Aparar string em JavaScript?

Como aparo uma string em JavaScript?

Todos os navegadores desde o IE9 + têm trim()método para seqüências de caracteres.

Para os navegadores que não suportam trim(), você pode usar este polyfill do MDN :

if (!String.prototype.trim) {
    (function() {
        // Make sure we trim BOM and NBSP
        var rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
        String.prototype.trim = function() {
            return this.replace(rtrim, '');
        };
    })();
}

Dito isto, se estiver usando jQuery, $.trim(str)também está disponível e lida com indefinido / nulo.

Veja isso:

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

String.prototype.ltrim=function(){return this.replace(/^\s+/,'');};

String.prototype.rtrim=function(){return this.replace(/\s+$/,'');};

String.prototype.fulltrim=function(){return this.replace(/(?:(?:^|\n)\s+|\s+(?:$|\n))/g,'').replace(/\s+/g,' ');};

A guarnição do jQuery é conveniente se você já estiver usando essa estrutura.

$.trim('  your string   ');

Eu costumo usar o jQuery com frequência, portanto, cortar cordas com ele é natural para mim. Mas é possível que exista reação contra o jQuery por aí? :)

Embora existam Stringvárias respostas corretas acima, deve-se observar que o objeto em JavaScript possui um .trim()método nativo a partir do ECMAScript 5 . Assim, idealmente, qualquer tentativa de criar um protótipo do método de corte deve realmente verificar se ele já existe primeiro.

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

Adicionado nativamente em: JavaScript 1.8.1 / ECMAScript 5

Assim suportado em:

Firefox: 3.5 ou superior

Safari: 5+

Internet Explorer: IE9 + (somente no modo de padrões!) Http://blogs.msdn.com/b/ie/archive/2010/06/25/enhanced-scripting-in-ie9-ecmascript-5-support-and-more .aspx

Chrome: mais de 5

Opera: 10.5+

Tabela de suporte do ECMAScript 5: http://kangax.github.com/es5-compat-table/

Existem muitas implementações que podem ser usadas. O mais óbvio parece ser algo assim:

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

" foo bar ".trim();  // "foo bar"

Versão simples aqui O que é uma função geral para o ajuste de JavaScript?

function trim(str) {
        return str.replace(/^\s+|\s+$/g,"");
}

Se a resposta ajudou de alguma forma, por favor, marque como resposta, caso a sua dúvida não tenha sido solucionada, por favor, poste novamente String.trim().

document.getElementById("id").value.trim();

Se você estiver usando jQuery, use a jQuery.trim()função Por exemplo:

if( jQuery.trim(StringVariable) == '')

O Flagrante Badassery possui 11 acabamentos diferentes com informações de referência:

http://blog.stevenlevithan.com/archives/faster-trim-javascript

Não surpreendentemente baseado em regexp é mais lento que o loop tradicional.

Aqui está o meu pessoal. Este código é antigo! Eu o escrevi para JavaScript1.1 e Netscape 3 e foi atualizado apenas um pouco desde então. (Original usado String.charAt)

/**
 *  Trim string. Actually trims all control characters.
 *  Ignores fancy Unicode spaces. Forces to string.
 */
function trim(str) {
    str = str.toString();
    var begin = 0;
    var end = str.length - 1;
    while (begin <= end && str.charCodeAt(begin) < 33) { ++begin; }
    while (end > begin && str.charCodeAt(end) < 33) { --end; }
    return str.substr(begin, end - begin + 1);
}

Use os métodos nativos JavaScript: String.trimLeft(), String.trimRight(), e String.trim().

String.trim()é suportado no IE9 + e em todos os outros principais navegadores :

'  Hello  '.trim()  //-> 'Hello'

String.trimLeft()e String.trimRight()não são padrão, mas são compatíveis com todos os principais navegadores, exceto o IE

'  Hello  '.trimLeft()   //-> 'Hello  '
'  Hello  '.trimRight()  //-> '  Hello'

No entanto, o suporte ao IE é fácil com um polyfill:

if (!''.trimLeft) {
    String.prototype.trimLeft = function() {
        return this.replace(/^\s+/,'');
    };
    String.prototype.trimRight = function() {
        return this.replace(/\s+$/,'');
    };
    if (!''.trim) {
        String.prototype.trim = function() {
            return this.replace(/^\s+|\s+$/g, '');
        };
    }
}

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

String.prototype.trimLeft = String.prototype.trimLeft || function () {
    return this.replace(/^\s+/, "");
};

String.prototype.trimRight = String.prototype.trimRight || function () {
    return this.replace(/\s+$/, "");
};

String.prototype.trimFull = String.prototype.trimFull || function () {
    return this.replace(/(?:(?:^|\n)\s+|\s+(?:$|\n))/g, "").replace(/\s+/g, " ");
};

Roubado descaradamente de Matt duereg .

Agora, nos dias em que você pode usar string.trim () que é a implementação nativa de Javascript

var orig = "   foo  ";
console.log(orig.trim());//foo

Veja também

• trimLeft ()
• trimRight ()

Código de apara do projeto js angular

var trim = (function() {

  // if a reference is a `String`.
  function isString(value){
       return typeof value == 'string';
  } 

  // native trim is way faster: http://jsperf.com/angular-trim-test
  // but IE doesn't have it... :-(
  // TODO: we should move this into IE/ES5 polyfill

  if (!String.prototype.trim) {
    return function(value) {
      return isString(value) ? 
         value.replace(/^\s*/, '').replace(/\s*$/, '') : value;
    };
  }

  return function(value) {
    return isString(value) ? value.trim() : value;
  };

})();

e chame como trim(" hello ")

use simplesmente código

