Como substituir todas as ocorrências de uma string?

Eu tenho esta 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 abcna sequência acima.

Como posso substituir todas as ocorrências dele?

Nota: Não use isso no código crítico de desempenho.

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

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

O padrão geral é

str.split(search).join(replacement)

Em alguns casos, isso costumava ser mais rápido do que usar replaceAll e uma expressão regular, mas isso não parece mais ser o caso nos navegadores modernos.

Referência: https://jsperf.com/replace-all-vs-split-join

Conclusão: Se você tiver um caso de uso crítico de desempenho (por exemplo, processando centenas de strings), use o método Regexp. Mas para os casos de uso mais comuns, vale a pena não ter que se preocupar com caracteres especiais.

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

Em resposta ao comentário:

var find = 'abc';
var re = new RegExp(find, 'g');

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

Em resposta ao comentário do Click Upvote , você pode simplificá-lo ainda mais:

function replaceAll(str, find, replace) {
  return str.replace(new RegExp(find, 'g'), replace);
}

Nota: Expressões regulares contêm caracteres especiais (meta) e, como tal, é perigoso transmitir cegamente um argumento na findfunção acima sem pré-processá-lo para escapar desses caracteres. Isso é abordado no Guia de expressões regulares do Mozilla Developer Network , em JavaScript , onde eles apresentam a seguinte função de utilitário (que foi alterada pelo menos duas vezes desde que a resposta foi originalmente escrita, verifique o site MDN para possíveis atualizações):

function escapeRegExp(string) {
  return string.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
}

Portanto, para tornar a replaceAll()função acima mais segura, ela pode ser modificada para o seguinte se você também incluir escapeRegExp:

function replaceAll(str, find, replace) {
  return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);
}

Por uma questão de integridade, comecei a pensar sobre qual método eu deveria usar para fazer isso. Existem basicamente duas maneiras de fazer isso, conforme sugerido pelas outras respostas nesta página.

Nota: Em geral, a extensão dos protótipos internos em JavaScript geralmente não é recomendada. Estou fornecendo como extensões no protótipo String apenas para fins de ilustração, mostrando diferentes implementações de um método padrão hipotético Stringno protótipo interno.

Implementação baseada em expressões regulares

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

Implementação de divisão e junção (funcional)

String.prototype.replaceAll = function(search, replacement) {
    var target = this;
    return target.split(search).join(replacement);
};

Sem saber muito sobre como as expressões regulares funcionam nos bastidores em termos de eficiência, eu costumava me inclinar para a divisão e ingressar na implementação no passado sem pensar em desempenho. Quando me perguntei o que era mais eficiente e com que margem, usei-o como desculpa para descobrir.

Na minha máquina Windows 8 Chrome, a implementação baseada em expressões regulares é a mais rápida , com a implementação de divisão e junção sendo 53% mais lenta . Significando que as expressões regulares são duas vezes mais rápidas para a entrada de lorem ipsum que eu usei.

Confira este benchmark executando essas duas implementações uma contra a outra.

Conforme observado no comentário abaixo de @ThomasLeduc e outros, pode haver um problema com a implementação baseada em expressões regulares se searchcontiver certos caracteres reservados como caracteres especiais em expressões regulares . A implementação pressupõe que o chamador escapará da string antecipadamente ou passará apenas as seqüências que estão sem os caracteres na tabela em Expressões regulares (MDN).

O MDN também fornece uma implementação para escapar de nossas strings. Seria bom se isso também fosse padronizado RegExp.escape(str), mas, infelizmente, não existe:

function escapeRegExp(str) {
  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
}

Poderíamos chamar escapeRegExpdentro de nossa String.prototype.replaceAllimplementação, no entanto, não tenho certeza de quanto isso afetará o desempenho (potencialmente mesmo para cadeias para as quais a fuga não é necessária, como todas as cadeias alfanuméricas).

O uso de uma expressão regular com o gconjunto de sinalizadores substituirá todos:

someString = 'the cat looks like a cat';
anotherString = someString.replace(/cat/g, 'dog');
// anotherString now contains "the dog looks like a dog"

