Aparar espaços do início e do fim da string

Estou tentando encontrar uma maneira de aparar espaços do início e do fim da sequência de título. Eu estava usando isso, mas não parece estar funcionando:

title = title.replace(/(^[\s]+|[\s]+$)/g, '');

Alguma ideia?

Nota: A partir de 2015, todos os principais navegadores (incluindo IE> = 9) suportam String.prototype.trim () . Isso significa que, na maioria dos casos de uso, simplesmente fazer str.trim()é a melhor maneira de alcançar o que a pergunta faz.

Steven Levithan analisou muitas implementações diferentes do trimJavascript em termos de desempenho.

Sua recomendação é:

function trim1 (str) {
    return str.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
}

para "implementação de uso geral rápida entre navegadores" e

function trim11 (str) {
    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;
}

"se você quiser lidar com seqüências longas excepcionalmente rápidas em todos os navegadores".

Referências

• blog.stevenlevithan.com - Corte mais rápido do JavaScript

Se o uso do jQuery for uma opção:

/**
 * Trim the site input[type=text] fields globally by removing any whitespace from the
 * beginning and end of a string on input .blur()
 */
$('input[type=text]').blur(function(){
    $(this).val($.trim($(this).val()));
});

ou simplesmente:

$.trim(string);

Como o @ChaosPandion mencionou, o String.prototype.trimmétodo foi introduzido na especificação do ECMAScript 5th Edition , algumas implementações já incluem esse método, portanto, a melhor maneira é detectar a implementação nativa e declará-la apenas se não estiver disponível:

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

Então você pode simplesmente:

title = title.trim();

Sei que este é um post antigo, mas pensei em compartilhar nossa solução. Na busca pelo código mais curto (nem todo mundo adora regex conciso), pode-se usar:

title = title.replace(/(^\s+|\s+$)/g, '');

BTW: Eu executei esse mesmo teste através do link compartilhado acima blog.stevenlevithan.com - Ajuste de JavaScript mais rápido e esse padrão superou todas as outras MÃOS!

Usando o IE8, teste adicionado como teste13. Os resultados foram:

Comprimento original: 226002
guarnição1: 110ms (comprimento: 225994)
guarnição2: 79ms (comprimento: 225994)
guarnição3: 172ms (comprimento: 225994)
guarnição4: 203ms (comprimento: 225994)
guarnição5: 172ms (comprimento: 225994)
guarnição6: 312ms (comprimento: 225994)
guarnição7: 203ms (comprimento: 225994)
guarnição8: 47ms (comprimento: 225994)
guarnição9: 453ms (comprimento: 225994)
guarnição10: 15ms (comprimento: 225994)
guarnição11: 16ms (comprimento: 225994)
guarnição12: 31ms (comprimento: 225994)
trim13: 0ms (comprimento: 226002)

O ECMAScript 5 suporta trime isso foi implementado no Firefox.

trim - MDC

Aqui, isso deve fazer tudo o que você precisa

function doSomething(input) {
    return input
              .replace(/^\s\s*/, '')     // Remove Preceding white space
              .replace(/\s\s*$/, '')     // Remove Trailing white space
              .replace(/([\s]+)/g, '-'); // Replace remaining white space with dashes
}

alert(doSomething("  something with  some       whitespace   "));

Aqui estão alguns métodos que eu tenho usado no passado para aparar cadeias de caracteres em js:

String.prototype.ltrim = function( chars ) {
    chars = chars || "\\s*";
    return this.replace( new RegExp("^[" + chars + "]+", "g"), "" );
}

String.prototype.rtrim = function( chars ) {
    chars = chars || "\\s*";
    return this.replace( new RegExp("[" + chars + "]+$", "g"), "" );
}
String.prototype.trim = function( chars ) {
    return this.rtrim(chars).ltrim(chars);
}

Aqui está o meu código atual: a 2ª linha funciona se eu comentar a 3ª linha, mas não funciona se eu deixar como está.

var page_title = $(this).val().replace(/[^a-zA-Z0-9\s]/g, '');
page_title = page_title.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
page_title = page_title.replace(/([\s]+)/g, '-');

Basta usar o string.trim()método É suportado por todos os principais navegadores. Consulte aqui: http://www.w3schools.com/jsref/jsref_trim_string.asp

jQuery.trim ("olá, como vai você?");

:)

Quando o DOM estiver totalmente carregado, você poderá adicioná-lo a todos os campos de texto. Eu nunca tive uma situação em que precisava enviar espaço à esquerda ou à direita, por isso fazê-lo o tempo todo em todo o mundo funcionou para mim ...

$(function() { $('input[type=text]').on('blur', function(){
    $(this).val($.trim($(this).val()));
  });
});

É o que sugere o arquiteto JavaScript / Guru Douglas Crockford.

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

Nota: você precisa definir "método" para Function.prototype.

alternativamente

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

title.trim();    // returns trimmed title

Observação

Em navegadores recentes, o corte método de é incluído por padrão. Portanto, você não precisa adicioná-lo explicitamente.

Os principais navegadores Chrome, Firefox, Safari etc. suportam o método de apara . Verificado no Chrome 55.0.2883.95 (64 bits), Firefox 51.0.1 (64 bits), Safari 10.0 (12602.1.50.0.10).

var word = " testWord ";   //add here word or space and test

var x = $.trim(word);

if(x.length > 0)
    alert('word');
else
    alert('spaces');

uma tentativa recursiva para isso

function t(k){ 
    if (k[0]==' ') {
        return t(k.substr(1,k.length));
    } else if (k[k.length-1]==' ') {
        return t(k.substr(0,k.length-1));
    } else {
        return k;
    }
}

chame assim:

t("      mehmet       "); //=>"mehmet"

Se você deseja filtrar caracteres específicos, pode definir uma string de lista basicamente:

function t(k){
    var l="\r\n\t "; //you can add more chars here.
    if (l.indexOf(k[0])>-1) {
        return t(k.substr(1,k.length));
    } else if (l.indexOf(k[k.length-1])>-1) {
        return t(k.substr(0,k.length-1));
    } else {
        return k;
    }
}