ti-enxame.com

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

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 ocorrências dele?

3564
Click Upvote

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

Note: Em geral, estender os protótipos embutidos em JavaScript geralmente não é recomendado. Eu estou fornecendo como extensões no protótipo String simplesmente para fins de ilustração, mostrando diferentes implementações de um método padrão hipotético no protótipo interno String.


Implementação Baseada em Expressões Regulares

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

Dividir e unir (funcional) a implementação

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

Não sabendo muito sobre como as expressões regulares funcionam nos bastidores em termos de eficiência, eu tendia a inclinar-se para a divisão e participar da implementação no passado sem pensar no desempenho. Quando eu me perguntei qual era mais eficiente, e com que margem, eu usei isso como uma desculpa para descobrir.

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

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


Como observado no comentário abaixo por @ThomasLeduc e outros, pode haver um problema com a implementação baseada em expressões regulares se search contiver certos caracteres reservados como caracteres especiais em expressões regulares . A implementação pressupõe que o chamador irá escapar a seqüência de caracteres com antecedência ou somente passará seqüências de caracteres 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 legal se isso também fosse padronizado como RegExp.escape(str), mas, infelizmente, ele não existe:

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

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

2009
Cory Gross
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 Clique no comentário do Upvote , você pode simplificá-lo ainda mais:

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

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

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

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

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

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

Como 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 em 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.

1244
Matthew Crumley

Usar uma expressão regular com o conjunto de sinalizadores g 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

553
Adam A

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

EDIT 

Se a sua find tiver caracteres especiais, você precisará escapar 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/

93
jesal

Update:

É um pouco tarde para uma atualização, mas desde que eu acabei de tropeçar nesta questão, e notei que a minha resposta anterior não é uma com a qual estou feliz. Como a questão envolvia substituir uma única palavra, é incrível que ninguém pensasse em usar limites do Word (\b)

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

Essa é uma regex simples que evita a substituição de partes de palavras na maioria dos casos. No entanto, um traço - ainda é considerado um limite do Word. 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 questão é a mesma que a pergunta aqui: Javascript substituir "'" por "' '"

@Mike, verifique a resposta que eu dei lá ... regexp não é a única maneira de substituir múltiplas ocorrências de uma subclasse, longe disso. Pense flexível, pense em dividir!

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

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

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

A saída é a mesma que a resposta aceita, no entanto, usando a expressão/cat/g nesta string:

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, isso provavelmente não é o que você quer. O que é então? IMHO, um regex que apenas substitui "cat" 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 atende às suas necessidades. Não é à prova de cheio, é claro, mas deve ser o suficiente para você começar. Eu recomendaria ler mais sobre essas páginas. Isso será útil no aperfeiçoamento dessa 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 questão ainda recebe muitos pontos de vista, pensei em adicionar um exemplo de .replace usado com uma função de retorno de chamada. Neste caso, simplifica dramaticamente a expressão e fornece ainda mais flexibilidade, como substituir com letras maiúsculas corretas ou substituir 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
76
Elias Van Ootegem

Corresponder a uma expressão regular global:

anotherString = someString.replace(/cat/g, 'dog');
57
scronide
str = str.replace(/abc/g, '');

Ou tente a função replaceAll aqui:

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

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

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

EDIT: Esclarecimento sobre substituirTodas as disponibilidades

O método 'replaceAll' é adicionado ao protótipo do 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'
39
SolutionYogi

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.

34
Emilio Grisolía

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-01:

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

Método-02:

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

Método-03:

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

Método-04:

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

Saída:

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

Use uma expressão regular:

str.replace(/abc/g, '');
32
Donnie DeBoer

Substituindo aspas simples:

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

    return text;
}
30
Chris Rosete

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

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

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

Revisado jsperf

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 split e 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 sempre poderá substituir outra ocorrência do Word.

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 de 27 de julho de 2017: parece que o RegExp agora tem o desempenho mais rápido no recém-lançado Chrome 59.
22
Cole Lawrence
str = str.replace(new RegExp("abc", 'g'), "");

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

22
csomakk

Usando RegExp em JavaScript poderia fazer o trabalho para você, simplesmente faça algo como abaixo, não esqueça do /g após qual destaque para global :

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

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:

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

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.replaceAll('abc', '');

Mas como eu mencionei anteriormente, isso não fará uma grande diferença em termos de linhas a serem escritas ou performance, somente o 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ê deseja reutilizar.

