12 practical ways to remove spaces in js_javascript skills

Implementation 1

Copy code The code is as follows:

String.prototype. trim = function() {
return this.replace(/^ss*/, '').replace(/ss*$/, '');
}

Look It doesn't look very good. It uses two regular replacements. The actual speed is very amazing, mainly due to the internal optimization of the browser. A famous example is string splicing. Direct addition is faster than StringBuffer made of Array. The base2 class library uses this implementation.

Implementation 2

Copy code The code is as follows:

String.prototype.trim = function() {
return this.replace(/^s /, '').replace(/s $/, '');
}

Very similar to implementation 1, but slightly slower, mainly because it first assumes that there is at least one whitespace character. Prototype.js uses this implementation, but its name is strip, because Prototype's methods strive to have the same name as Ruby.

Implementation 3

Copy code The code is as follows:

String.prototype.trim = function() {
return this.substring(Math.max(this.search(/S/), 0),this.search(/Ss*$/) 1);
}

Obtain the blank part by interception (of course, whitespace characters are allowed in the middle), and a total of four native methods are called. Very cleverly designed, substring takes two numbers as parameters. Math.max takes two numbers as parameters, and search returns one number. A little slower than the above two, but faster than most of the ones below.

Implementation 4

Copy code The code is as follows:

String.prototype.trim = function() {
return this.replace(/^s |s $/g, '');
}

This can be called A simplified version of Implementation 2 above is to use candidate operators to connect two regular expressions. But in doing so, you lose the opportunity for browser optimization, which is not as good as implementing 3. Because it looks elegant, many libraries use it, such as JQuery and mootools

implementation 5

Copy code The code is as follows:

String.prototype.trim = function() {
var str = this;
str = str.match(/S (? :s S )*/);
return str ? str[0] : '';
}

match returns an array, so the part of the original string that meets the requirements is Become an element of it. In order to prevent whitespace characters in the middle of the string from being excluded, we need to use non-capturing grouping (?:exp). Since the array may be empty, we have to make further decisions later. It seems that the browser is relatively weak in processing grouping, and one word is slow. So don't be superstitious about regularity, although it is basically omnipotent.

Implementation 6

Copy code The code is as follows:

String.prototype.trim = function() {
return this.replace(/^s*(S*(s S )*)s*$/, '$1');
}

Provide the parts that meet the requirements and put them into an empty string. However, the efficiency is very poor, especially in IE6.

Implementation 7

Copy code The code is as follows:

String.prototype.trim = function() {
return this.replace(/^s*(S*(?:s S )*)s*$/, '$1');
}

It is very similar to implementation 6, but uses non-capturing grouping to take advantage of it, and the performance efficiency is slightly improved.

Implementation 8

Copy code The code is as follows:

String.prototype.trim = function() {
return this.replace(/^s*((?:[Ss]*S)?)s*$/, '$1');
}

Improved along the above two ideas, using non-capturing groups and character sets, using ? instead of *, the effect is amazing. Especially in IE6, this performance improvement can be described as crazy, directly killing Firefox.

Implementation 9

Copy code The code is as follows:

String.prototype.trim = function() {
return this.replace(/^s*([Ss]*?)s*$/, '$1');
}

This time, lazy matching is used to replace non-capturing grouping, which has been improved in Firefox. IE is not as crazy as last time.

Implementation 10

Copy code The code is as follows:

String.prototype.trim = function() {
var str = this,
whitespace = 'nrtfx0bxa0u2000u2001u2002u2003u2004u2005u2006u2007u2008u2009u200au200bu2028u2029u3000' ;
for (var i = 0,len = str.length; i if (whitespace.indexOf(str.charAt(i)) === -1) {
str = str.substring(i);
break;
}
}
for (i = str.length - 1; i >= 0; i--) {
if (whitespace.indexOf(str.charAt(i)) === -1) {
str = str.substring(0, i 1);
break;
}
}
return whitespace.indexOf(str.charAt(0)) === -1 ? str : ' ';
}

I just want to say that the person who created this is no longer described as a cow, but is already at the level of a god. It first lists all possible whitespace characters, cuts off the preceding whitespace characters in the first traversal, and cuts off the following whitespace characters in the second pass. The whole process only uses indexOf and substring, which are native methods specifically designed for processing strings, and does not use regular expressions. The speed is astonishingly fast, it is estimated to be as close as the internal binary implementation, and it performs well in IE and Firefox (and other browsers, of course). The speed is zero milliseconds.

Implementation 11

Copy code The code is as follows:

String.prototype.trim = function() {
var str = this,
str = str.replace(/^s /, '');
for (var i = str.length - 1; i >= 0; i--) {
if (/S/.test(str.charAt(i))) {
str = str.substring(0, i 1);
break;
}
}
return str;
}

Implementation 10 has told us that the ordinary native string interception method is far better than regular replacement, although It's a little more complicated. But as long as the regular expression is not too complex, we can use the browser's optimization of the regular expression to improve program execution efficiency, such as achieving the performance of 8 in IE. I don't think anyone would usually use implementation 10 in a project because the whitespace implementation is too long and hard to remember (of course if you are building a class library, it is definitely the first). Implementation 11 can be said to be an improved version. The blanks in the front part are cut off by regular replacement, and the latter part is processed by native methods. The effect is not inferior to the original version, but the speed is extremely fast.

Implementation 12

Copy code The code is as follows:

String.prototype.trim = function() {
var str = this,
str = str.replace(/^ss*/, ''),
ws = /s/,
i = str.length;
while (ws.test(str.charAt(--i)));
return str.slice(0, i 1);
}

Implementation 10 and Implementation 11 are better and improved versions in terms of writing. Note that it is not about performance and speed, but about ease of memory and use. Both its two predecessors are at the zero millisecond level. I will use this for work and intimidation in the future.