Dans les navigateurs IE 7 et 8, si vous utilisez l'attribut trim() pour supprimer des espaces, une erreur sera signalée.
Il existe donc les solutions suivantes pour résoudre ce problème :
var aa = $("#id").val().trim() --- La méthode trim() ne peut pas être analysée dans IE
Solution :
[ var aa = $.trim($("#id").val()); Ce n'est pas facile à utiliser, utilisez donc celui présenté ci-dessous. Le premier a été testé.
Les têtes des gens du W3C ont été frappées par des ânes. Ce n'est qu'avec javascript1.8.1 que la fonction trim (avec trimLeft, trimRight) a été prise en charge. Malheureusement, seul Firefox3.5 la prend en charge désormais. Étant donné que la suppression des espaces des deux côtés d’une chaîne est si courante, on la trouve dans toutes les principales bibliothèques. De plus, les étrangers sont très énergiques dans la recherche et ont créé de nombreuses implémentations.
Réalisez 1 OK . (Écrivez ceci en js, puis suivez .trim() directement après la chaîne dans laquelle vous souhaitez supprimer les espaces)
String.prototype.trim = function () {
renvoie ceci .replace(/^ss*/, '' ).replace(/ss*$/, '' );
}
Cela n'a pas l'air très bien. Il utilise deux remplacements réguliers. La vitesse réelle est incroyable, principalement en raison de l'optimisation interne du navigateur. Un exemple célèbre est l'épissage de chaînes. L'ajout direct est plus rapide que StringBuffer constitué de Array. La bibliothèque de classes base2 utilise cette implémentation.
Mise en œuvre 2
String.prototype.trim = function () {
renvoie ceci .replace(/^s /, '' ).replace(/s $/, '' );
}
est très similaire à l'implémentation 1, mais légèrement plus lente, principalement parce qu'elle suppose d'abord qu'il y a au moins un caractère d'espacement. Prototype.js utilise cette implémentation, mais son nom est strip, car les méthodes de Prototype s'efforcent d'avoir le même nom que Ruby.
Atteindre 3
String.prototype.trim = function () {
returnthis .substring(Math.max( this .search(/S/), 0), this .search(/Ss*$/) 1);
}
Obtenez la partie vierge par interception (bien sûr, les espaces sont autorisés au milieu), et un total de 4 méthodes natives sont appelées. La valeur par défaut est très intelligente, la sous-chaîne prend deux nombres comme paramètres. Math.max prend deux nombres comme paramètres et la recherche renvoie un nombre. La vitesse est un peu plus lente que les deux ci-dessus, mais plus rapide que la plupart de celles ci-dessous.
Atteindre 4
String.prototype.trim = function () {
returnthis .replace(/^s |s $/g, '' );
}
Cela peut être appelé une version simplifiée de l'implémentation 2, qui utilise des opérateurs candidats pour connecter deux expressions régulières. Mais cela manquerait l’opportunité d’optimisation du navigateur, qui est inférieure à l’implémentation 3. Parce qu'il a l'air très élégant, de nombreuses bibliothèques l'utilisent, comme JQuery et mootools
Atteindre 5
String.prototype.trim = function () {
var str = this ;
str = str.match(/S (?:s S )*/);
return str ? >
match renvoie un tableau, de sorte que les parties de la chaîne d'origine qui répondent aux exigences deviennent ses éléments. Afin d'éviter que les caractères d'espacement au milieu de la chaîne ne soient éliminés, nous devons utiliser un regroupement sans capture (?:exp). Le tableau étant peut-être vide, nous porterons d’autres jugements plus tard. Il semble que le navigateur soit relativement faible dans le traitement du regroupement et qu'un mot soit lent. Ne soyez donc pas superstitieux à propos de la régularité, même si elle est fondamentalement omnipotente.
Atteindre 6
String.prototype.trim = function () {
renvoie ceci .replace(/^s*(S*(s S )*)s*$/, '$1' );
}
Fournissez les pièces qui répondent aux exigences et placez-les dans une chaîne vide. Cependant, l’efficacité est très médiocre, notamment sous IE6.
Atteindre 7
String.prototype.trim = function () {
renvoie ceci .replace(/^s*(S*(?:s S )*)s*$/, '$1' );
}
Elle est très similaire à l'implémentation 6, mais utilise un regroupement sans capture pour en tirer parti, et l'efficacité des performances est légèrement améliorée.
Atteindre 8
String.prototype.trim = function () {
renvoie ceci .replace(/^s*((?:[Ss]*S)?)s*$/, '$1' );
}
Amélioré selon les deux idées ci-dessus, en utilisant des groupes et des jeux de caractères non capturants, et en utilisant à la place de *. L'effet est incroyable. Surtout dans IE6, cette amélioration des performances peut être qualifiée de folle, tuant directement Firefox.
Mise en œuvre 9
String.prototype.trim = function () {
renvoie ceci .replace(/^s*([Ss]*?)s*$/, '$1' );
}
Cette fois, la correspondance paresseuse est utilisée pour remplacer les groupes non capturants, ce qui a été amélioré dans Firefox, IE n'est pas aussi fou que la dernière fois.
Atteindre 10
String.prototype.trim = function () {
var str = this ,
espace blanc = 'nrtfx0bxa0u2000u2001u2002u2003u2004u20 05u2006u2007u2008u2009u200au200bu2028u2029 u3000' ;
pour ( var i = 0 ,len = str.length; 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 : '' ;
}
Je veux juste dire que la personne qui a créé cela n'est plus décrite comme une vache, mais est déjà au niveau d'un dieu. Il répertorie d'abord tous les caractères d'espacement possibles, coupe l'espace de début lors du premier parcours et coupe l'espace suivant lors de la deuxième passe. L'ensemble du processus utilise uniquement indexOf et substring, qui sont des méthodes natives spécifiquement conçues pour le traitement des chaînes, et aucune règle régulière n'est utilisée. La vitesse est étonnamment rapide et devrait être aussi proche de celle de l'implémentation binaire interne, et offrira des performances exceptionnelles dans IE et Firefox (et d'autres navigateurs, bien sûr). La vitesse est de zéro milliseconde.
Atteindre 11
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;
}
L'implémentation 10 nous a dit que la méthode ordinaire d'interception de chaînes inconnues est bien meilleure que le remplacement régulier, même si elle est un peu plus compliquée. Mais tant que l'expression régulière n'est pas trop compliquée, nous pouvons utiliser l'optimisation de l'expression régulière par le navigateur pour améliorer l'efficacité de l'exécution du programme et atteindre 8 performances dans IE. Je pense que généralement personne n'utilisera l'implémentation 10 dans ses projets, car l'implémentation des espaces est trop longue et difficile à retenir (bien sûr, si vous construisez une bibliothèque de classes, c'est certainement la première). L'implémentation 11 peut être considérée comme une version améliorée. L'espace blanc dans la partie avant est coupé par remplacement régulier, et cette dernière partie est traitée par des méthodes natives. L'effet n'est pas inférieur à la version originale, mais la vitesse est très. incroyable.
Atteindre 12
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);
}
实现10与实现11在写法上更好的改进版,注意说的不是性能速度,而是易记与施用上。和它的两个先辈都是零毫秒级另外,以后就用这个来工作与吓人。
下面是老外给出的比力结果,执行背景是对Magna Carta 这文章(超过27,600字符)进行trim操作。
实现 Firefox 2 IE 6
trim1 15ms trim2 31ms trim3 46ms 31ms
trim4 47ms 46ms
trim5 156ms 1656ms
trim6 172ms 2406ms
trim7 172ms 1640ms
trim8 281ms trim9 125ms 78ms
trim10 trim11 trim12 trim函数实现揭晓自己的想法,想懂得原作者说什么请看原文。
JS去除空格的方法目前共有12种 :
实现1
String.prototype.trim = function() { return this.replace(/^ss*/, '' ).replace(/ss*$/, ''); }
实现2
String.prototype.trim = function() { return this.replace(/^s /, '').replace(/s $/, ''); }
实现3
String.prototype.trim = function() { return this.s string(Math.max(this.search(/S/), 0),this.search(/Ss*$/ ) 1); }
实现4
String.prototype.trim = function() { return this.replace(/^s |s $/g, ''); }
String.prototype.trim = function() { var str = this; str = str.match(/S (?:s S )*/); retourner str ? str[0] : ''; }
String.prototype.trim = function() { return this.replace(/^s*(S*(s S )*)s*$/, '$1'); }
实现7
String.prototype.trim = function() { return this.replace(/^s*(S*(?:s S )*)s*$/, '$1'); }
String.prototype.trim = function() { return this.replace(/^s*((?:[Ss]*S)?)s*$/, '$1'); }
String.prototype.trim = function() { return this.replace(/^s*([Ss]*?)s*$/, '$1'); }
String.prototype.trim = function() { var str = this, whitespace = 'nrtfx0bxa0??????????????? '; for (var i = 0,len = str.length; i < len; i ) { if (whitespace.indexOf(str.charAt(i)) === -1) { str = str.s string(i) ; casser; } } for (i = str.length - 1; i >= 0; i--) { if (whitespace.indexOf(str.charAt(i)) === -1) { str = str.s string( 0, je 1); casser; } } return whitespace.indexOf(str.charAt(0)) === -1 ? chaîne : ''; }
实现11
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.s string(0, i 1 ); casser; } } return str; }
实现12
String.prototype.trim = function() { var str = this, str = str.replace(/^ss*/, ''), ws = /s/, i = str. longueur; while (ws.test(str.charAt(--i))); return str.slice(0, i 1); }
看起来不怎么样， 动用了两次正则替换，实际速度非常惊人，主要得益于浏览器的内一个著名的例子字符串拼接，加比用Array做
和实现1 很相似，但稍慢一点，主要原因是它最先是假设至少存在一个空白符。Prototype.js使用
以截取方式取得空白部分（当然允许中间存在空白符），总共 调用了四个原生方法。Math.max以两个数字作参数，search则返回一个数字。速度比上 面两个慢一点，但比下面大多数都快。 这个可以称得上实现2的简化版，就是 利用候选操作符连接两个正则。但这样做就失去了浏览器优化的机会，比不上实现3。由于看来很优雅，许多类库都使用它，如JQ ry与mootools
实现5
match 是返回一个数组，因此原字符串符合要求的郄都分就成为它的元素。为了防止字符串中间的空白符被排除，我们需要动用到非捕获性分组（?:exp）。由于数组可 能为空，我们在后面还要做进一步的判定。好像浏览器在处理分组上比较无力，一个字虽然它基本上是万能的。
实现6
把符合要求的部分提供出来，放到一个空字符串中。不过效率很差，
和实现6很相似，但用了非捕获分组进行了优点，性能效之有一点点提升。
实现8
尤其IE6中，可 以用疯狂来形容这次性能的提升，直接秒杀火狐。
实现9
这次是用懒惰匹配 顶替非捕获分组，在火狐中得到改善，IE没有上次那么疯狂。
实现10
我 只想说，搞出这个的人已经不是用牛来形容，已是神一样的级别。它先是把可能的空白符全部列出来，在第一次遍历中砍掉前面的空白，第二次砍掉后面的空白。全 过程只用了indexOf与s string这个专门为处理字符串而生的原生方法,没有使用到正则。速度快得惊人，估计直逼上内部的二进制实现，并且在IE与火狐（其他浏览器当然也毫无疑问）都有良好的表现。速度都是零毫秒级别的。
实现10 jours de voyage替换，虽然是复杂一点。但只要正则 不过于复杂，我们就可以利用浏览器对正则的优化，改善程序执行效率，如实现8 et IE的表现。我想通常不会有人在项目中应用实现10 ，因为那个 whitespace 实现太长太难记了（当然如果你在打造一个类库，它绝对是首先）。L'implémentation 11 peut être considérée comme une version améliorée. Les blancs de la partie avant sont coupés par remplacement régulier, et cette dernière partie est traitée par des méthodes natives. L'effet n'est pas inférieur à la version originale, mais la vitesse est très incroyable. .
Implementation 10 et Implementation 11 sont des versions meilleures et améliorées en termes d'écriture. Notez qu'il ne s'agit pas de performances et de vitesse, mais de facilité de mémoire et d'utilisation. Ses deux prédécesseurs sont au niveau zéro milliseconde. Je l'utiliserai à l'avenir pour le travail et l'intimidation.
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