21
Alireza

Se o que você quer encontrar já está em uma string, e você não tem um escapador regex à mão, 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'));

18
rakslice
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;
}
16
Tim Rivoli

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

text = text.replace(new RegExp("cat","g"), "dog"); 
14
Owen
var str = "ff ff f f a de def";
str = str.replace(/f/g,'');
alert(str);

http://jsfiddle.net/ANHR9/

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

Se a string contiver padrões semelhantes, como abccc, você poderá usar isto:

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

As respostas anteriores são muito complicadas. Apenas use a função replace assim:

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

11
Black

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

Por exemplo:

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

Quando terminar, você ainda terá 'teste 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) que pode ser combinado para 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 temos 'a , b' e desejamos remover todas as vírgulas duplicadas.
[Nesse caso, pode-se fazer .replace (/, +/g, ','), mas em algum momento a regex se torna complexa e lenta o suficiente para dar um loop.]

9
SamGoody

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

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

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

Você pode consultar o exemplo detalhado aqui .

9
Cheezy Code

Eu resolvi esse problema com uma simples linha de código.

str.replace(/Current string/g, "Replaced string");

Verifique o exemplo no jsfiddle https://jsfiddle.net/pot6whnx/1/

8
Riajul Islam

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 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.

7
Sandeep Gantait

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

Apenas adicione /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

7
Reza Fahmi

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 irá 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'
6
Termininja

O caminho mais simples para isso sem usar qualquer regex é dividir e se associar como código aqui:

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

A maioria das pessoas provavelmente faz isso para codificar uma URL. Para codificar uma URL, você deve considerar apenas espaços, mas converter a string inteira corretamente com encodeURI.

encodeURI("http://www.google.com/a file with spaces.html")

para obter:

http://www.google.com/a%20file%20with%20spaces.html
5
User

Em termos de desempenho relacionado às principais respostas estes são alguns testes online .

Enquanto os seguintes são alguns testes de desempenho usando console.time() (eles funcionam melhor em seu próprio console, o tempo é muito curto para ser visto no snippet)

console.time('split and join');
"javascript-test-find-and-replace-all".split('-').join(' ');
console.timeEnd('split and join')

console.time('regular expression');
"javascript-test-find-and-replace-all".replace(new RegExp('-', 'g'), ' ');
console.timeEnd('regular expression');

console.time('while');
let str1 = "javascript-test-find-and-replace-all";
while (str1.indexOf('-') !== -1) {
    str1 = str1.replace('-', ' ');
}
console.timeEnd('while');

O interessante é que, se você executá-los várias vezes, os resultados serão sempre diferentes, embora a solução RegExp pareça a mais rápida, em média, e a solução while loop, a mais lenta.

4
Ferie

Minha implementação, muito auto-explicativa

function replaceAll(string, token, newtoken) {
    if(token!=newtoken)
    while(string.indexOf(token) > -1) {
        string = string.replace(token, newtoken);
    }
    return string;
}
4
Vitim.us

Para substituir todos os tipos de caracteres, tente este código:

Suppose we have need to send " and \ in my string, then we will convert it " to \" and \ to \\

Portanto, esse método resolverá esse problema.

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

var message = $('#message').val();
             message = message.replaceAll('\\', '\\\\'); /*it will replace \ to \\ */
             message = message.replaceAll('"', '\\"');   /*it will replace " to \\"*/

Eu estava usando o Ajax e tive a necessidade de enviar parâmetros no formato JSON. Então meu método está parecendo assim:

 function sendMessage(source, messageID, toProfileID, userProfileID) {

     if (validateTextBox()) {
         var message = $('#message').val();
         message = message.replaceAll('\\', '\\\\');
         message = message.replaceAll('"', '\\"');
         $.ajax({
             type: "POST",
             async: "false",
             contentType: "application/json; charset=utf-8",
             url: "services/WebService1.asmx/SendMessage",
             data: '{"source":"' + source + '","messageID":"' + messageID + '","toProfileID":"' + toProfileID + '","userProfileID":"' + userProfileID + '","message":"' + message + '"}',
             dataType: "json",
             success: function (data) {
                 loadMessageAfterSend(toProfileID, userProfileID);
                 $("#<%=PanelMessageDelete.ClientID%>").hide();
                 $("#message").val("");
                 $("#delMessageContainer").show();
                 $("#msgPanel").show();
             },
             error: function (result) {
                 alert("message sending failed");
             }
         });
     }
     else {
         alert("Please type message in message box.");
         $("#message").focus();

     }
 }

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