Veja aqui também

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

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

EDITAR

Se você findpossuir caracteres especiais, será necessário escapá-los:

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

Fiddle: http://jsfiddle.net/cdbzL/

Atualizar:

É um pouco tarde para uma atualização, mas desde que acabei de me deparar com essa pergunta e percebi que minha resposta anterior não é com a qual estou feliz. Como a pergunta envolvia substituir uma única palavra, é incrível que ninguém pensasse em usar limites de palavras ( \b)

'a cat is not a caterpillar'.replace(/\bcat\b/gi,'dog');
//"a dog is not a caterpillar"

Esse é um regex simples que evita substituir partes das palavras na maioria dos casos. No entanto, um traço -ainda é considerado um limite de palavra. Portanto, condicionais podem ser usados ​​neste caso para evitar a substituição de strings como cool-cat:

'a cat is not a cool-cat'.replace(/\bcat\b/gi,'dog');//wrong
//"a dog is not a cool-dog" -- nips
'a cat is not a cool-cat'.replace(/(?:\b([^-]))cat(?:\b([^-]))/gi,'$1dog$2');
//"a dog is not a cool-cat"

basicamente, esta pergunta é a mesma que a pergunta aqui: Javascript substitui "'" por "' '"

@ Mike, verifique a resposta que eu dei lá ... regexp não é a única maneira de substituir várias ocorrências de uma assinatura, longe disso. Pense flexível, pense dividido!

var newText = "the cat looks like a cat".split('cat').join('dog');

Como alternativa, para evitar a substituição de partes de palavras, o que a resposta aprovada também fará! Você pode contornar esse problema usando expressões regulares que são, eu admito, um pouco mais complexas e, como resultado disso, um pouco mais devagar:

var regText = "the cat looks like a cat".replace(/(?:(^|[^a-z]))(([^a-z]*)(?=cat)cat)(?![a-z])/gi,"$1dog");

A saída é igual à resposta aceita, no entanto, usando a expressão / cat / g nesta cadeia de caracteres:

var oops = 'the cat looks like a cat, not a caterpillar or coolcat'.replace(/cat/g,'dog');
//returns "the dog looks like a dog, not a dogerpillar or cooldog" ?? 

Opa, de fato, isso provavelmente não é o que você deseja. O que é então? IMHO, um regex que substitui apenas 'gato' condicionalmente. (ou seja, não faz parte de uma palavra), assim:

var caterpillar = 'the cat looks like a cat, not a caterpillar or coolcat'.replace(/(?:(^|[^a-z]))(([^a-z]*)(?=cat)cat)(?![a-z])/gi,"$1dog");
//return "the dog looks like a dog, not a caterpillar or coolcat"

Meu palpite é que isso atenda às suas necessidades. Não é à prova de falhas, é claro, mas deve ser suficiente para você começar. Eu recomendo ler um pouco mais sobre estas páginas. Isso será útil para aperfeiçoar essa expressão para atender às suas necessidades específicas.

http://www.javascriptkit.com/jsref/regexp.shtml

http://www.regular-expressions.info

Adição final:

Como essa pergunta ainda tem muitas visualizações, pensei em adicionar um exemplo de .replaceusado com uma função de retorno de chamada. Neste caso, ele simplifica dramaticamente a expressão e oferece ainda mais flexibilidade, como a substituição com capitalização correta ou substituição de ambos cate catsde uma só vez:

'Two cats are not 1 Cat! They\'re just cool-cats, you caterpillar'
   .replace(/(^|.\b)(cat)(s?\b.|$)/gi,function(all,char1,cat,char2)
    {
       //check 1st, capitalize if required
       var replacement = (cat.charAt(0) === 'C' ? 'D' : 'd') + 'og';
       if (char1 === ' ' && char2 === 's')
       {//replace plurals, too
           cat = replacement + 's';
       }
       else
       {//do not replace if dashes are matched
           cat = char1 === '-' || char2 === '-' ? cat : replacement;
       }
       return char1 + cat + char2;//return replacement string
    });
//returns:
//Two dogs are not 1 Dog! They're just cool-cats, you caterpillar

