No navegador IE 7 8, se você usar o atributo TRIM () para remover espaços, será relatado um erro.
Portanto, existem as seguintes soluções para esse problema:
var aa = $ ("#id"). val ().
Solução:
[var aa = $ .Trim ($ ("#id"). val ()); ] Isso não é fácil de usar; portanto, use o introduzido abaixo. O primeiro foi testado.
O grupo de pessoas W3C foi chutado nas cabeças pelos burros, e eles não suportaram funções de acabamento (e Trimleft, Trimright) até o Java Script 1.8.1. Infelizmente, apenas o Firefox3.5 suporta agora. Como remover os espaços em branco de ambos os lados das cordas é muito comum, todas as principais bibliotecas têm suas próprias sombras. Além disso, os estrangeiros têm muita energia de pesquisa e fizeram muitas conquistas.
Implementar 1 ok. (Escreva isso em JS e siga a string que você deseja remover o espaço diretamente.Trim ())
A cópia do código é a seguinte:
String.prototype.trim = function () {
Retorne este .Place (/^/s/s*/, '') .Rearplace (// s/s*$/, '');
}
Não parece muito bom e eu usei duas substituições regulares. A velocidade real é incrível, principalmente devido à otimização interna do navegador. Um exemplo famoso de splicing de cordas, a adição direta é mais rápida que um StringBuffer feito de matriz. A biblioteca de classe Base2 aplica esta implementação.
Implementar 2
A cópia do código é a seguinte:
String.prototype.trim = function () {
Retorne este .Place (/^/S/, '') .Splace (// s $/, '');
}
É muito semelhante à implementação 1, mas um pouco mais lento, o principal motivo é que ele primeiro assume que há pelo menos um espaço em branco. O prototype.js usa essa implementação, mas seu nome é tira, porque os métodos de protótipo tentam renomeá -lo com o Ruby.
Implementação 3
A cópia do código é a seguinte:
String.prototype.trim = function () {
Retorne este .Substring (Math.max (this .Search (// s/), 0), este .search (// s/s*$/) 1);
}
A parte em branco é obtida interceptando (é claro, os caracteres de espaço em branco são permitidos no meio) e um total de 4 métodos nativos são chamados. A predefinição é muito inteligente, a substring leva dois números como parâmetros. Math.Max usa dois números como parâmetros e retorna de pesquisa para um número. A velocidade é um pouco mais lenta que os dois primeiros, mas é muito mais rápido que o fundo.
Implementar 4
A cópia do código é a seguinte:
String.prototype.trim = function () {
retornar este. substitua (/^/s |/s $/g, '');
}
Isso pode ser chamado de versão simplificada da implementação 2, que deve usar os operadores candidatos para conectar duas regularidades. Mas isso não conseguirá alcançar oportunidades de otimização do navegador, o que não é tão bom quanto a realização 3. Porque parece elegante, muitos aplicativos de biblioteca, como jQuery e MooTools
Implementar 5
A cópia do código é a seguinte:
String.prototype.trim = function () {
var str = this;
str = str.match (// s (?:/s/s)*/);
retornar str? str [0]: '';
}
A partida é retornar a uma matriz, e a parte que atende aos requisitos da string original se torna seu elemento. Para impedir que o espaço em branco no meio da corda seja desconectado, precisamos usar o agrupamento não-captura (?: Exp). Como a matriz pode estar vazia, precisamos fazer mais julgamentos mais tarde. Parece que o navegador é menos poderoso nos agrupamentos de processamento e uma palavra é mais lenta. Portanto, não seja supersticioso sobre as regras, embora seja basicamente onipotente.
Implementação 6
A cópia do código é a seguinte:
String.prototype.trim = function () {
Retorne este .place (/^/s*(/s*(/s/s)*)/s*$/, '$ 1');
}
Forneça a peça necessária e coloque -a em uma corda vazia. Mas a eficiência é muito ruim, especialmente no IE6.
Implementação 7
A cópia do código é a seguinte:
String.prototype.trim = function () {
Retorne este .Place (/^/s*(/s*(?:/s/s)*)/s*$/, '$ 1');
}
É muito semelhante à implementação 6, mas usa pacotes que não são capturas para fornecer vantagens e a eficiência de desempenho é um pouco melhorada.
Implementação 8
A cópia do código é a seguinte:
String.prototype.trim = function () {
Retorne este .place (/^/s*((?: [/s/s]*/s)?)/S*$/, '$ 1');
}
Melhorei as duas idéias acima, usei conjuntos de agrupamento e personagens que não capturam e substituímos * por?, O que foi incrível. Especialmente no IE6, a loucura pode ser usada para descrever essa melhoria de desempenho e matar diretamente o Firefox em segundos.
Implementar 9
A cópia do código é a seguinte:
String.prototype.trim = function () {
Retorne este .Place (/^/s*([/s/s]*?)/s*$/, '$ 1');
}
Desta vez, usei a correspondência preguiçosa para substituir o agrupamento não capturado, que foi melhorado no Firefox, e o IE não foi tão louco quanto da última vez.
Perceba 10
A cópia do código é a seguinte:
String.prototype.trim = function () {
var str = isso,
WHITESPACE = '/N/R/T/F/X0B/XA0/U2000/U2001/U2002/U2003/U2004/U2020 05/U2006/U2007/U2008/U2009/U200A/U200B/U2028/U2029/U2009;
for (var i = 0, len = str.length; i = 0; i--) {
if (whiteSpace.indexof (str.charat (i)) === -1) {
str = str.substring (0, i 1);
quebrar;
}
}
Retornar WhiteSpace.IndexOf (str.Charat (0)) === -1? str: '';
}
Eu só quero dizer que a pessoa que criou isso não é mais descrita como uma vaca, mas está no mesmo nível que um Deus. Primeiro, ele lista todos os caracteres em branco possíveis, corta a frente em branco na primeira travessia e corta a parte traseira em branco pela segunda vez. Todo o processo utiliza apenas o índice e a substring, um método nativo projetado especialmente para processamento de strings e não aplica a regularidade. A velocidade é incrivelmente rápida, e espera -se que esteja próximo da implementação binária interna e tem um excelente desempenho no IE e no Firefox (é claro que outros navegadores são sem dúvida). As velocidades são todas zero milissegundos.
Implementar 11
A cópia do código é a seguinte:
String.prototype.trim = function () {
var str = isso,
str = str.Replace (/^/s/, '');
for (var i = str.Length-1; i> = 0; i--) {
if (//s/.test(st.charat(i))) {
str = str.substring (0, i 1);
quebrar;
}
}
retornar str;
}
A implementação 10 nos disse que o método normal de interceptação de string que é originalmente desconhecido é muito melhor que a substituição regular, embora seja um pouco mais complicada. Mas, desde que a regularidade não seja muito complicada, podemos usar o navegador para otimizar a regularidade para melhorar a eficiência da execução do programa e obter 8 desempenho no IE. Eu não acho que alguém normalmente aplicaria a implementação 10 em um projeto, porque essa implementação em branco é muito longa e difícil de lembrar (é claro, se você estiver construindo uma biblioteca de classes, ele definitivamente começará). Diz -se que a implementação de 11 é sua versão aprimorada. Os espaços em branco na frente são cortados por substituição regular. Eles são tratados com métodos nativos posteriormente. O efeito não é inferior à versão original, mas a velocidade é incrível.
Implementar 12
A cópia do código é a seguinte:
String.prototype.trim = function () {
var str = isso,
str = str.Replace (/^/s/s*/, ''),
ws = // s/,
i = str.length;
enquanto (ws.test (str.charat (-i)));
return str.slice (0, i 1);
}
A melhor versão de melhoria da implementação 10 e a implementação 11 é escrita. Observe que não se trata de velocidade de desempenho, mas da facilidade de memória e aplicativo. E seus dois antecessores são zero milissegundos, eles usarão isso para trabalhar e assustar as pessoas no futuro.
A seguir, é apresentado o resultado da comparação dado por estrangeiros. O histórico de execução é executar operações de acabamento neste artigo (mais de 27.600 caracteres).
Implementar o Firefox 2, ou seja, 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 A implementação da função Trim revela suas próprias idéias. Se você quiser entender o que o autor original disse, leia o texto original.
Atualmente, existem 12 métodos para remover espaços em 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+$/, ''); }
Implementação 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+)*/); retornar str? str [0]: ''; }
String.prototype.trim = function () {return this.replace (/^/s*(/s*(/s+/s+)*)/s*$/, '$ 1'); }
Implementação 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); quebrar; }} para (i = str.Length -1; i> = 0; i-) {if (whitespace.indexof (str.charat (i)) === -1) {str = str.s string (0, i + 1); quebrar; }} return whitespace.indexof (str.charat (0)) === -1? str: ''; }
Implementar 11
String.prototype.trim = function () {var str = this, str = str.Replace (/^/s+/, ''); para (var i = str.Length-1; i> = 0; i-) {if (//s/.test(str.charat(i))) {str = str.s string (0, i + 1); quebrar; }} retornar str; }
Implementar 12
String.prototype.trim = function () {var str = this, str = str.Replace (/^/s/s*/, ''), ws = // s/, i = str.Length; enquanto (ws.test (str.charat (-i))); return str.slice (0, i + 1); }
Não parece muito bom, e eu usei duas substituições regulares, e a velocidade real é incrível, principalmente devido à otimização interna do navegador. Um exemplo famoso de splicing de cordas, que é mais rápido que o StringB? R feito de matriz. A biblioteca da classe Base2 usa essa implementação.
É muito semelhante à implementação 1, mas um pouco mais lento, principalmente porque primeiro assume que há pelo menos um espaço em branco. O prototype.js usa essa implementação, mas seu nome é tira, porque o método do protótipo se esforça para ter o mesmo nome que Ry.
A parte em branco é obtida interceptando (é claro, o caráter de espaço em branco é permitido no meio) e um total de quatro métodos nativos são chamados. Ele foi projetado de maneira muito inteligente e S String leva dois números como parâmetros. Math.Max leva dois números como parâmetros e a pesquisa retorna um número. A velocidade é um pouco mais lenta que os dois acima, mas mais rápida que a maioria abaixo.
Isso pode ser chamado de uma versão simplificada da implementação 2, que deve usar operadores candidatos para conectar duas regras. Mas isso perderá a oportunidade de otimizar o navegador, o que não é tão bom quanto a realização 3. Porque parece elegante, muitas bibliotecas de classes o usam, como JQ Ry e MooTools
Implementar 5
O Match retorna uma matriz, então a parte da string original que atende aos requisitos se torna seu elemento. Para impedir que o espaço em branco no meio da string seja excluído, precisamos usar o agrupamento não capturado (?: Exp). Como a matriz pode estar vazia, precisamos fazer mais julgamentos mais tarde. Parece que o navegador é fraco em agrupamentos de processamento e uma palavra é lenta. Portanto, não seja supersticioso sobre as regras, embora seja basicamente onipotente.
Implementação 6
Forneça a peça necessária e coloque -a em uma corda vazia. Mas a eficiência é muito ruim, especialmente no IE6.
É muito semelhante à implementação 6, mas usa pacotes que não são capturas para fornecer vantagens e a eficiência de desempenho é um pouco melhorada.
Implementação 8
Melhorei as duas idéias acima, usei conjuntos de agrupamento e personagens não capturados e substituí-me * por?, O que foi muito incrível. Especialmente no IE6, a loucura pode ser usada para descrever essa melhoria de desempenho e matar diretamente o Firefox em segundos.
Implementar 9
Desta vez, usei a correspondência preguiçosa para substituir o agrupamento não capturado, que foi melhorado no Firefox, e o IE não foi tão louco quanto da última vez.
Perceba 10
Eu só quero dizer que a pessoa que criou isso não é mais descrita como uma vaca, mas está no mesmo nível que um Deus. Primeiro, ele lista todos os espaços em branco possíveis, corta os espaços em branco dianteiro na primeira travessia e corta os espaços em branco pela segunda vez. Todo o processo usa apenas a String IndexOF e S, um método nativo projetado especialmente para processamento de seqüências de processamento, e não usa regularidade. A velocidade é incrivelmente rápida, provavelmente perto da implementação binária interna, e tem um bom desempenho no IE e no Firefox (é claro, outros navegadores são sem dúvida). A velocidade é toda em zero milissegundos.
A implementação 10 nos disse que o método normal de interceptação de cordas nativas é muito melhor que a substituição regular, embora seja um pouco mais complicada. Mas, desde que a regularidade não seja muito complicada, podemos usar o navegador para otimizar a regularidade para melhorar a eficiência da execução do programa, como alcançar 8 desempenho no IE. Eu não acho que alguém normalmente aplicaria a implementação 10 em um projeto, porque essa implementação em branco é muito longa e difícil de lembrar (é claro que se você estiver construindo uma biblioteca de classes, é definitivamente o primeiro). Diz -se que a implementação de 11 é sua versão aprimorada. Os espaços em branco na primeira parte são cortados por substituição regular e o processamento posterior é feito pelos métodos nativos. O efeito não é inferior à versão original, mas a velocidade é muito incrível.
A melhor versão de melhoria do método de redação de implementação 10 e implementação 11 não é sobre velocidade de desempenho, mas sobre memória e uso fácil. E seus dois antecessores estão no nível de milissegundos zero, então usarei isso para trabalhar e assustar no futuro.