Cómo reemplazar todas las apariciones de una cadena en JavaScript

4926

Tengo esta cadena en mi código JavaScript:

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

Haciendo:

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

Parece que solo elimina la primera aparición de abcen la cadena anterior.

¿Cómo puedo reemplazar todas las apariciones?

3
  • 13
    Al reemplazar todas las apariciones de abain ababapor ca, ¿qué resultado espera? caba? abca? cca? 2 de agosto de 2019 a las 12:58
  • 8
    String.prototype.replaceAll()ahora es una parte estándar de ECMAScript tc39.es/ecma262/#sec-string.prototype.replaceall , documentado en developer.mozilla.org/docs/Web/JavaScript/Reference/… y enviado en Safari 13.1, Firefox 77 y Chrome Dev / Canary y se enviará en Chrome 85. De los documentos: “Si searchValue es una cadena, reemplaza todas las apariciones de searchValue (como si se .split(searchValue).join(replaceValue)hubiera usado una expresión regular global y con el escape adecuado). Si searchValue es una expresión regular no global, lanza una excepción " 29/06/20 a las 5:26
  • 11
    Use expresiones regulares en lugar de cadenas, debería verse str.replace(/abc/g, '');así como g para obtener todas las coincidencias.
    sarea
    29/07/20 a las 6:17
2215

Actualización: en las últimas versiones de los navegadores más populares, puede usarlo replaceAll como se muestra aquí:

let result = "1 abc 2 abc 3".replaceAll("abc", "xyz");
// `result` is "1 xyz 2 xyz 3"

Pero verifique primero ¿Puedo usar u otra tabla de compatibilidad para asegurarse de que los navegadores a los que se dirige tengan soporte agregado primero?


Para Node y compatibilidad con navegadores antiguos / no actuales:

Nota: No utilice la siguiente solución en código de rendimiento crítico.

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)

En algunos casos, esto solía ser más rápido que usar replaceAlluna expresión regular, pero ya no parece ser el caso en los navegadores modernos.

Punto de referencia: https://jsben.ch/TZYzj

Conclusión: si tiene un caso de uso crítico para el rendimiento (por ejemplo, procesar cientos de cadenas), utilice el método Regexp. Pero para la mayoría de los casos de uso típicos, vale la pena no tener que preocuparse por los caracteres especiales.

5
  • 50
    Es curioso que necesitaran más de 20 años para agregar una función como replaceAll. 20 de septiembre de 2020 a las 12:57
  • 13
    Desanimo el uso de replaceAll en este momento (2020). No es compatible con algunos navegadores que tuvieron actualizaciones este año caniuse.com/?search=replaceTodo Es demasiado pronto 19/10/20 a las 18:31
  • 14
    NodeJS admite replaceAllversiones 15.x.
    Abion47
    25 de febrero a las 1:38
  • @Remirror jaja! cierto 19 de agosto a las 13:23
  • qué hacer en mayúsculas y minúsculas 27 de agosto a las 23:03
4761

A partir de agosto de 2020: los navegadores modernos son compatibles con el String.replaceAll()método definido por la especificación de lenguaje ECMAScript 2021.


Para navegadores antiguos / heredados:

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 Click 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 tal, es peligroso pasar a ciegas un argumento en la findfunción anterior sin procesarlo previamente para escapar de esos caracteres. Esto se trata en la red de desarrolladores de Mozilla 's Guía de JavaScript en las expresiones regulares , donde presentan la siguiente función de utilidad (que ha cambiado al menos dos veces desde esta respuesta fue escrito originalmente, así que asegúrese de comprobar el sitio MDN para las actualizaciones posibles):

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

Entonces, para que la replaceAll()función anterior sea 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);
}
0
2473

En aras de la integridad, me puse a pensar qué método debería usar para hacer esto. Básicamente, hay dos formas de hacer esto, como lo sugieren las otras respuestas en esta página.

Nota: En general, no se recomienda extender los prototipos integrados en JavaScript. Proporciono extensiones en el prototipo String simplemente con fines ilustrativos, mostrando diferentes implementaciones de un método estándar hipotético en el Stringprototipo incorporado.


Implementación basada en expresiones regulares

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

Implementación de división y unión (funcional)

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

Sin saber demasiado sobre cómo funcionan las expresiones regulares detrás de escena en términos de eficiencia, tendía a inclinarme hacia la implementación de split y unirme en el pasado sin pensar en el rendimiento. Cuando me pregunté cuál era más eficiente y con qué margen, lo usé como excusa para averiguarlo.

En mi máquina Chrome con Windows 8, la implementación basada en expresiones regulares es la más rápida , y la implementación de división y unión es un 53% más lenta . Lo que significa que las expresiones regulares son dos veces más rápidas para la entrada de lorem ipsum que utilicé.

