¿Cómo reemplazar todas las ocurrencias de una cadena en JavaScript?

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

En respuesta al comentario:

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

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

En respuesta al comentario de Haga clic en Upvote , podría simplificarlo aún más:

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

Nota: Las expresiones regulares contienen caracteres especiales (meta), y como tales es peligroso pasar ciegamente un argumento en la función find anterior sin procesarlo previamente para escapar de esos caracteres. Esto está cubierto en la [17]} Mozilla Developer Network ' s Guía JavaScript sobre Expresiones Regulares, donde presente la siguiente función de utilidad:

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

Así que para hacer la función replaceAll() anterior más segura, podría modificarse a lo siguiente si también incluye escapeRegExp:

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

Nota: No uses esto en código real.

Como alternativa a las expresiones regulares para una cadena literal simple, puede usar

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

El patrón general es

str.split(search).join(replacement)

Esto solía ser más rápido en algunos casos que usar replaceAll y una expresión regular, pero eso ya no parece ser el caso en los navegadores modernos. Por lo tanto, esto realmente solo debe ser utilizado como un truco rápido para evitar la necesidad de escapar de la expresión regular, no en código real.

Usando una expresión regular con la bandera g reemplazará todo:

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

Ver aquí también

Aquí hay una función prototipo de cadena basada en la respuesta aceptada:

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

EDITAR

Si su find contendrá caracteres especiales, entonces necesita escaparlos:

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

Violín: http://jsfiddle.net/cdbzL/

Actualizar:

Es un poco tarde para una actualización, pero ya que me tropecé con esta pregunta, y noté que mi respuesta anterior no es una con la que esté contento. Dado que la pregunta implicaba reemplazar una sola palabra, es increíble que nadie pensara en usar límites de palabras(\b)

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

Esta es una expresión regular simple que evita reemplazar partes de palabras en la mayoría de los casos. Sin embargo, un guión - todavía se considera un límite de palabra. Así condicionales se pueden utilizar en este caso para evitar reemplazar cadenas 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"

Básicamente, esta pregunta es la misma que la pregunta aquí: Javascript reemplazar "'" con "" "

@ Mike, mira la respuesta que di allí... regexp no es la única manera de reemplazar múltiples ocurrencias de una subsrting, lejos de ello. ¡Piensa flexible, piensa dividido!

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

Alternativamente, para evitar la sustitución de partes de palabras-que la respuesta aprobada hará, también! Usted puede conseguir alrededor de este problema usando expresiones regulares que son, lo admito, algo más complejas y como resultado de eso, un poco más lentas también:

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

La salida es la misma que la respuesta aceptada, sin embargo, usando la expresión / cat / g en esta cadena:

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

Oops de hecho, esto probablemente no es lo que quieres. ¿Qué es, entonces? IMHO, una expresión regular que solo reemplaza 'cat' condicionalmente. (es decir, no parte de una palabra), así:

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"

Mi conjetura es, esto satisface sus necesidades. No es a prueba de todo, por supuesto, pero debería será suficiente para empezar. Recomiendo leer más en estas páginas. Esto resultará útil para perfeccionar esta expresión para satisfacer sus necesidades específicas.

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

Http://www.regular-expressions.info

Adición final:

Dado que esta pregunta todavía recibe muchas vistas, pensé que podría agregar un ejemplo de .replace utilizado con una función de devolución de llamada. En este caso, se simplifica drásticamente la expresión y proporciona aún más flexibilidad, como reemplazar con mayúsculas correctas o reemplazar ambos cat y cats de una sola 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

Coincidencia con una expresión regular global:

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

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

O pruebe la función replaceAll desde aquí:

¿Cuáles son los métodos JavaScript útiles que extienden los objetos incorporados?

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

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

EDIT: Aclaración sobre la disponibilidad de replaceAll

El método 'replaceAll' se añade al prototipo de String. Esto significa que estará disponible para todos los objetos de cadena/literales.

Por ejemplo

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

Digamos que quieres reemplazar todo el ' 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

Estaba tratando de pensar en algo más simple que modificar el prototipo de cadena.