var str = "       Hello World!        ";
alert(str.trim());

Suporte do navegador

Feature         Chrome  Firefox Internet Explorer   Opera   Safari  Edge
Basic support   (Yes)   3.5     9                   10.5    5       ?

Para navegador antigo, adicione protótipo

if (!String.prototype.trim) {
  String.prototype.trim = function () {
    return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
  };
}

Aqui está uma maneira muito simples:

function removeSpaces(string){
return string.split(' ').join('');
}

Usar trim()a String nativa pode ser a maneira mais fácil:

const fullName = "       Alireza Dezfoolian     ";
const trimmedFullName = fullName.trim();

console.log(trimmedFullName);

Você pode simplesmente declarar sua variável como string e usar a função trim:

var str = new String('my string'); 
str= str.trim();

Hoje, praticamente todos os navegadores suportam String.prototype.trim() .

Você o usa assim:

var origStr = '   foo  ';
var newStr = origStr.trim(); // Value of newStr becomes 'foo'

Caso você ainda precise dar suporte a um navegador antigo que não suporta esse recurso, este é um polyfill sugerido pelo MDN:

if (!String.prototype.trim) {
    String.prototype.trim = function () {
       return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
    };
}

Eu tenho uma lib que usa guarnição. resolveu usando o seguinte código.

String.prototype.trim = String.prototype.trim || function(){ return jQuery.trim(this); };

if(!String.prototype.trim){  
  String.prototype.trim = function(){  
    return this.replace(/^\s+|\s+$/gm,'');  
  };  
}

Das respostas anteriores, difere a adição de sinalizador m.

A bandeira mpesquisará o texto de várias lineares. Nesse modo, a marca no início e no final do padrão ( ^ $) é inserida antes e depois do caractere de nova linha ( \n).

Você pode fazer isso usando o JavaScript simples:

function trimString(str, maxLen) {
if (str.length <= maxLen) {
return str;
}
var trimmed = str.substr(0, maxLen);
return trimmed.substr(0, trimmed.lastIndexOf(' ')) + '…';
}

// Let's test it

sentenceOne = "too short";
sentencetwo = "more than the max length";

console.log(trimString(sentenceOne, 15));
console.log(trimString(sentencetwo, 15));

Agora trim () é construído em javascript.

let yourName = ' something   ';
let actualTrimmedName = yourName.trim();

apenas console ou código de impressão, seu nome também será aparado.

Não sei o que os bugs podem esconder aqui, mas eu uso isso:

var some_string_with_extra_spaces="   goes here    "
console.log(some_string_with_extra_spaces.match(/\S.*\S|\S/)[0])

Ou isso, se o texto contiver digitar:

console.log(some_string_with_extra_spaces.match(/\S[\s\S]*\S|\S/)[0])

Outra tentativa:

console.log(some_string_with_extra_spaces.match(/^\s*(.*?)\s*$/)[1])

Aqui está no TypeScript:

var trim: (input: string) => string = String.prototype.trim
    ? ((input: string) : string => {
        return (input || "").trim();
    })
    : ((input: string) : string => {
        return (input || "").replace(/^\s+|\s+$/g,"");
    })

Ele retornará à regex se o protótipo nativo não estiver disponível.

Eu escrevi essa função para trim, quando a função .trim () não estava disponível no JS em 2008. Alguns dos navegadores mais antigos ainda não suportam a função .trim () e espero que essa função possa ajudar alguém.

FUNÇÃO TRIM

function trim(str)
{
    var startpatt = /^\s/;
    var endpatt = /\s$/;

    while(str.search(startpatt) == 0)
        str = str.substring(1, str.length);

    while(str.search(endpatt) == str.length-1)
        str = str.substring(0, str.length-1);   

    return str;
}

Explicação : A função trim () aceita um objeto de sequência e remove os espaços em branco iniciais e finais (espaços, guias e novas linhas) e retorna a sequência aparada. Você pode usar esta função para aparar entradas de formulário para garantir que dados válidos sejam enviados.

A função pode ser chamada da seguinte maneira como exemplo.

form.elements[i].value = trim(form.elements[i].value);

O mine usa uma única regex para procurar casos em que o corte é necessário e usa os resultados dessa regex para determinar os limites de substring desejados:

var illmatch= /^(\s*)(?:.*?)(\s*)$/
function strip(me){
    var match= illmatch.exec(me)
    if(match && (match[1].length || match[2].length)){
        me= me.substring(match[1].length, p.length-match[2].length)
    }
    return me
}

a única decisão de design adotada foi usar uma substring para realizar a captura final. s / \?: // (faça a captura do meio termo) e o fragmento de substituição se torna:

    if(match && (match[1].length || match[3].length)){
        me= match[2]
    }

há duas apostas de desempenho que eu fiz nesses impls:

1. a implementação de substring copia os dados da string original? Nesse caso, no primeiro, quando uma string precisa ser cortada, há uma travessia dupla, primeiro no regex (que pode, espero, ser parcial), e segundo na extração de substring. esperamos que uma implementação de substring faça referência apenas à string original, portanto operações como substring podem ser quase livres. dedos cruzados

2. quão boa é a captura no regex impl? o médio prazo, o valor do produto, pode ser potencialmente muito longo. eu não estava pronto para concluir que a captura de todos os documentos regulares não seria recusada em algumas centenas de capturas de entrada de KB, mas também não testei (muitos tempos de execução, desculpe!). o segundo SEMPRE executa uma captura; se o seu mecanismo puder fazer isso sem ser atingido, talvez usando algumas das técnicas de cordas acima, com certeza USE-O!

Para IE9 + e outros navegadores

function trim(text) {
    return (text == null) ? '' : ''.trim.call(text);
}