todos - ¿Cómo reemplazar todas las apariciones de una cadena en JavaScript?
reemplazar un valor en javascript (30)
// 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/
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 here .
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 RegExp en JavaScript puede 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 que lo haga 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 úselo en su 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 a escribir o de rendimiento, solo el almacenamiento en caché de la función puede efectuar un rendimiento más rápido en cadenas largas y también una buena práctica de código DRY si desea reutilizarlo.
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).
Esta es la versión más rápida que no usa expresiones regulares .
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 de división y unión.
Como se señaló en un comentario aquí, esto no funcionará si su variable omit contiene un place , como en: replaceAll("string", "s", "ss") , porque siempre podrá reemplazar otra aparición de la palabra .
¡Hay otro jsperf con variantes en mi reemplazo recursivo que va incluso 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 el recientemente lanzado Chrome 59.
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");
Podrías intentar combinar estos dos métodos poderosos.
"test abc test test abc".split("abc").join("")
¡Espero eso ayude!
Reemplazo de comillas simples:
function JavaScriptEncode(text){
text = text.replace(/''/g,''''')
// 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 la cadena contiene un patrón similar como abccc , puedes usar esto:
str.replace(/abc(/s|$)/g, "")
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);
};
Simplemente siga esta expresión regular de oneliner agregando la distinción entre mayúsculas y minúsculas, así que si hace "ABC", actuaría de la misma manera que para "abc".
str = str.replace(/abc/gi, "");
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, '''');
Uso 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 apariciones en la cadena s hasta que sea posible:
replaceAll(''abbbbb'', ''ab'', ''a'') → ''abbbb'' → ''abbb'' → ''abb'' → ''ab'' → ''a''
Para evitar el bucle infinito, compruebo si la r de reemplazo contiene una coincidencia m :
replaceAll(''abbbbb'', ''a'', ''ab'') → ''abbbbb''
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.
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 , 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 (meta) especiales y, como tal, es peligroso pasar un argumento a ciegas en la función de find anterior sin procesarlo previamente para escapar de esos caracteres. Esto se trata en la Guía de JavaScript de Mozilla Developer Network sobre expresiones regulares , donde presentan la siguiente función de utilidad:
function escapeRegExp(str) {
return str.replace(/([.*+?^=!:${}()|/[/]////])/g, "//$1");
}
Por lo tanto, para 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);
}
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''
str = str.replace(new RegExp("abc", ''g''), "");
Funcionó mejor para mí que las respuestas anteriores. por lo que el new RegExp("abc", ''g'') crea un RegExp que coincide con toda la ocurrencia (marca ''g'' ) del texto ( "abc" ). La segunda parte es a lo que se reemplaza, en su caso cadena vacía ( "" ). str es la cadena, y debemos anularla, ya que replace(...) solo devuelve el resultado, pero no las anulaciones. En algunos casos es posible que desee utilizar eso.
var str = "ff ff f f a de def";
str = str.replace(/f/g,'''');
alert(str);
var string = ''Test abc Test abc Test abc Test abc''
string = string.replace(/abc/g, '''')
console.log(string)
while (str.indexOf(''abc'') !== -1)
{
str = str.replace(''abc'', '''');
}