Combine com uma expressão regular global:

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

Para substituir uma única vez, use:

var res = str.replace('abc', "");

Para substituir várias vezes, use:

var res = str.replace(/abc/g, "");

Estes são os métodos mais comuns e legíveis.

var str = "Test abc test test abc test test test abc test test abc"

Método 1:

str = str.replace(/abc/g, "replaced text");

Método 2:

str = str.split("abc").join("replaced text");

Método 3:

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

Método 4:

while(str.includes("abc")){
    str = str.replace("abc", "replaced text");
}

Resultado:

console.log(str);
// Test replaced text test test replaced text test test test replaced text test test replaced text

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

Ou tente a função replaceAll a partir daqui:

Quais são os métodos JavaScript úteis que estendem objetos internos?

str = str.replaceAll('abc', ''); OR

var search = 'abc';
str = str.replaceAll(search, '');

EDITAR: Esclarecimento sobre a disponibilidade do replaceAll

O método 'replaceAll' é adicionado ao protótipo de String. Isso significa que estará disponível para todos os objetos / literais de string.

Por exemplo

var output = "test this".replaceAll('this', 'that');  //output is 'test that'.
output = output.replaceAll('that', 'this'); //output is 'test this'

O uso RegExpde JavaScript pode fazer o trabalho para você, basta fazer algo como o código abaixo, não se esqueça do /gseguinte destaque para global :

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

Se você pensar em reutilizar, crie uma função para fazer isso por você, mas isso não é recomendado, pois é apenas uma função de linha, mas novamente, se você usar isso intensamente, poderá escrever algo como isto:

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

e simplesmente use-o no seu código repetidamente, como abaixo:

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

Mas, como mencionei anteriormente, não fará uma grande diferença em termos de linhas a serem gravadas ou desempenho, apenas o cache da função poderá afetar um desempenho mais rápido em seqüências longas e também uma boa prática de código DRY se você desejar reutilizar.

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.

Use uma expressão regular:

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

Substituindo aspas simples:

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

    return text;
}

// faz um loop até que o número 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;
    }

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

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

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 de divisão e junção.

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

Há outro jsperf com variantes na minha substituição recursiva que é ainda mais rápida ( 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 Chrome 59, lançado recentemente.

atuação

Hoje em 27.12.2019, realizo testes no macOS v10.13.6 (High Sierra) para as soluções escolhidas.

Conclusões

• O str.replace(/abc/g, '');( C ) é uma boa solução rápida entre navegadores para todas as strings.
• As soluções baseadas em split-join( A, B ) ou replace( C, D ) são rápidas
• As soluções baseadas em while( E, F, G, H ) são lentas - geralmente ~ 4 vezes mais lentas para cordas pequenas e cerca de 3000 vezes (!) Mais lentas para cordas longas
• As soluções de recorrência ( RA, RB ) são lentas e não funcionam para seqüências longas

Eu também crio minha própria solução. Parece que atualmente é o mais curto que faz o trabalho de pergunta:

str.split`abc`.join``

str = "Test abc test test abc test test test abc test test abc";
str = str.split`abc`.join``

console.log(str);

Detalhes

Os testes foram realizados no Chrome 79.0, Safari 13.0.4 e Firefox 71.0 (64 bits). Os testes RAe RBusam recursão. Resultados

String curta - 55 caracteres

Você pode executar testes em sua máquina AQUI . Resultados para o Chrome:

Sequência longa: 275 000 caracteres

As soluções recursivas RA e RB oferecem

RangeError: tamanho máximo da pilha de chamadas excedido

Para 1 milhão de caracteres, eles até quebram o Chrome

Eu tento executar testes de caracteres de 1 milhão para outras soluções, mas E, F, G, H leva tanto tempo que o navegador me pede para quebrar o script, então reduzo a sequência de teste para 275 mil caracteres. Você pode executar testes em sua máquina AQUI . Resultados para Chrome

Código usado nos testes

var t="Test abc test test abc test test test abc test test abc"; // .repeat(5000)
var log = (version,result) => console.log(`${version}: ${result}`);


function A(str) {
  return str.split('abc').join('');
}

function B(str) {
  return str.split`abc`.join``; // my proposition
}


function C(str) {
  return str.replace(/abc/g, '');
}

function D(str) {
  return str.replace(new RegExp("abc", "g"), '');
}

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

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

function G(str) {
  while(str.includes("abc")) { str = str.replace('abc', ''); }
  return str;
}

// src: https://stackoverflow.com/a/56989553/860099
function H(str)
{
    let i = -1
    let find = 'abc';
    let newToken = '';

    if (!str)
    {
        if ((str == null) && (find == null)) return newToken;
        return str;
    }

    while ((
        i = str.indexOf(
            find, i >= 0 ? i + newToken.length : 0
        )) !== -1
    )
    {
        str = str.substring(0, i) +
            newToken +
            str.substring(i + find.length);
    }
    return str;
}

// src: https://stackoverflow.com/a/22870785/860099
function RA(string, prevstring) {
  var omit = 'abc';
  var place = '';
  if (prevstring && string === prevstring)
    return string;
  prevstring = string.replace(omit, place);
  return RA(prevstring, string)
}

// src: https://stackoverflow.com/a/26107132/860099
function RB(str) {
  var find = 'abc';
  var 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) + RB(st2, find, replace);
    }
  }
  return str;
}




