En el navegador IE 7 8, si usa el atributo TRIM () para eliminar los espacios, se informará un error.
Por lo tanto, existen las siguientes soluciones a este problema:
var aa = $ ("#id"). Val (). Trim () --- El método TRIM () no se puede analizar en IE
Solución:
[var aa = $ .trim ($ ("#id"). val ()); ] Esto no es fácil de usar, así que use el que se introduce a continuación. El primero ha sido probado.
El grupo W3C de personas fue pateado en las cabezas por burros, y no admitieron funciones de TRIM (y Trimleft, Trimright) hasta Java Script 1.8.1. Desafortunadamente, solo Firefox3.5 lo apoya ahora. Dado que eliminar en blanco en ambos lados de las cuerdas es demasiado común, todas las bibliotecas principales tienen sus propias sombras. Además, los extranjeros tienen mucha energía de investigación y han logrado muchos logros.
Implementar 1 OK. (Escriba esto en JS y luego siga la cadena que desea eliminar el espacio directamente.trim ())
La copia del código es la siguiente:
String.prototype.trim = function () {
devuelve este .replace (/^/s/s*/, '') .replace (// s/s*$/, '');
}
No se ve muy bien, y utilicé dos reemplazos regulares. La velocidad real es sorprendente, principalmente debido a la optimización interna del navegador. Un famoso ejemplo de empalme de cuerdas, la adición directa es más rápida que un stringbuffer hecho de matriz. La biblioteca de clase Base2 aplica esta implementación.
Implementar 2
La copia del código es la siguiente:
String.prototype.trim = function () {
devuelve este .replace (/^/s/, '') .replace (// s $/, '');
}
Es muy similar a la implementación 1, pero un poco más lento, la razón principal es que primero supone que hay al menos un espacio en blanco. Prototype.js usa esta implementación, pero su nombre es Strip, porque los métodos de prototipo intentan cambiar el nombre de Ruby.
Implementación 3
La copia del código es la siguiente:
String.prototype.trim = function () {
Devuelve esto .substring (Math.max (this .search (// s/), 0), this .search (// s/s*$/) 1);
}
La parte en blanco se obtiene interceptando (por supuesto, los caracteres en blanco se permiten en el medio), y se llama a un total de 4 métodos nativos. El preajuste es muy inteligente, la subcadena toma dos números como parámetros. Math.max usa dos números como parámetros, y la búsqueda vuelve a un número. La velocidad es un poco más lenta que las dos superiores, pero es mucho más rápida que la parte inferior.
Implementar 4
La copia del código es la siguiente:
String.prototype.trim = function () {
returnThis .replace (/^/s |/s $/g, '');
}
Esto se puede llamar una versión simplificada de la implementación 2, que es utilizar operadores candidatos para conectar dos regularidades. Pero hacerlo no logrará lograr oportunidades de optimización del navegador, que no es tan bueno como la realización 3. Debido a que parece elegante, muchas aplicaciones de biblioteca como jQuery y Mootols
Implementar 5
La copia del código es la siguiente:
String.prototype.trim = function () {
var str = this;
str = str.match (// s (?:/s/s)*/);
¿RETURN STR? str [0]: '';
}
La coincidencia es volver a una matriz, y la parte que cumple con los requisitos de la cadena original se convierte en su elemento. Para evitar que el espacio en blanco en el medio de la cuerda se desconecte, necesitamos usar agrupación no captada (?: Exp). Dado que la matriz puede estar vacía, necesitamos hacer más juicios más tarde. Parece que el navegador es menos poderoso en las agrupaciones de procesamiento, y una palabra es más lenta. Así que no seas supersticioso sobre las reglas, aunque es básicamente omnipotente.
Implementación 6
La copia del código es la siguiente:
String.prototype.trim = function () {
Devuelve este .replace (/^/s*(/s*(/s/s/s)*)/s*$/, '$ 1');
}
Proporcione la parte requerida y póngala en una cadena vacía. Pero la eficiencia es muy pobre, especialmente en IE6.
Implementación 7
La copia del código es la siguiente:
String.prototype.trim = function () {
Devuelve este .replace (/^/s*(/s*(?:/s/s)*)/s*$/, '$ 1');
}
Es muy similar a la implementación 6, pero utiliza paquetes no captados para proporcionar ventajas, y la eficiencia del rendimiento ha mejorado ligeramente.
Implementación 8
La copia del código es la siguiente:
String.prototype.trim = function () {
Devuelve este .replace (/^/s*((?: [/s/s]*/s)?)/S*$/, '$ 1');
}
Mejoré las dos ideas anteriores, utilicé la agrupación no capturante y los conjuntos de personajes, y reemplazé * con?, Lo cual fue increíble. Especialmente en IE6, la locura se puede usar para describir esta mejora del rendimiento y matar directamente a Firefox en segundos.
Implementar 9
La copia del código es la siguiente:
String.prototype.trim = function () {
Devuelve este .replace (/^/s*([/s/s]*?)/S*$/, '$ 1');
}
Esta vez, utilicé la coincidencia perezosa para reemplazar la agrupación no capturante, que mejoró en Firefox, y IE no estaba tan loca como la última vez.
Date cuenta 10
La copia del código es la siguiente:
String.prototype.trim = function () {
var str = esto,
Whitespace = '/n/r/t/f/x0b/xa0/u2000/u2001/u2002/u2003/u2004/u2020 05/u2006/u2007/u2008/u2009/u200a/u200b/u2028/u2029/u3000';
para (var i = 0, len = str.length; i = 0; i--) {
if (whitespace.indexof (str.charat (i)) === -1) {
str = str.substring (0, i 1);
romper;
}
}
return whitespace.indexof (str.charat (0)) === -1? str: '';
}
Solo quiero decir que la persona que creó esto ya no se describe como una vaca, sino que está al mismo nivel que un Dios. Primero enumera todos los personajes en blanco posibles, corta el espacio en blanco delantero en el primer recorrido y corta la parte posterior en blanco por segunda vez. Todo el proceso solo utiliza índices y subcadenas, un método nativo especialmente diseñado para cadenas de procesamiento, y no aplica la regularidad. La velocidad es increíblemente rápida, y se espera que esté cerca de la implementación binaria interna, y tiene un rendimiento sobresaliente en IE y Firefox (por supuesto, otros navegadores son sin duda). Las velocidades son todos milisegundos cero además.
Implementar 11
La copia del código es la siguiente:
String.prototype.trim = function () {
var str = esto,
str = str.replace (/^/s/, '');
para (var i = str.length-1; i> = 0; i--) {
if (//s/.test(str.charat(i)) {
str = str.substring (0, i 1);
romper;
}
}
regresar str;
}
La implementación 10 nos ha dicho que el método de intercepción de cadena normal que originalmente es desconocido es mucho mejor que el reemplazo regular, aunque es un poco más complicado. Pero mientras la regularidad no sea demasiado complicada, podemos usar el navegador para optimizar la regularidad para mejorar la eficiencia de la ejecución del programa y lograr un rendimiento de 8 en IE. No creo que nadie aplique normalmente la implementación 10 en un proyecto, porque esa implementación en blanco es demasiado larga y difícil de recordar (por supuesto, si está construyendo una biblioteca de clase, definitivamente comenzará). Se puede decir que la implementación de 11 es su versión mejorada. Los espacios en blanco en el frente están cortados por reemplazo regular. Se tratan con métodos nativos más tarde. El efecto no es inferior a la versión original, pero la velocidad es sorprendente.
Implementar 12
La copia del código es la siguiente:
String.prototype.trim = function () {
var str = esto,
str = str.replace (/^/s/s*/, ''),
ws = // s/,
i = str.length;
while (ws.test (str.charat (-i)));
return str.slice (0, i 1);
}
Se escribe la mejor versión de mejora de la implementación 10 y la implementación 11. Tenga en cuenta que no se trata de la velocidad de rendimiento, sino de la facilidad de memoria y aplicación. Y sus dos predecesores son cero milisegundos, además, lo usarán para trabajar y asustar a las personas en el futuro.
El siguiente es el resultado de comparación dado por los extranjeros. El fondo de ejecución es realizar operaciones de equipamiento en este artículo (más de 27,600 caracteres).
Implementar 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 La implementación de la función TRIM revela sus propias ideas. Si desea comprender lo que dijo el autor original, lea el texto original.
Actualmente hay 12 métodos para eliminar espacios en JS:
Implementar 1
String.prototype.trim = function () {return this.replace (/^/s/s*/, '') .replace (// s/s*$/, ''); }
Implementar 2
String.prototype.trim = function () {return this.replace (/^/s+/, '') .replace (// s+$/, ''); }
Implementación 3
String.prototype.trim = function () {return this.s string (math.max (this.search (// s/), 0), this.search (// s/s*$/) + 1); }
Implementar 4
String.prototype.trim = function () {return this.replace (/^/s+|/s+$/g, ''); }
String.prototype.trim = function () {var str = this; str = str.match (// s+(?:/s+/s+)*/); ¿RETURN STR? str [0]: ''; }
String.prototype.trim = function () {return this.replace (/^/s*(/s*(/s+/s+)*)/s*$/, '$ 1'); }
Implementación 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*$/, '$ 1'); }
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/?/?/?/?/?/?/?/?/?/?/?/?/?/?/?/?/? for (var i = 0, len = str.length; i <len; i ++) {if (whitespace.indexof (str.charat (i)) === -1) {str = str.s string (i); romper; }} para (i = str.length -1; i> = 0; i--) {if (whitespace.indexof (str.charat (i)) === -1) {str = str.s string (0, i + 1); romper; }} return whitespace.indexof (str.charat (0)) === -1? str: ''; }
Implementar 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); romper; }} return str; }
Implementar 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); }
No se ve muy bien, y utilicé dos reemplazos regulares, y la velocidad real es sorprendente, principalmente debido a la optimización interna del navegador. Un famoso ejemplo de empalme de cuerdas, que es más rápido que Stringb? R hecho de matriz. La biblioteca de clase Base2 utiliza esta implementación.
Es muy similar a la implementación 1, pero un poco más lento, principalmente porque primero supone que hay al menos un espacio en blanco. Prototype.js usa esta implementación, pero su nombre es Strip, porque el método prototipo se esfuerza por tener el mismo nombre que R y.
La parte en blanco se obtiene interceptando (por supuesto, el carácter de espacio en blanco está permitido en el medio), y se llama a un total de cuatro métodos nativos. Está diseñado de manera muy inteligente, y S String toma dos números como parámetros. Math.max toma dos números como parámetros y la búsqueda devuelve un número. La velocidad es un poco más lenta que las dos de arriba, pero más rápida que la mayoría de abajo.
Esto se puede llamar una versión simplificada de la implementación 2, que es utilizar operadores candidatos para conectar dos reglas. Pero hacerlo perderá la oportunidad de optimizar el navegador, que no es tan bueno como la realización 3. Debido a que parece elegante, muchas bibliotecas de clase lo usan, como JQ Ry y Mootols
Implementar 5
Match devuelve una matriz, por lo que la parte de la cadena original que cumple con los requisitos se convierte en su elemento. Para evitar que se excluyan el espacio en blanco en el medio de la cadena, necesitamos usar agrupación no capturante (?: Exp). Dado que la matriz puede estar vacía, necesitamos hacer más juicios más tarde. Parece que el navegador es débil en las agrupaciones de procesamiento, y una palabra es lenta. Así que no seas supersticioso sobre las reglas, aunque es básicamente omnipotente.
Implementación 6
Proporcione la parte requerida y póngala en una cadena vacía. Pero la eficiencia es muy pobre, especialmente en IE6.
Es muy similar a la implementación 6, pero utiliza paquetes no captados para proporcionar ventajas, y la eficiencia del rendimiento ha mejorado ligeramente.
Implementación 8
Mejoré las dos ideas anteriores, utilicé la agrupación no capturante y los conjuntos de personajes, y reemplazé * con?, Que fue muy sorprendente. Especialmente en IE6, la locura se puede usar para describir esta mejora del rendimiento y matar directamente a Firefox en segundos.
Implementar 9
Esta vez, utilicé la coincidencia perezosa para reemplazar la agrupación no capturante, que mejoró en Firefox, y IE no estaba tan loca como la última vez.
Date cuenta 10
Solo quiero decir que la persona que creó esto ya no se describe como una vaca, sino que está al mismo nivel que un Dios. Primero enumera todos los espacios en blanco posibles, corta los espacios en blanco delantero en el primer recorrido y corta los espacios en blanco trasero por segunda vez. Todo el proceso solo usa IndexOF y S String, un método nativo especialmente diseñado para cadenas de procesamiento, y no usa regularidad. La velocidad es increíblemente rápida, probablemente cerca de la implementación binaria interna, y tiene un buen rendimiento en IE y Firefox (por supuesto, otros navegadores son indudablemente). La velocidad es todo en cero milisegundos.
La implementación 10 nos ha dicho que el método normal de intercepción de cadena nativa es mucho mejor que el reemplazo regular, aunque es un poco más complicado. Pero mientras la regularidad no sea demasiado complicada, podemos usar el navegador para optimizar la regularidad para mejorar la eficiencia de la ejecución del programa, como lograr un rendimiento de 8 en IE. No creo que nadie normalmente aplique la implementación 10 en un proyecto, porque esa implementación de espacios en blanco es demasiado larga y difícil de recordar (por supuesto, si está construyendo una biblioteca de clase, definitivamente es la primera). Se puede decir que la implementación de 11 es su versión mejorada. Los espacios en blanco en la primera parte están cortados por reemplazo regular, y el procesamiento posterior se realiza mediante métodos nativos. El efecto no es inferior a la versión original, pero la velocidad es muy sorprendente.
La mejor versión de mejora del método de escritura de implementación 10 e implementación 11 no se trata de la velocidad de rendimiento, sino de la memoria y el uso fácil. Y sus dos predecesores están a nivel de cero milisegundos, por lo que usaré esto para trabajar y asustar en el futuro.