Nos meus aplicativos, eu uso uma função personalizada que é a mais poderosa para essa finalidade, e mesmo envolvendo a solução split/join no caso mais simples, é um pouco mais rápido em Chrome 60and Firefox 54 ( JSBEN.CH ) do que outras soluções. Meu computador executa Windows 7 64 bits.

A vantagem é que essa função personalizada pode manipular muitas substituições ao mesmo tempo usando strings ou caracteres, o que pode ser um atalho para alguns aplicativos.

Como uma solução acima split/join, a solução abaixo não tem nenhum problema com caracteres de escape, diferentemente da abordagem de expressão regular.

  function replaceAll(s,find,repl,caseOff,byChar){
  if (arguments.length<2)  return false; 
  var destDel = ! repl;       // if destDel delete all keys from target
  var isString = !! byChar;   // if byChar, replace set of characters 
  if (typeof find !==typeof repl && ! destDel)  return false; 
  if (isString  &&  (typeof find!=="string"))   return false; 

  if (! isString &&  (typeof find==="string"))  {
    return s.split(find).join(destDel?"":repl);
  }

  if ((! isString)  &&  ( ! Array.isArray(find) ||
          ( ! Array.isArray(repl) && ! destDel)   ))  return false;

     // if destOne replace all strings/characters by just one element
  var destOne = destDel ? false : (repl.length===1);   

     // Generally source and destination should have the same size
  if (! destOne && ! destDel && find.length!==repl.length)  return false    

  var prox,sUp,findUp,i,done;   
  if (caseOff)  {    // case insensitive    
       // Working with uppercase keys and target 
    sUp = s.toUpperCase();   
    if (isString)
       findUp = find.toUpperCase()   
    else
       findUp = find.map(function(el){  return el.toUpperCase();});    

  } else  {         // case sensitive
     sUp = s;
     findUp =find.slice();  // clone array/string
  }  

  done = new Array(find.length);  // size: number of keys
  done.fill(null);              

  var pos = 0;       // initial position in target s
  var r = "";   // initial result
  var aux, winner;
  while (pos < s.length)  {       // Scanning the target
     prox  = Number.MAX_SAFE_INTEGER;
     winner = -1;  // no winner at start
     for (i=0;i<findUp.length;i++)   // find next occurence for each string
       if (done[i]!==-1) {    // key still alive
             // Never search for the Word/char or is over?
         if (done[i]===null || done[i]<pos)  { 
           aux = sUp.indexOf(findUp[i],pos);
           done[i]=aux;  // Save the next occurrence
         } else
           aux = done[i]   // restore the position of last search
         if (aux<prox && aux!==-1) {   // if next occurrence is minimum
           winner = i;     // save it  
           prox = aux;
         }  
       }  // not done

      if (winner===-1) {   // No matches forward
         r += s.slice(pos);   
         break;
      } // no winner

      // found the character or string key in the target

      i = winner;  // restore the winner
      r += s.slice(pos,prox);   // update piece before the match

            // Append the replacement in target 
      if (! destDel) r += repl[ destOne?0:i ];  
      pos = prox + ( isString?1:findUp[i].length );       // go after match

  }  // loop
  return r;  // return the resulting string
}

A documentação está abaixo

           replaceAll    
 Syntax    
 ======     
      replaceAll(s,find,[ repl ,caseOff, byChar)     

 Parameters    
 ==========    

   "s" is a string target of replacement.    
   "find" can be a string or array of strings.     
   "repl" should be the same type than "find" or empty     

  if "find" is a string, it is a simple replacement for      
    all "find" occurrences in "s" by string "repl"    

  if "find" is an array, it will replaced each string in "find"    
    that occurs in "s" for corresponding string in "repl" array.
  The replace specs are independent: A replacement part cannot    
    be replaced again. 


  if "repl" is empty all "find" occurrences in "s" will be deleted.   
  if "repl" has only one character or element,    
      all occurrences in "s" will be replaced for that one.   

  "caseOff" is true if replacement is case insensitive     
       (default is FALSE)

  "byChar" is true when replacement is based on set of characters.    
  Default is false   

  if "byChar", it will be replaced in "s" all characters in "find"   
  set of characters for corresponding character in  "repl"
  set of characters   

 Return   
 ======   
  the function returns the new string after the replacement.  

Para ser justo, eu corri o benchmark sem teste de parâmetro. 

Aqui está o meu conjunto de testes, usando Node.js

function l() { return console.log.apply(null, arguments); }

var k=0;
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"],["do","fa"]));  //1
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"],["do"]));  //2
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"]));  //3
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
     "aeiou","","",true));  //4
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      "aeiou","a","",true));  //5
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      "aeiou","uoiea","",true));  //6
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      "aeiou","uoi","",true));  //7
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"],["do","fa","leg"]));  //8
l(++k,replaceAll("BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER",
      ["ri","nea"],["do","fa"]));  //9
