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


Answers

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ías 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 un argumento a ciegas en la función de find anterior sin preprocesarlo para escapar de esos caracteres. Esto se trata en la Guía de JavaScript de Mozilla Developer Network en expresiones regulares , donde presentan la siguiente función de utilidad:

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

Por lo tanto, para hacer que la función replaceAll() 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);
}
Question

Tengo esta cadena:

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

Obra

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

parece solo eliminar la primera aparición de abc en la cadena de arriba. ¿Cómo puedo reemplazar todas las apariciones?




Solo 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 significa global




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



Simplemente puede usar el método a continuación

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



function replaceAll(str, find, replace) {
    var $r="";
    while($r!=str){ 
        $r = str;
        str = str.replace(find, replace);
    }
    return str;
}



Mi implementación, muy explicativa

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



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

O pruebe la función replaceAll desde aquí:

¿Cuáles son los métodos de JavaScript útiles que amplían los objetos incorporados?

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

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

EDIT: aclaración sobre replaceToda disponibilidad

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

P.ej

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



Digamos que quiere 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 cuerda.




Para reemplazar todo tipo de caracteres, pruebe este código:

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

Entonces este método resolverá este 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 \\"*/

Estaba usando Ajax, y tuve la necesidad de enviar parámetros en formato JSON. Entonces mi método se ve así:

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



Si lo que quieres encontrar ya está en una cadena, y no tienes a mano un escarabajo de expresiones regulares, puedes usar join / split:

function replaceMulti(haystack, needle, replacement)
{
    return haystack.split(needle).join(replacement);
}

someString = 'the cat looks like a cat';
anotherString = replaceMulti(someString, 'cat', 'dog');



El uso de una expresión regular con el conjunto de indicadores g reemplazará a todos:

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

Vea aquí también




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



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 más rápido que el método de división y unión.

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 será capaz de reemplazar otra ocurrencia de la palabra .

Hay otra 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 Chrome 59 recientemente lanzado.



Actualizar:

Es algo tarde para una actualización, pero desde que me encontré con esta pregunta, y noté que mi respuesta anterior no es con la que estoy contento. Dado que la pregunta implicaba reemplazar una sola palabra, es increíble que a nadie se le haya ocurrido utilizar 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 guion - 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 aquí: Javascript reemplaza "'" por "' '"

@Mike, verifique la respuesta que di allí ... la expresión regular no es la única forma de reemplazar múltiples ocurrencias de una subserie, ni mucho menos. ¡Piensa flexible, piensa dividido!

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

Alternativamente, para evitar reemplazar partes de palabras, ¡lo cual también será la respuesta aprobada! Puede solucionar este problema utilizando expresiones regulares que, reconozco, son 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");

El resultado es el mismo 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. ¿Que es entonces? En mi humilde opinión, una expresión regular que solo reemplaza 'gato' condicionalmente. (es decir, no forma 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 tus necesidades. No es a prueba de todo, por supuesto, pero debería ser suficiente para comenzar. Recomiendo leer un poco más en estas páginas. Esto será útil para perfeccionar esta expresión y satisfacer sus necesidades específicas.

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

http://www.regular-expressions.info

Además final:

Dado que esta pregunta aún 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, simplifica enormemente la expresión y proporciona aún más flexibilidad, como reemplazar con mayúsculas o reemplazar 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



La mayoría de las personas probablemente hagan esto para codificar una URL. Para codificar una URL, no solo debe considerar los espacios, sino también convertir la cadena completa correctamente con encodeURI .

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

Llegar:

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