Dans le navigateur IE 7 8, si vous utilisez l'attribut TRIM () pour supprimer les espaces, une erreur sera signalée.
Par conséquent, il existe les solutions suivantes à 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, alors utilisez celui introduit ci-dessous. Le premier a été testé.
Le groupe W3C de personnes a été botté dans les têtes par Donkeys, et ils n'ont pas pris en charge les fonctions de finition (et trimbleft, trimRight) avant le script Java 1.8.1. Malheureusement, seul Firefox3.5 le soutient maintenant. Étant donné que l'élimination des blancs des deux côtés des cordes est trop courante, toutes les grandes bibliothèques ont leurs propres ombres. De plus, les étrangers ont beaucoup d'énergie de recherche et ont fait beaucoup de réalisations.
Implémentez 1 ok. (Écrivez ceci dans JS, puis suivez la chaîne que vous souhaitez supprimer l'espace directement.trim ())
La copie de code est la suivante:
String.prototype.trim = function () {
Renvoie ce .replace (/ ^ / s / s * /, '') .replace (// s / s * $ /, '');
}
Il n'a pas l'air très bien et j'ai utilisé deux remplacements réguliers. La vitesse réelle est incroyable, principalement en raison de l'optimisation interne du navigateur. Un exemple célèbre d'épissage de chaîne, l'ajout direct est plus rapide qu'un bernard en baby. La bibliothèque de classe Base2 applique cette implémentation.
Mettre en œuvre 2
La copie de code est la suivante:
String.prototype.trim = function () {
Renvoie ce .replace (/ ^ / s /, '') .replace (// s $ /, '');
}
Il est très similaire à la mise en œuvre 1, mais un peu plus lent, la raison principale est qu'elle suppose d'abord qu'il y a au moins un espace blanc. Prototype.js utilise cette implémentation, mais son nom est Strip, car les méthodes de prototype tentent de le renommer avec Ruby.
Implémentation 3
La copie de code est la suivante:
String.prototype.trim = function () {
Renvoie ceci .SubString (math.max (this .search (// s /), 0), this .search (// s / s * $ /) 1);
}
La partie vide est obtenue en interceptant (bien sûr, les caractères des espaces blancs sont autorisés au milieu), et un total de 4 méthodes natives sont appelées. Le préréglage est très intelligent, la sous-chaîne prend deux nombres comme paramètres. Math.Max utilise deux nombres comme paramètres et la recherche revient à un numéro. La vitesse est un peu plus lente que les deux premières, mais elle est beaucoup plus rapide que le fond.
Mettre en œuvre 4
La copie de code est la suivante:
String.prototype.trim = function () {
returnThis .replace (/ ^ / s | / s $ / g, '');
}
Cela peut être appelé une version simplifiée de l'implémentation 2, qui est d'utiliser des opérateurs de candidats pour connecter deux régularités. Mais cela ne parviendra pas à réaliser des opportunités d'optimisation du navigateur, ce qui n'est pas aussi bon que la réalisation 3. Parce qu'il semble élégant, de nombreuses applications de bibliothèque telles que jQuery et Mootools
Mettre en œuvre 5
La copie de code est la suivante:
String.prototype.trim = function () {
var str = this;
str = str.match (// s (?: / s / s) * /);
Retour Str? str [0]: '';
}
La correspondance est de revenir à un tableau, et la pièce qui répond aux exigences de la chaîne d'origine devient son élément. Afin d'éviter que l'espace vierge au milieu de la chaîne soit déconnecté, nous devons utiliser le regroupement non capture (?: Exp). Étant donné que le tableau peut être vide, nous devons porter plus de jugements plus tard. Il semble que le navigateur soit moins puissant dans les groupes de traitement et un mot est plus lent. Alors ne soyez pas superstitieux sur les règles, bien que ce soit fondamentalement omnipotent.
Implémentation 6
La copie de code est la suivante:
String.prototype.trim = function () {
Renvoie ce .replace (/ ^ / s * (/ s * (/ s / s) *) / s * $ /, '$ $');
}
Fournissez la pièce requise et placez-la dans une chaîne vide. Mais l'efficacité est très médiocre, surtout dans IE6.
Implémentation 7
La copie de code est la suivante:
String.prototype.trim = function () {
Renvoie ce .replace (/ ^ / s * (/ s * (?: / s / s) *) / s * $ /, '$ 1');
}
Il est très similaire à la mise en œuvre 6, mais il utilise des paquets non captureux pour fournir des avantages, et l'efficacité des performances est légèrement améliorée.
Implémentation 8
La copie de code est la suivante:
String.prototype.trim = function () {
Renvoie ce .replace (/ ^ / s * ((?: [/ s / s] * / s)?) / s * $ /, '$ 1');
}
J'ai amélioré les deux idées ci-dessus, utilisé des ensembles de groupement et de caractères non capturant, et remplacé par ?, Ce qui était incroyable. Surtout dans IE6, la folie peut être utilisée pour décrire cette amélioration des performances et tuer directement Firefox en quelques secondes.
Mettre en œuvre 9
La copie de code est la suivante:
String.prototype.trim = function () {
Renvoie ce .replace (/ ^ / s * ([/ s / s] *?) / s * $ /, '1 $');
}
Cette fois, j'ai utilisé une correspondance paresseuse pour remplacer le regroupement non capturant, qui a été amélioré dans Firefox, et IE n'était pas aussi fou que la dernière fois.
Réaliser 10
La copie de code est la suivante:
String.prototype.trim = function () {
var str = ceci,
Whitespace = '/ n / r / t / f / x0b / xa0 / u2000 / u2001 / u2002 / u2003 / u2004 / u2020 05 / u2006 / u2007 / u2008 / u2009 / u200a / u200b / u2028 / u2029 / u3000';
pour (var i = 0, len = str.length; i = 0; i--) {
if (whitepace.indexof (str.charat (i)) === -1) {
str = str.substring (0, i 1);
casser;
}
}
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 au même niveau qu'un Dieu. Il répertorie d'abord tous les caractères vides possibles, coupe le blanc avant dans la première traversée et coupe le blanc arrière pour la deuxième fois. L'ensemble du processus utilise uniquement l'index et la sous-chaîne, une méthode native spécialement conçue pour le traitement des chaînes, et n'applique pas la régularité. La vitesse est incroyablement rapide, et il devrait être proche de la mise en œuvre binaire interne, et il a des performances exceptionnelles dans IE et Firefox (bien sûr, d'autres navigateurs sont sans aucun doute). Les vitesses sont toutes de zéro millisecondes en plus.
Mettre en œuvre 11
La copie de code est la suivante:
String.prototype.trim = function () {
var str = ceci,
str = str.replace (/ ^ / s /, '');
pour (var i = str.length - 1; i> = 0; i--) {
if (//s/.test(str.charat(i))) {
str = str.substring (0, i 1);
casser;
}
}
retour STR;
}
La mise en œuvre 10 nous a dit que la méthode d'interception normale des cordes qui est à l'origine inconnue est bien meilleure que le remplacement ordinaire, bien qu'il soit un peu plus compliqué. Mais tant que la régularité n'est pas trop compliquée, nous pouvons utiliser le navigateur pour optimiser la régularité afin d'améliorer l'efficacité de l'exécution du programme et d'obtenir 8 performances dans IE. Je ne pense pas que quiconque applique normalement la mise en œuvre 10 dans un projet, car cette implémentation de l'espace est trop longue et difficile à retenir (bien sûr, si vous construisez une bibliothèque de classe, cela commencera certainement). La mise en œuvre 11 peut être considérée comme sa version améliorée. Les blancs à l'avant sont coupés par un remplacement régulier. Ils sont traités avec des méthodes natives plus tard. L'effet n'est pas inférieur à la version originale, mais la vitesse est incroyable.
Mettre en œuvre 12
La copie de code est la suivante:
String.prototype.trim = function () {
var str = ceci,
str = str.replace (/ ^ / s / s * /, ''),
ws = // s /,
i = str.length;
while (ws.Test (str.charat (- i)));
return str.slice (0, i 1);
}
La meilleure version d'amélioration de l'implémentation 10 et de l'implémentation 11 est écrite. Notez qu'il ne s'agit pas de vitesse de performance, mais de facilité de mémoire et d'application. Et ses deux prédécesseurs ne sont pas de zéro millisecondes en outre, ils l'utiliseront pour travailler et effrayer les gens à l'avenir.
Ce qui suit est le résultat de comparaison donné par les étrangers. L'arrière-plan d'exécution consiste à effectuer des opérations de finition sur cet article (plus de 27 600 caractères).
Implémenter Firefox 2 IE 6
TRIM1 15MS TRIM2 31 ms TRIM3 46ms 31 ms
Trim4 47ms 46ms
TRIM5 156ms 1656 ms
Trim6 172ms 2406ms
TRIM7 172MS 1640M
TRIM8 281 ms TRIM9 125 ms 78 ms
TRIM10 TRIM11 TRIM12 TRIM La fonction implémentation révèle vos propres idées. Si vous voulez comprendre ce que l'auteur original a dit, veuillez lire le texte original.
Il existe actuellement 12 méthodes pour éliminer les espaces dans JS:
Mettre en œuvre 1
String.prototype.trim = function () {return this.replace (/ ^ / s / s * /, '') .replace (// s / s * $ /, ''); }
Mettre en œuvre 2
String.prototype.trim = function () {return this.replace (/ ^ / s + /, '') .replace (// s + $ /, ''); }
Implémentation 3
String.prototype.trim = function () {return this.s String (math.max (this.search (// s /), 0), this.search (// s / s * $ /) + 1); }
Mettre en œuvre 4
String.prototype.trim = function () {return this.replace (/ ^ / s + | / s + $ / g, ''); }
String.prototype.trim = function () {var str = this; str = str.match (// s + (?: / s + / s +) * /); Retour Str? str [0]: ''; }
String.prototype.trim = function () {return this.replace (/ ^ / s * (/ s * (/ s + / s +) *) / s * $ /, '$ 1'); }
Implémentation 7
String.prototype.trim = function () {return this.replace (/ ^ / s * (/ s * (?: / S + / s +) *) / s * $ /, '$ 1'); }
String.prototype.trim = function () {return this.replace (/ ^ / s * ((?: [/ S / s] * / s)?) / S * $ /, '$ $'); }
String.prototype.trim = function () {return this.replace (/ ^ / s * ([/ s / s] *?) / S * $ /, '$ 1'); }
String.prototype.trim = function () {var str = this, Whitespace = ' / n / r / t / f / x0b / xa0 /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? /? pour (var i = 0, len = str.length; i <len; i ++) {if (whitespace.indexof (str.charat (i)) === -1) {str = str.s String (i); casser; }} pour (i = str.length - 1; i> = 0; i--) {if (whitespace.indexof (str.charat (i)) === -1) {str = str.s String (0, i + 1); casser; }} return whitespace.indexof (str.charat (0)) === -1? str: ''; }
Mettre en œuvre 11
String.prototype.trim = function () {var str = this, str = str.replace (/ ^ / s + /, ''); pour (var i = str.length - 1; i> = 0; i--) {if (//s/.test(str.charat(i))) {str = str.s String (0, i + 1); casser; }} return str; }
Mettre en œuvre 12
String.prototype.trim = function () {var str = this, str = str.replace (/ ^ / s / s * /, ''), ws = // s /, i = str.length; while (ws.Test (str.charat (- i))); return str.slice (0, i + 1); }
Il n'a pas l'air très bien et j'ai utilisé deux remplacements réguliers, et la vitesse réelle est incroyable, principalement en raison de l'optimisation interne du navigateur. Un exemple célèbre d'épissage de chaîne, qui est plus rapide que Stringb? R fait de tableau. La bibliothèque de classe Base2 utilise cette implémentation.
Il est très similaire à la mise en œuvre 1, mais un peu plus lent, principalement parce qu'il suppose d'abord qu'il y a au moins un espace blanc. Prototype.js utilise cette implémentation, mais son nom est Strip, car la méthode Prototype s'efforce d'avoir le même nom que R Y.
La partie vierge est obtenue en interceptant (bien sûr, le caractère blanc est autorisé au milieu), et un total de quatre méthodes natives sont appelées. Il est conçu très intelligemment et la chaîne S prend deux nombres comme paramètres. Math.Max prend deux nombres en tant que 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 ci-dessous.
Cela peut être appelé une version simplifiée de l'implémentation 2, qui est d'utiliser des opérateurs de candidats pour connecter deux règles. Mais cela perdra l'occasion d'optimiser le navigateur, qui n'est pas aussi bon que la réalisation 3. Parce qu'il semble élégant, de nombreuses bibliothèques de classe l'utilisent, comme JQ Ry et Mootools
Mettre en œuvre 5
Match renvoie un tableau, donc la partie de la chaîne d'origine qui répond aux exigences devient son élément. Afin d'empêcher l'exclusion de l'espace blanc au milieu de la chaîne, nous devons utiliser le regroupement non capturant (?: Exp). Étant donné que le tableau peut être vide, nous devons porter plus de jugements plus tard. Il semble que le navigateur soit faible dans les groupes de traitement, et un mot est lent. Alors ne soyez pas superstitieux sur les règles, bien que ce soit fondamentalement omnipotent.
Implémentation 6
Fournissez la pièce requise et placez-la dans une chaîne vide. Mais l'efficacité est très médiocre, surtout dans IE6.
Il est très similaire à la mise en œuvre 6, mais il utilise des paquets non captureux pour fournir des avantages, et l'efficacité des performances est légèrement améliorée.
Implémentation 8
J'ai amélioré les deux idées ci-dessus, utilisé des ensembles de groupement et de caractères non capturant, et remplacé *?, Ce qui était très incroyable. Surtout dans IE6, la folie peut être utilisée pour décrire cette amélioration des performances et tuer directement Firefox en quelques secondes.
Mettre en œuvre 9
Cette fois, j'ai utilisé une correspondance paresseuse pour remplacer le regroupement non capturant, qui a été amélioré dans Firefox, et IE n'était pas aussi fou que la dernière fois.
Réaliser 10
Je veux juste dire que la personne qui a créé cela n'est plus décrite comme une vache, mais est au même niveau qu'un Dieu. Il répertorie d'abord tous les blancs possibles, coupe les blancs avant dans la première traversée et coupe les blancs arrière pour la deuxième fois. L'ensemble du processus utilise uniquement l'index et la chaîne S, une méthode native spécialement conçue pour le traitement des chaînes et n'utilise pas la régularité. La vitesse est incroyablement rapide, probablement proche de la mise en œuvre binaire interne, et elle a de bonnes performances dans IE et Firefox (bien sûr, les autres navigateurs sont sans aucun doute). La vitesse est tout à zéro millisecondes.
La mise en œuvre 10 nous a dit que la méthode normale d'interception des chaînes natives est bien meilleure que le remplacement ordinaire, bien qu'elle soit un peu plus compliquée. Mais tant que la régularité n'est pas trop compliquée, nous pouvons utiliser le navigateur pour optimiser la régularité afin d'améliorer l'efficacité de l'exécution du programme, comme atteindre 8 performances dans IE. Je ne pense pas que quiconque applique normalement la mise en œuvre 10 dans un projet, car cette implémentation de l'espace est trop longue et difficile à retenir (bien sûr, si vous construisez une bibliothèque de classe, c'est certainement le premier). La mise en œuvre 11 peut être considérée comme sa version améliorée. Les blancs de la première partie sont coupés par un remplacement régulier, et le traitement ultérieur est effectué par des méthodes natives. L'effet n'est pas inférieur à la version originale, mais la vitesse est très incroyable.
La meilleure version d'amélioration de la méthode d'écriture de l'implémentation 10 et de l'implémentation 11 ne concerne pas la vitesse de performance, mais la mémoire et l'utilisation faciles. Et ses deux prédécesseurs sont à un niveau de zéro milliseconde, donc je vais l'utiliser pour travailler et faire peur à l'avenir.