valor - replace javascript todas ocurrencias




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

// repítala hasta que el número llegue a 0. O simplemente copie / pegue

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

Tengo esta cadena:

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

Obra

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

Parece que solo se elimina la primera aparición de abc en la cadena anterior. ¿Cómo puedo reemplazar todas las apariciones?


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 su find contendrá caracteres especiales, entonces necesita escapar de ellos:

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

Fiddle: http://jsfiddle.net/cdbzL/


Coincidir contra una expresión regular global:

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

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


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"

Ver aqui tambien


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, generalmente no se recomienda extender los prototipos incorporados en JavaScript. Proporciono como extensiones en el prototipo String simplemente con fines ilustrativos, mostrando diferentes implementaciones de un método estándar hipotético en el prototipo incorporado en String .

Implementación basada en expresiones regulares

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

Dividir y unir la implementació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 inclinarme hacia la división y unir la implementación en el pasado sin pensar en el rendimiento. Cuando me pregunté cuál era más eficiente y por qué margen, lo usé como excusa para descubrirlo.

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

Echa un vistazo a este benchmark ejecutando estas dos implementaciones entre sí.

Como se señala en el comentario a continuación por @ThomasLeduc y otros, podría haber un problema con la implementación basada en expresiones regulares si la search contiene ciertos caracteres que están reservados como caracteres especiales en expresiones regulares . La implementación asume que el llamante escapará de la cadena de antemano o solo pasará cadenas que no tienen 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, por desgracia, no existe:

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

Podríamos llamar a escapeRegExp dentro de nuestra implementación String.prototype.replaceAll , 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).


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 como esta:

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


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

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

Reemplazo de comillas simples:

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

    return text;
}

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

Por ejemplo:

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

Cuando termine, todavía tendrá 'test 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 se ejecuta el reemplazo dos veces para cada ciclo. Quizás (en riesgo de ser rechazado) se pueda combinar para obtener una forma ligeramente 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 deseamos eliminar todas las comas duplicadas.
[En ese caso, uno podría hacer .replace (/, + / g, ','), pero en algún punto la expresión regular se vuelve lo suficientemente compleja y lenta como para hacer un bucle.]


Si lo que quiere encontrar ya está en una cadena, y no tiene a mano un manual de expresión regular, puede usar unir / dividir:

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

    someString = 'the cat looks like a cat';
    console.log(replaceMulti(someString, 'cat', 'dog'));


Simplemente puede utilizar el método de abajo

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

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


Usa una expresión regular:

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

Actualizar:

Es un poco tarde para una actualización, pero ya que me topé 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 los límites de las 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. Por lo tanto, se pueden usar condicionales en este caso para evitar el reemplazo de 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, verifica la respuesta que di allí ... regexp no es la única forma de reemplazar las múltiples apariciones de una subsrting, ni mucho menos. ¡Piensa flexible, piensa dividido!

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

Alternativamente, para evitar el reemplazo de partes de palabras, ¡la respuesta aprobada también lo hará! Puede solucionar este problema utilizando expresiones regulares que son, lo admito, algo más complejas y, como resultado de esto, también un poco más lento:

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, utilizando 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 es lo que quieres. ¿Que es entonces? En mi humilde opinión, una expresión regular que solo reemplaza condicionalmente a 'cat'. (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"

Mi conjetura es, esto satisface sus necesidades. Por supuesto, no es totalmente resistente, 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 tiene 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 dramáticamente la expresión y proporciona aún más flexibilidad, como reemplazar con mayúsculas correctas o reemplazar a 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

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 ya no parece ser el caso en los navegadores modernos. Por lo tanto, esto solo debería usarse como un truco rápido para evitar tener que escapar de la expresión regular, no en código real.


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

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

O pruebe la función replaceAll desde aquí:

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

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

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

EDITAR: Aclaración acerca de reemplazar toda la disponibilidad

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

P.ej

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


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




replace