Consulte este punto de referencia que ejecuta estas dos implementaciones entre sí.


Como se indica en el comentario a continuación de @ThomasLeduc y otros, podría haber un problema con la implementación basada en expresiones regulares si searchcontiene ciertos caracteres que están reservados como caracteres especiales en expresiones regulares . La implementación asume que la persona que llama escapará de la cadena de antemano o solo pasará cadenas que no tengan los caracteres en la tabla en Expresiones regulares (MDN).

MDN también proporciona una implementación para escapar de nuestras cadenas. Sería bueno si esto también estuviera estandarizado como RegExp.escape(str), pero lamentablemente, no existe:

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

Podríamos llamar escapeRegExpdentro de nuestra String.prototype.replaceAllimplementación, sin embargo, no estoy seguro de cuánto afectará esto al rendimiento (potencialmente incluso para cadenas para las que no se necesita el escape, como todas las cadenas alfanuméricas).

0
751

El uso de una expresión regular con el gconjunto de banderas 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

0
125

Aquí hay una función de 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 tu findcontendrá caracteres especiales, entonces debes escapar de ellos:

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/

0
93

Actualizar:

Es algo tarde para una actualización, pero como me encontré con esta pregunta y noté que mi respuesta anterior no es una con la que estoy contento. Dado que la pregunta implicaba reemplazar una sola palabra, es increíble que nadie haya pensado 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 palabras. Entonces, los condicionales se pueden usar 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 reemplaza "'" con "' '"

@ Mike, verifique la respuesta que di allí ... regexp no es la única forma de reemplazar múltiples apariciones de una subasta, ni mucho menos. ¡Piense flexible, piense dividido!

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

Alternativamente, para evitar reemplazar partes de palabras, ¡lo que también funcionará con la respuesta aprobada! Puede solucionar este problema utilizando expresiones regulares que son, lo admito, algo más complejas y, como resultado, 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");

Sin embargo, la salida es la misma que la respuesta aceptada, 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" ?? 

Vaya, de hecho, esto probablemente no sea lo que quieres. ¿Que es entonces? En mi humilde opinión, una expresión regular que solo reemplaza a 'gato' condicionalmente. (es decir, no es 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"

Supongo que esto satisface sus necesidades. Por supuesto, no es una prueba completa, pero debería ser suficiente para comenzar. Recomiendo leer un poco 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 visitas, pensé que podría agregar un ejemplo de .replaceusado con una función de devolución de llamada. En este caso, simplifica drásticamente la expresión y proporciona aún más flexibilidad, como reemplazar con las mayúsculas correctas o reemplazar ambas caty catsde una 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
0
76

Coincidir con una expresión regular global:

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

Para reemplazar un uso de una sola vez:

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

Para reemplazar varias veces el uso:

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

Estos son los métodos más comunes y legibles.

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

Producción:

console.log(str);
// Test replaced text test test replaced text test test test replaced text test test replaced text
54
str = str.replace(/abc/g, '');

O pruebe el replaceAllmétodo, como se recomienda en esta respuesta :

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

o:

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

EDITAR: aclaración sobre la replaceAlldisponibilidad

El replaceAllmétodo se agrega al Stringprototipo de. Esto significa que estará disponible para todos los objetos de cadena / literales.

Ejemplo:

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

El uso RegExpde JavaScript podría hacer el trabajo por usted, simplemente haga algo como el siguiente código, no olvide el /gdespués de lo cual se destaca para global :

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 que lo haga por usted, pero no se recomienda ya que es una función de una sola 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 úselo en su código una y otra vez como se muestra 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 que se escribirán o rendimiento, solo almacenar en caché la función puede afectar un rendimiento más rápido en cadenas largas y también una buena práctica de código DRY si desea reutilizar.

43

Digamos que desea reemplazar todos los 'abc' con '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 cuerda.

0
42

Usa una expresión regular:

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

Reemplazo de comillas simples:

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

    return text;
}
0
32

Rendimiento

Hoy 27.12.2019 realizo pruebas en macOS v10.13.6 (High Sierra) para las soluciones elegidas.

Conclusiones

  • La str.replace(/abc/g, '');( C ) es una buena solución rápida entre navegadores para todas las cadenas.
  • Las soluciones basadas en split-join( A, B ) o replace( C, D ) son rápidas
  • Las soluciones basadas en while( E, F, G, H ) son lentas, por lo general ~ 4 veces más lentas para cuerdas pequeñas y aproximadamente ~ 3000 veces (!) Más lentas para cuerdas largas
  • Las soluciones de recurrencia ( RA, RB ) son lentas y no funcionan para cadenas largas

También creo mi propia solución. Parece que actualmente es el más corto el que hace el trabajo de preguntas:

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

Detalles

