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

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 de Click Upvote, Você poderia simplificá-lo ainda mais:

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

Nota: as expressões regulares contêm caracteres especiais (meta) e, como tal, é perigoso passar cegamente um argumento na função find acima sem pré-processá-lo para escapar a esses caracteres. Isto está coberto no Guia de JavaScript Mozilla Developer Network'S no Guia de Expressões Regulares , onde apresentam a seguinte função de utilidade:

function escapeRegExp(str) {
    return str.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
}

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

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

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

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

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

O padrão geral é

str.split(search).join(replacement)

Isto costumava ser mais rápido em alguns casos do que usar {[[2]} e uma expressão regular, mas isso já não parece ser o caso nos navegadores modernos. Então, isso realmente só deve ser usado como um hack rápido para evitar a necessidade de escapar da expressão regular, não em código real.

Se usar uma expressão regular com a opção g irá substituir todas:

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 protótipo de cadeia de caracteres com base na resposta aceite:

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, então terá de fugir deles:

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

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

actualizar:

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

'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"

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

Em alternativa, para evitar a substituição de partes do termo-o que a resposta aprovada também fará! Você pode contornar esta questão usando expressões regulares que são, admito, um pouco mais complexas e como resultado disso, um pouco mais lentas também:

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

O resultado é o mesmo que a resposta aceite, no entanto, usando a expressão de /cat/g nesta cadeia:

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" ?? 

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"

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

Http://www.regular-expressions.info

Adição Final:

Dado que esta questão ainda tem muitas vistas, pensei em Adicionar um exemplo de .replace usado com uma função de callback. Neste case, simplifica dramaticamente a expressão e proporciona ainda mais flexibilidade, como substituir por capitalização correta ou substituir ambos cat e cats de 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

Jogo contra uma expressão regular global:

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

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

Ou tente a função de substituição a partir daqui:

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

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

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

Editar: clarificação sobre a disponibilidade de substituição

O método' replaceAll ' é adicionado ao protótipo do String. Isto significa que estará disponível para todos os objectos de texto/literais.

Por exemplo

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

Diga que quer 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

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

/ / loop it until number occurrence comes to 0. Ou simplesmente copiar / colar

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

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

Jsperf revisto

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 tão rápido quanto o método de separação e junção.

Como apontado em um comentário aqui, isso não vai funcionar se o seu omit variável contém place, como em: replaceAll("string", "s", "ss"), porque ele sempre será capaz de substituir outra ocorrência da palavra.

• Update July 27th 2017: It looks like RegExp now has the fastest performance in the recently released Chrome 59.

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

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

Se o que quer encontrar já estiver numa corda, e não tiver um escapador regex à mão, pode usar o 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'));

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

Usar RegExp em o JavaScript pode fazer o trabalho por ti, basta fazer algo como abaixo:

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 para você, mas não é recomendado, pois é apenas uma função de linha, mas novamente se você tiver muito uso disso, você pode escrever algo assim:

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

E basta usá - lo no seu código vezes sem conta do seguinte modo:

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

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

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

Se o texto contém um padrão semelhante ao abccc, pode usar isto:

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

Se está a tentar garantir que a cadeia de caracteres que procura não existirá mesmo após a substituição, precisa de usar um laço.

Por exemplo:

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

Quando completo, você ainda terá 'teste abc'!

O loop mais simples para resolver isto seria:

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

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

Isto pode ser particularmente útil ao procurar por sequências duplicadas.
Por exemplo, se tivermos 'a,,, b' e quisermos remover todas as vírgulas duplicadas.
Nesse caso, pode ser.substitua (/,+ / g,','), Mas em algum momento o regex fica complexo e lento o suficiente para fazer o loop.]

var string  = 'Test abc Test abc Test abc Test abc'
string = string.replace(/abc/g, '')
console.log(string)

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

Pode simplesmente utilizar 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);
};

Embora as pessoas tenham mencionado o uso da regex, mas há uma abordagem melhor se você quiser substituir o texto, independentemente do caso do texto. Como maiúsculas ou minúsculas. Usar abaixo da sintaxe

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

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

Pode consultar o exemplo detalhado aqui .

Basta seguir este oneliner regex adicionando a sensibilidade ao caso, então se você fizer "ABC", ele agiria da mesma forma que para"abc".

str = str.replace(/abc/gi, "");

Basta adicionar /g

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

A

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

/g significa global

A seguinte função 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 chama as funções assim:

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

Basta copiar e colar este código na consola do seu navegador para testar.

Uso p para guardar o resultado da substituição da recursão anterior:

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

Irá substituir todas as ocorrências na sequência s até ser possível:

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

Para evitar o ciclo infinito, verifico se a substituição R contém uma correspondência m:

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