log('A ', A(t));
log('B ', B(t));
log('C ', C(t));
log('D ', D(t));
log('E ', E(t));
log('F ', F(t));
log('G ', G(t));
log('H ', H(t));
log('RA', RA(t)); // use reccurence
log('RB', RB(t)); // use reccurence

<p style="color:red">This snippet only presents codes used in tests. It not perform test itself!<p>

Se o que você deseja encontrar já estiver em uma sequência e não tiver um escaper de regex à mão, poderá 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'));

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;
}

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

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

A maneira mais simples de fazer isso sem usar qualquer regex é dividir e associar-se como o código aqui:

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

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

http://jsfiddle.net/ANHR9/

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

Se a string contiver um padrão semelhante abccc, você pode usar isto:

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

As respostas anteriores são muito complicadas. Basta usar a função de substituição como esta:

str.replace(/your_regex_pattern/g, replacement_string);

Exemplo:

var str = "Test abc test test abc test test test abc test test abc";

var res = str.replace(/[abc]+/g, "");

console.log(res);

Se você estiver tentando garantir que a string que você está procurando não exista mesmo após a substituição, será necessário usar um loop.

Por exemplo:

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

Quando concluído, você ainda terá 'test abc'!

O loop mais simples para resolver isso seria:

var str = 'test aabcbc';
while (str != str.replace(/abc/g, '')){
   str.replace(/abc/g, '');
}

Mas isso executa a substituição duas vezes para cada ciclo. Talvez (sob risco de ser rejeitado) possa ser combinado de uma forma um pouco mais eficiente, mas menos legível:

var str = 'test aabcbc';
while (str != (str = str.replace(/abc/g, ''))){}
// alert(str); alerts 'test '!

Isso pode ser particularmente útil ao procurar seqüências de caracteres duplicadas.
Por exemplo, se tivermos 'a ,,, b' e desejarmos remover todas as vírgulas duplicadas.
[Nesse caso, é possível substituir. (/, + / G, ','), mas em algum momento o regex fica complexo e lento o suficiente para fazer um loop.]

Embora as pessoas tenham mencionado o uso de regex, existe uma abordagem melhor se você deseja substituir o texto, independentemente do caso. Como maiúsculas ou minúsculas. Use a sintaxe abaixo

//Consider below example
originalString.replace(/stringToBeReplaced/gi, '');

//Output will be all the occurrences removed irrespective of casing.

Você pode consultar o exemplo detalhado aqui .

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);
};

Basta adicionar /g

document.body.innerHTML = document.body.innerHTML.replace('hello', 'hi');

para

// Replace 'hello' string with /hello/g regular expression.
document.body.innerHTML = document.body.innerHTML.replace(/hello/g, 'hi');

/g significa global