Use una expresión regular:

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

Reemplazando comillas simples:

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

    return text;
}

//loop hasta que el número de ocurrencias llega a 0. O simplemente copiar / pegar

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

Esta es la versión más rápida que no usa expresiones 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)
}

Es casi dos veces tan rápido como el método dividir y unir.

Como se señala en un comentario aquí, esto no funcionará si su variable omit contiene place, como en: replaceAll("string", "s", "ss"), porque siempre podrá reemplazar otra ocurrencia de la palabra.

Hay otro jsperf con variantes en mi reemplazo recursivo que van incluso más rápido ( http://jsperf.com/replace-all-vs-split-join/12)!

• Actualización 27 de julio de 2017: Parece que RegExp ahora tiene el rendimiento más rápido en el recientemente lanzado Chrome 59.

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

Funcionó mejor para mí que las respuestas anteriores. así que new RegExp("abc", 'g') crea una expresión regular que coincide con todas las ocurrencias ('g' bandera) del texto ("abc"). La segunda parte es lo que se reemplaza a, en su caso cadena vacía (""). str es la cadena, y tenemos que sobreescribirla, ya que replace(...) solo devuelve el resultado, pero no sobreescribe. En algunos casos es posible que desee utilizar eso.

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

Si lo que quieres encontrar ya está en una cadena, y no tienes un escaper de expresiones regulares a mano, puedes 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'));

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

Usando RegExp en JavaScript podría hacer el trabajo por usted, simplemente haga algo como a continuación:

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

Si piensa en reutilizar, cree una función para hacer eso por usted, pero no se recomienda ya que es solo una función de línea, pero nuevamente si usa mucho esto, puede escribir algo como esto:

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

Y simplemente úsalo en tu código una y otra vez como a continuación:

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

Pero como mencioné anteriormente, no hará una gran diferencia en términos de líneas para ser escrito o rendimiento, solo el almacenamiento en caché de la función puede afectar un rendimiento más rápido en cadenas largas y también una buena práctica de código SECO si desea reutilizar.

Me gusta este método (se ve un poco más limpio):

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

Si la cadena contiene un patrón similar como abccc, puede usar esto:

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

Si está tratando de asegurarse de que la cadena que está buscando no existirá incluso después del reemplazo, debe usar un bucle.

Por ejemplo:

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

Cuando esté completo, usted todavía tendrá 'prueba abc'!

El bucle más simple para resolver esto sería:

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

Pero eso ejecuta el reemplazo dos veces para cada ciclo. Tal vez (en riesgo de ser rechazado) que se puede combinar para una forma un poco más eficiente pero menos legible:

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

Esto puede ser particularmente útil cuando se buscan cadenas duplicadas.
Por ejemplo, si tenemos 'a,,, b' y queremos eliminar todas las comas duplicadas.
[En ese caso, uno podría hacerlo .replace ( / , + / g,','), pero en algún momento la expresión regular se vuelve lo suficientemente compleja y lenta como para hacer un bucle en su lugar.]

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

Podrías intentar combinar estos dos poderosos métodos.

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

Espero que ayude!

Simplemente puede usar el siguiente método

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

Aunque la gente ha mencionado el uso de expresiones regulares, hay un mejor enfoque si desea reemplazar el texto independientemente del caso del texto. Como mayúsculas o minúsculas. Use la sintaxis siguiente

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

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

Puede consultar el ejemplo detallado aquí.

Simplemente siga esta expresión regular de oneliner agregando la sensibilidad de mayúsculas y minúsculas, por lo que si hace "ABC", actuaría de la misma manera que para "abc".

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

Simplemente agregue /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 global

La siguiente función funciona para mí:

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

Ahora llama a las funciones de esta manera:

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

Simplemente copie y pegue este código en la consola de su navegador para PROBARLO.

Utilizo p para almacenar el resultado del reemplazo de recursión anterior:

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

Reemplazará todas las ocurrencias en la cadena s hasta que sea posible:

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

Para evitar el bucle infinito, compruebo si el reemplazo r contiene una coincidencia m :

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