l(++k,replaceAll("BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER",
      ["ri","nea"],["do","fa"],true)); //10
return;

E os resultados:

1 'banana é uma fruta Dope colhida longe do dover'
2 'banana é uma fruta do Dope colhida do dover'
3 'banana é um pe de fruta colhida r a ver'
4 'bnn s rp frt hrvstd nr th rvr'
5 'banana como um rapa fraat harvastad naar tha ravar'
6 'bununu é u ripo frait hurvostod nour tho rivor'
7 falso
8 falsa
9 'BANANA IS UMA FRUTOS MADUROS COLHIDOS PERTO DO RIO'
10 'BANANA IS Uma Fruta de Colheita Dopada para a Fazenda' 

3
Paulo Buchsbaum

Isso pode ser feito usando o Regex. Poucas combinações que podem ajudar alguém,

var Word = "this,\\ .is*a*test,    '.and? / only /     'a \ test?";
var stri = "This      is    a test         and only a        test";

Para substituir todos os caracteres não alfa,

console.log(Word.replace(/([^a-z])/g,' ').replace(/ +/g, ' ')); 
Result: [this is a test and only a test]

Para substituir vários espaços contínuos por um espaço,

console.log(stri.replace(/  +/g,' ')); 
Result: [This is a test and only a test]

Para substituir todos os caracteres *,

console.log(Word.replace(/\*/g,'')); 
Result: [this,\ .isatest,    '.and? / only /     'a  test?]

Para substituir pontos de interrogação (?)