Las pruebas se realizaron en Chrome 79.0, Safari 13.0.4 y Firefox 71.0 (64 bits). Las pruebas RAy el RBuso de la recursividad. Resultados

Ingrese la descripción de la imagen aquí

Cadena corta: 55 caracteres

Puede ejecutar pruebas en su máquina AQUÍ . Resultados para Chrome:

Ingrese la descripción de la imagen aquí

Cadena larga: 275 000 caracteres

Las soluciones recursivas RA y RB dan

RangeError: Maximum call stack size exceeded

Para 1 millón de caracteres, incluso rompen Chrome

ingrese la descripción de la imagen aquí

Intento realizar pruebas para 1 millón de caracteres para otras soluciones, pero E, F, G, H lleva tanto tiempo que el navegador me pide que rompa el guión, por lo que reduzco la cadena de prueba a 275 mil caracteres. Puede ejecutar pruebas en su máquina AQUÍ . Resultados para Chrome

ingrese la descripción de la imagen aquí

Código utilizado en las pruebas

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>
1
  • 2
    ¡Esta es una respuesta increíblemente profunda! ¡Muchos gracias! Aunque, lo que tengo curiosidad es por qué la sintaxis "nueva RegExp (...)" ofrece tanta mejora. 31 dic 2019 a las 12:59
29
str = str.replace(new RegExp("abc", 'g'), "");

funcionó mejor para mí que las respuestas anteriores. por lo 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, en su caso, cadena vacía ( ""). stres la cadena, y tenemos que anularla, ya que replace(...)solo devuelve el resultado, pero no anula. En algunos casos, es posible que desee usar eso.

0
28

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 el doble de rápido que el método split and join.

Como se señaló en un comentario aquí, esto no funcionará si su omitvariable 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 aún más rápido ( http://jsperf.com/replace-all-vs-split-join/12 )!

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

Repítelo hasta que el número de apariciones llegue a 0, así:

function replaceAll(find, replace, str) {
    while (str.indexOf(find) > -1) {
        str = str.replace(find, replace);
    }
    return str;
}
1
  • 24
    Este método es peligroso, no lo use. Si la cadena de reemplazo contiene la palabra clave de búsqueda, se producirá un bucle infinito. Como mínimo, almacene el resultado de .indexOfen una variable y use esta variable como el segundo parámetro de .indexOf(menos la longitud de la palabra clave, más la longitud de la cadena de reemplazo).
    Rob W
    29/10/2013 a las 11:33
23

Si lo que desea encontrar ya está en una cadena, y no tiene a mano un escalador de expresiones regulares, puede 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'));
0
20
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;
}
0
17

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

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

http://jsfiddle.net/ANHR9/

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

La forma más sencilla de hacerlo sin usar ninguna expresión regular es dividir y unir como el código aquí:

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

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

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

Las respuestas anteriores son demasiado complicadas. Simplemente use la función de reemplazo de esta manera:

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

Ejemplo:

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

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

console.log(res);
0
12

A partir de agosto de 2020, existe una propuesta de Etapa 4 para ECMAScript que agrega el replaceAllmétodo a String.

Ahora es compatible con Chrome 85+, Edge 85+, Firefox 77+, Safari 13.1+ .

El uso es el mismo que el replacemétodo:

String.prototype.replaceAll(searchValue, replaceValue)

Aquí hay un ejemplo de uso:

'Test abc test test abc test.'.replaceAll('abc', 'foo'); // -> 'Test foo test test foo test.'

Es compatible con la mayoría de los navegadores modernos , pero existen polyfills:

Se apoya en el motor V8 detrás de una bandera experimental --harmony-string-replaceall. Lea más en el sitio web de V8 .

1
  • Según MDN , esto ha estado disponible desde Firefox 77 y Chromium 85.
    pcworld
    3 de junio de 2020 a las 0:31
10

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

Por ejemplo:

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

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

El ciclo 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 por cada ciclo. Quizás (en riesgo de ser rechazado) que se pueda combinar para obtener 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 resultar particularmente útil cuando se buscan cadenas duplicadas.
Por ejemplo, si tenemos 'a ,,, b' y deseamos eliminar todas las comas duplicadas.
[En ese caso, se podría hacer .replace (/, + / g, ','), pero en algún momento la expresión regular se vuelve compleja y lo suficientemente lenta como para hacer un bucle].

0
10

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. Utilice la siguiente sintaxis

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

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

Puede consultar el ejemplo detallado aquí .

1
  • del sitio de ejemplo: "/ toBeReplacedString / gi es la expresión regular que necesita usar. Aquí g representa la coincidencia global e i representa no distingue entre mayúsculas y minúsculas. Por defecto, la expresión regular distingue entre mayúsculas y minúsculas"
    alikuli
    3 de agosto de 2016 a las 10:15
8

Solo agrega /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