javascript - uma - substituir texto jquery




Como substituir todas as ocorrências de uma string em JavaScript? (20)

Eu tenho essa string:

"Test abc test test abc test test test abc test test abc"

Fazendo

str = str.replace('abc', '');

parece remover apenas a primeira ocorrência de abc na string acima. Como posso substituir todas as ocorrências dele?


// faça um loop até que a quantidade de ocorrências chegue a 0. OU simplesmente copie / cole

    function replaceAll(find, replace, str) 
    {
      while( str.indexOf(find) > -1)
      {
        str = str.replace(find, replace);
      }
      return str;
    }

Aqui está uma função de protótipo de string baseada na resposta aceita:

String.prototype.replaceAll = function (find, replace) {
    var str = this;
    return str.replace(new RegExp(find, 'g'), replace);
};

EDITAR

Se o seu find contiver caracteres especiais, você precisará evitá-los:

String.prototype.replaceAll = function (find, replace) {
    var str = this;
    return str.replace(new RegExp(find.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'), 'g'), replace);
};

Violino: http://jsfiddle.net/cdbzL/


Corresponder a uma expressão regular global:

anotherString = someString.replace(/cat/g, 'dog');

Digamos que você queira substituir todo o 'abc' por 'x':

let some_str = 'abc def def lom abc abc def'.split('abc').join('x')
console.log(some_str) //x def def lom x x def

Eu estava tentando pensar em algo mais simples do que modificar o protótipo de string.


Esta é a versão mais rápida que não usa expressões regulares .

Jsperf revisado

replaceAll = function(string, omit, place, prevstring) {
  if (prevstring && string === prevstring)
    return string;
  prevstring = string.replace(omit, place);
  return replaceAll(prevstring, omit, place, string)
}

É quase duas vezes mais rápido que o método split and join.

Como apontado em um comentário aqui, isso não funcionará se sua variável omit contiver place , como em: replaceAll("string", "s", "ss") , porque ele sempre poderá substituir outra ocorrência da palavra .

Há outro jsperf com variantes na minha substituição recursiva que vai ainda mais rápido ( http://jsperf.com/replace-all-vs-split-join/12 )!

  • Atualização 27 de julho de 2017: parece que o RegExp agora tem o desempenho mais rápido no recém-lançado Chrome 59.

Eu gosto desse método (parece um pouco mais limpo):

text = text.replace(new RegExp("cat","g"), "dog"); 

Se a string contiver um padrão similar ao abccc , você poderá usar isto:

str.replace(/abc(\s|$)/g, "")

Se o que você quer encontrar já está em uma string, e você não tem um escape regular, você pode usar join / split:

    function replaceMulti(haystack, needle, replacement)
    {
        return haystack.split(needle).join(replacement);
    }

    someString = 'the cat looks like a cat';
    console.log(replaceMulti(someString, 'cat', 'dog'));


Substituindo aspas simples:

function JavaScriptEncode(text){
    text = text.replace(/'/g,''')
    // More encode here if required

    return text;
}

Usando RegExp em JavaScript poderia fazer o trabalho para você, basta fazer algo como abaixo:

var str = "ff ff f f a de def";
str = str.replace(/f/g,'');
alert(str);

Se você pensa em reutilizar, crie uma função para fazer isso para você, mas ela não é recomendada, pois é apenas uma função de linha, mas, novamente, se você usa muito isso, pode escrever algo assim:

while (str.indexOf('abc') !== -1)
{
    str = str.replace('abc', '');
}

e simplesmente usá-lo em seu código mais e mais como abaixo:

var str ="Test abc test test abc test test test abc test test abc";
str = str.replace(/abc/g, '');

Mas, como mencionei anteriormente, não fará uma grande diferença em termos de linhas a serem escritas ou desempenho, apenas o armazenamento em cache da função pode afetar um desempenho mais rápido em strings longas e também uma boa prática de código DRY se você quiser reutilizá-lo.


Use uma expressão regular:

str.replace(/abc/g, '');

Você pode simplesmente usar o método abaixo

/**
 * Replace all the occerencess of $find by $replace in $originalString
 * @param  {originalString} input - Raw string.
 * @param  {find} input - Target key word or regex that need to be replaced.
 * @param  {replace} input - Replacement key word
 * @return {String}       Output string
 */
function replaceAll(originalString, find, replace) {
  return originalString.replace(new RegExp(find, 'g'), replace);
};

Nota: não use isso em código real.

Como uma alternativa às expressões regulares para uma string literal simples, você poderia usar

str = "Test abc test test abc test...".split("abc").join("");

O padrão geral é

str.split(search).join(replacement)

Isso costumava ser mais rápido em alguns casos do que usar replaceAll e uma expressão regular, mas isso não parece mais ser o caso nos navegadores modernos. Então, isso deve ser usado apenas como um truque rápido para evitar a necessidade de escapar da expressão regular, não em código real.


A função seguinte funciona para mim:

String.prototype.replaceAllOccurence = function(str1, str2, ignore) 
{
    return this.replace(new RegExp(str1.replace(/([\/\,\!\\\^\$\{\}\[\]\(\)\.\*\+\?\|\<\>\-\&])/g,"\\$&"),(ignore?"gi":"g")),(typeof(str2)=="string")?str2.replace(/\$/g,"$$$$"):str2);
} ;

agora chame as funções assim:

"you could be a Project Manager someday, if you work like this.".replaceAllOccurence ("you", "I");

Basta copiar e colar esse código no console do seu navegador para TEST.


Você poderia tentar combinar esses dois métodos poderosos.

"test abc test test abc".split("abc").join("")

Espero que ajude!


Eu uso p para armazenar o resultado da substituição de recursão anterior:

function replaceAll(s, m, r, p) {
    return s === p || r.contains(m) ? s : replaceAll(s.replace(m, r), m, r, s);
}

Ele substituirá todas as ocorrências na string s até que seja possível:

replaceAll('abbbbb', 'ab', 'a') → 'abbbb' → 'abbb' → 'abb' → 'ab' → 'a'

Para evitar loop infinito, eu verifico se a substituição r contém uma correspondência m :

replaceAll('abbbbb', 'a', 'ab') → 'abbbbb'

String.prototype.replaceAll = String.prototype.replaceAll || function(string, replaced) {
  return this.replace(new RegExp(string, 'g'), replaced);
};

http://jsfiddle.net/ANHR9/


function replaceAll(str, find, replace) {
  var i = str.indexOf(find);
  if (i > -1){
    str = str.replace(find, replace); 
    i = i + replace.length;
    var st2 = str.substring(i);
    if(st2.indexOf(find) > -1){
      str = str.substring(0,i) + replaceAll(st2, find, replace);
    }       
  }
  return str;
}

str = str.replace(new RegExp("abc", 'g'), "");

funcionou melhor para mim do que as respostas acima. então o new RegExp("abc", 'g') cria um RegExp que corresponde a todas as ocorrências (flag 'g' ) do texto ( "abc" ). A segunda parte é substituída, no seu caso, string vazia ( "" ). str é a string, e nós temos que sobrescrevê-la, já que replace(...) apenas retorna o resultado, mas não substitui. Em alguns casos, você pode querer usar isso.


var str ="Test abc test test abc test test test abc test test abc";
str = str.replaceAll('abc', '');




replace