console.log(Word.replace(/\?/g,'#')); 
Result: [this,\ .is*a*test,    '.and# / only /     'a  test#]

Para substituir aspas,

console.log(Word.replace(/'/g,'#'));  
Result: [this,\ .is*a*test,    #.and? / only /     #a  test?]

Para substituir todos os caracteres,

console.log(Word.replace(/,/g,'')); 
Result: [this\ .is*a*test    '.and? / only /     'a  test?]

Para substituir um Word específico,

console.log(Word.replace(/test/g,'')); 
Result: [this,\ .is*a*,    '.and? / only /     'a  ?]

Para substituir a barra invertida,

console.log(Word.replace(/\\/g,''));  
Result: [this, .is*a*test,    '.and? / only /     'a  test?]

Para substituir a barra,

console.log(Word.replace(/\//g,''));  
Result: [this,\ .is*a*test,    '.and?  only      'a  test?]

Para substituir todos os espaços,

console.log(Word.replace(/ /g,'#'));  
Result: [this,\#.is*a*test,####'.and?#/#only#/#####'a##test?]

Para substituir pontos,

console.log(Word.replace(/\./g,'#')); 
Result: [this,\ #is*a*test,    '#and? / only /     'a  test?]
3
prime
function replaceAll(str, find, replace) {
    var $r="";
    while($r!=str){ 
        $r = str;
        str = str.replace(find, replace);
    }
    return str;
}
3
theWalker

Aqui está o código de trabalho com o protótipo:

String.prototype.replaceAll = function(find, replace) {
    var str = this;
    return str.replace(new RegExp(find.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1"), 'g'), replace);
};
3
Nivesh Saharan

Para valores exclusivos substituíveis

String.prototype.replaceAll = function(search_array, replacement_array) {
  //
  var target = this;
  //
  search_array.forEach(function(substr, index) {
    if (typeof replacement_array[index] != "undefined") {
      target = target.replace(new RegExp(substr, 'g'), replacement_array[index])
    }
  });
  //
  return target;
};

//  Use:
var replacedString = "This topic commented on :year. Talking :question.".replaceAll([':year', ':question'], ['2018', 'How to replace all occurrences of a string in JavaScript']);
//
console.log(replacedString);

2
TheAivis

Eu uso split e join ou esta funcion

function replaceAll( text, busca, reemplaza ){
  while (text.toString().indexOf(busca) != -1)
      text = text.toString().replace(busca,reemplaza);
  return text;
}
2
VhsPiceros

Método 1

Tente implementar a expressão regular

"Teste abc teste teste abc teste teste teste abc teste teste abc" .replace (/\abc/g, '');

Método 2

Dividir e participar. Dividir com abc e juntar-se ao espaço vazio

"Teste abc teste teste abc teste teste teste abc teste teste abc" .split ("abc"). Join ("")

2
ashish

Se usar uma biblioteca for uma opção para você, você obterá os benefícios do teste e do suporte da comunidade que acompanha uma função de biblioteca. Por exemplo, a biblioteca string.js tem uma função replaceAll () que faz o que você está procurando:

// Include a reference to the string.js library and call it (for example) S.
str = S(str).replaceAll('abc', '').s;
2
Guy

Na primeira busca de elemento de string e substitua  

var str = '[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var i = str.replace('"[','[').replace(']"',']');
console.log(i,'//first element search and replace')

Na cadeia de pesquisa global e substitua  

var str = '[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var j = str.replace(/\"\[/g,'[').replace(/\]\"/g,']');
console.log(j,'//global search and replace')

2
KARTHIKEYAN.A

Eu só quero compartilhar minha solução, com base em alguns dos recursos funcionais das últimas versões do JavaScript:

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

   var result = str.split(' ').reduce((a, b) => {
      return b == 'abc' ? a : a + ' ' + b;   })

  console.warn(result)
1
Andrés

Isso pode ser resolvido usando expressões regulares e o sinalizador g, que significa não parar depois de encontrar a primeira correspondência. Realmente, expressões regulares são salva vidas!

function replaceAll(string, pattern, replacement) {
    return string.replace(new RegExp(pattern, "g"), replacement);
}

// or if you want myString.replaceAll("abc", "");

String.prototype.replaceAll = function(pattern, replacement) {
    return this.replace(new RegExp(pattern, "g"), replacement);
};
1
C. Morgan

Para substituir uma única vez, use:

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

Para substituir várias vezes, use:

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

Isso deve funcionar.

String.prototype.replaceAll = function (search, replacement){
var str1 = this.replace(search, replacement);
var str2 = this;
while(str1 != str2){
str2 = str1;
str1 = str1.replace(search, replacement);
}
return str1;
}

Exemplo:

Console.log("Steve is the best character in minecraft".replaceAll("Steve" ,"Alex"));
1
jessie tessie

Confira esta resposta que poderá ajudar e usei no meu projeto.

function replaceAll(searchString, replaceString, str) {
   return str.split(searchString).join(replaceString);
}
replaceAll('abc', '',"Test abc test test abc test test test abc test test abc" ); // "Test  test test  test test test  test test "
0
Raghavendra S

Tente isto:

String.prototype.replaceAll = function (sfind, sreplace) {
    var str = this;

    while (str.indexOf(sfind) > -1) {
        str = str.replace(sfind, sreplace);
    }

    return str;
};
0
Antonio Mirarchi
 var myName = 'r//i//n//o//l////d';
  var myValidName = myName.replace(new RegExp('\//', 'g'), ''); > // rinold
  console.log(myValidName);

var myPetName = 'manidog';
var renameManiToJack = myPetName.replace(new RegExp('mani', 'g'), 'jack'); > // jackdog
0
Rinold

Todas as respostas são aceitas, você pode fazer isso de várias maneiras. Um dos truques para fazer isso é isso.

const str = "Test abc test test abc test test test abc test test abc";

const compare = "abc";
arrayStr = str.split(" ");
arrayStr.forEach((element, index) => {
  if (element == compare) {
    arrayStr.splice(index, 1);
  }
});
const newString = arrayStr.join(" ");
console.log(newString);
0
Nouman Dilshad

Solução mais simples - 

let str = "Test abc test test abc test test test abc test test abc";

str = str.split(" ");
str = str.filter((ele, key)=> ele!=="abc")
str = str.join(" ")

Or Simply - 

str = str.split(" ").filter((ele, key) => ele != "abc").join(" ")

0
Brijesh Kumar

Melhor solução, a fim de substituir qualquer caractere que usamos essas funções indexOf(), includes(), substring() para substituir matched String pelo provided String na string atual.

  • String.indexOf() function é encontrar o nname__º posição do índice de correspondência.
  • String.includes() método determina se uma string pode ser encontrada dentro de outra string, retornando true ou false conforme apropriado.
  • String.substring() function é para obter as partes de String (precedingname __, excedingname__). Adicionado o substituir String entre essas partes para gerar a string de retorno final.

A seguinte função permite usar qualquer caractere.
onde como RegExpNAME_ não permitirá algum caracter especial como ** e algum caractere precisa ser escape como $.

String.prototype.replaceAllMatches = function(obj) { // Obj format: { 'matchkey' : 'replaceStr' }
    var retStr = this;
    for (var x in obj) {
        //var matchArray = retStr.match(new RegExp(x, 'ig'));
        //for (var i = 0; i < matchArray.length; i++) {
        var prevIndex = retStr.indexOf(x); // matchkey = '*', replaceStr = '$*' While loop never ends.
        while (retStr.includes(x)) {
            retStr = retStr.replaceMatch(x, obj[x], 0);
            var replaceIndex = retStr.indexOf(x);
            if( replaceIndex <  prevIndex + (obj[x]).length) {
                break;
            } else {
                prevIndex = replaceIndex;
            }
        }
    }
    return retStr;
};
String.prototype.replaceMatch = function(matchkey, replaceStr, matchIndex) {
    var retStr = this, repeatedIndex = 0;
    //var matchArray = retStr.match(new RegExp(matchkey, 'ig'));
    //for (var x = 0; x < matchArray.length; x++) {
    for (var x = 0; (matchkey != null) && (retStr.indexOf(matchkey) > -1); x++) {
        if (repeatedIndex == 0 && x == 0) {
            repeatedIndex = retStr.indexOf(matchkey);
        } else { // matchIndex > 0
            repeatedIndex = retStr.indexOf(matchkey, repeatedIndex + 1);
        }
        if (x == matchIndex) {
            retStr = retStr.substring(0, repeatedIndex) + replaceStr + retStr.substring(repeatedIndex + (matchkey.length));
            matchkey = null; // To break the loop.
        }
    }
    return retStr;
};

Também podemos usar o objeto de expressão regular para correspondência de texto com um padrão. A seguir estão as funções que serão objeto de expressão regular.

Você receberá SyntaxError quando estiver usando um padrão de expressão regular inválido, como '**'.

  • String.replace() function é usado para substituir a String especificada pela String fornecida.
  • String.match() function é descobrir quantas vezes a String é repetida.
  • RegExp.prototype.test method executa uma busca por uma correspondência entre uma expressão regular e uma string especificada. Retorna verdadeiro ou falso.
String.prototype.replaceAllRegexMatches = function(obj) { // Obj format: { 'matchkey' : 'replaceStr' }
    var retStr = this;
    for (var x in obj) {
        retStr = retStr.replace(new RegExp(x, 'ig'), obj[x]);
    }
    return retStr;
};

Observe que expressões regulares são escritas sem aspas.


Exemplos para usar funtions acima:

var str = "yash yas $dfdas.**";
console.log('String : ', str);

// No need to escape any special Character
console.log('Index Matched replace : ', str.replaceMatch('as', '*', 2) );
console.log('Index Matched replace : ', str.replaceMatch('y', '~', 1) );
console.log('All Matched replace : ', str.replaceAllMatches({'as' : '**', 'y':'Y', '$':'-'}));
console.log('All Matched replace : ', str.replaceAllMatches({'**' : '~~', '$':'&$&', '&':'%', '~':'>'}));

// You need to escape some special Characters
console.log('REGEX All Matched replace : ', str.replaceAllRegexMatches({'as' : '**', 'y':'Y', '\\$':'-'}));

Resultado:

String :  yash yas $dfdas.**
Index Matched replace :  yash yas $dfd*.**
Index Matched replace :  yash ~as $dfdas.**

All Matched replace :  Y**h Y** -dfd**.**
All Matched replace :  yash yas %$%dfdas.>>

REGEX All Matched replace :  Y**h Y** -dfd**.**

0
Yash