regex another - Come sostituire tutte le occorrenze di una stringa in JavaScript?




with substring (25)

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

Ho questa stringa:

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

fare

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

sembra rimuovere solo la prima occorrenza di abc nella stringa sopra. Come posso sostituire tutte le occorrenze di esso?


Potresti provare a combinare questi due potenti metodi.

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

Spero che sia d'aiuto!


Questa è la versione più veloce che non usa espressioni regolari .

Revisionato jsperf

replaceAll = function(string, omit, place, prevstring) {
  if (prevstring && string === prevstring)
    return string;
  prevstring = string.replace(omit, place);
  return replaceAll(prevstring, omit, place, string)
}

È quasi due volte più veloce del metodo split e join.

Come indicato in un commento qui, questo non funzionerà se la variabile replaceAll("string", "s", "ss") contiene la place , come in: replaceAll("string", "s", "ss") , perché sarà sempre in grado di sostituire un'altra occorrenza della parola .

C'è un altro jsperf con varianti sul mio sostituto ricorsivo che vanno ancora più veloce ( http://jsperf.com/replace-all-vs-split-join/12 )!

  • Aggiornamento 27 luglio 2017: sembra che RegExp abbia ora le prestazioni più veloci nel Chrome 59 rilasciato di recente.

Usare RegExp in JavaScript potrebbe fare il lavoro per te, semplicemente fai qualcosa di simile qui sotto:

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

Se pensi di riutilizzare, crea una funzione per farlo per te, ma non è raccomandato in quanto è una sola funzione di linea, ma ancora una volta se usi pesantemente questo, puoi scrivere qualcosa come questo:

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

e semplicemente usarlo nel tuo codice più e più volte come di seguito:

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

Ma come detto in precedenza, non farà un'enorme differenza in termini di righe da scrivere o prestazioni, solo il caching della funzione potrebbe avere delle prestazioni più veloci su stringhe lunghe e anche una buona pratica del codice DRY se si desidera riutilizzare.


Nota: non usare questo nel codice reale.

In alternativa alle espressioni regolari per una semplice stringa letterale, puoi usare

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

Lo schema generale è

str.split(search).join(replacement)

In alcuni casi questo replaceAll era più veloce dell'uso di replaceAll e un'espressione regolare, ma non sembra più il caso nei browser moderni. Quindi, questo dovrebbe essere usato solo come un trucco rapido per evitare di dover sfuggire all'espressione regolare, non nel codice reale.


Sebbene la gente abbia menzionato l'uso della regex ma c'è un approccio migliore se si vuole sostituire il testo indipendentemente dal caso del testo. Come maiuscole o minuscole. Usa sotto la sintassi

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

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

Puoi fare riferimento all'esempio dettagliato here .


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

In risposta al commento:

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

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

In risposta al commento di , puoi semplificarlo ancora di più:

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

Nota: le espressioni regolari contengono caratteri speciali (meta) e in quanto tale è pericoloso passare ciecamente un argomento nella funzione di find sopra senza pre-elaborarlo per sfuggire a quei caratteri. Questo è spiegato nella Guida JavaScript di Mozilla Developer Network su Espressioni regolari , in cui vengono presentate le seguenti funzioni di utilità:

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

Quindi, per rendere la funzione replaceAll() sopra più sicura, potrebbe essere modificata alla seguente se si include anche escapeRegExp :

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


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

Usa un'espressione regolare:

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

Basta seguire questa espressione regolare di oneliner aggiungendo la sensibilità alla distinzione tra maiuscole e minuscole, quindi se si esegue "ABC", si comporterebbe allo stesso modo di "abc".

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

L'uso di un'espressione regolare con il flag g set sostituirà tutto:

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

Vedi anche qui


Se la stringa contiene pattern simili come abccc , puoi usare questo:

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

Ecco una funzione di prototipo di stringa basata sulla risposta accettata:

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

MODIFICARE

Se la tua find conterrà caratteri speciali, dovrai sfuggire a loro:

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

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


Sostituire le virgolette singole:

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

    return text;
}

Corrisponde a un'espressione regolare globale:

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

Io uso p per memorizzare il risultato della precedente ricorsione:

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

Sostituirà tutte le occorrenze nella stringa s finché non sarà possibile:

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

Per evitare loop infiniti, controllo se la sostituzione r contiene una corrispondenza m :

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

// loop fino a quando le occorrenze del numero arrivano a 0. OPPURE semplicemente copia / incolla

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

Puoi semplicemente usare sotto il metodo

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

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

Oppure prova la funzione replaceAll da qui:

Quali sono i metodi JavaScript utili che estendono gli oggetti incorporati?

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

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

EDIT: chiarimenti sulla sostituzione di tutte le disponibilità

Il metodo 'replaceAll' viene aggiunto al prototipo di String. Ciò significa che sarà disponibile per tutti gli oggetti stringa / letterali.

Per esempio

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

Se ciò che vuoi trovare è già in una stringa, e non hai un comando di espressione regolare, puoi usare 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'));


Mi piace questo metodo (sembra un po 'più pulito):

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

La seguente funzione funziona per me:

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

ora chiama le funzioni in questo modo:

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

Basta copiare e incollare questo codice nella tua console del browser su TEST.


Supponi di voler sostituire tutti '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

Stavo cercando di pensare a qualcosa di più semplice della modifica del prototipo di stringa.


Ogni volta che vedi la parola chiave function all'interno di un'altra funzione, la funzione inner ha accesso alle variabili nella funzione esterna.

function foo(x) {
  var tmp = 3;

  function bar(y) {
    console.log(x + y + (++tmp)); // will log 16
  }

  bar(10);
}

foo(2);

Questo logarà sempre 16, perché la bar può accedere alla x che è stata definita come un argomento a foo , e può anche accedere a tmp da foo .

Questa è una chiusura. Una funzione non deve tornare per essere chiamata una chiusura. Semplicemente l'accesso a variabili esterne all'ambito lessicale immediato crea una chiusura .

function foo(x) {
  var tmp = 3;

  return function (y) {
    console.log(x + y + (++tmp)); // will also log 16
  }
}

var bar = foo(2); // bar is now a closure.
bar(10);

La funzione precedente registrerà anche 16, perché la bar può ancora fare riferimento a x e tmp , anche se non è più direttamente all'interno dell'ambito.

Tuttavia, poiché tmp è ancora in agguato all'interno della chiusura della bar , viene anche incrementato. Sarà incrementato ogni volta che chiami bar .

L'esempio più semplice di chiusura è questo:

var a = 10;

function test() {
  console.log(a); // will output 10
  console.log(b); // will output 6
}
var b = 6;
test();

Quando viene invocata una funzione JavaScript, viene creato un nuovo contesto di esecuzione. Insieme agli argomenti della funzione e all'oggetto padre, questo contesto di esecuzione riceve anche tutte le variabili dichiarate al di fuori di esso (nell'esempio precedente, sia 'a' che 'b').

È possibile creare più di una funzione di chiusura, restituendone una lista o impostandole su variabili globali. Tutti questi si riferiscono alla stessa x e allo stesso tmp , non fanno le proprie copie.

Qui il numero x è un numero letterale. Come con altri letterali in JavaScript, quando viene chiamato foo , il numero x viene copiato in foo come argomento x .

D'altra parte, JavaScript usa sempre riferimenti quando si tratta di oggetti. Se dici, hai chiamato foo con un oggetto, la chiusura restituita farà riferimento a quell'oggetto originale!

function foo(x) {
  var tmp = 3;

  return function (y) {
    console.log(x + y + tmp);
    x.memb = x.memb ? x.memb + 1 : 1;
    console.log(x.memb);
  }
}

var age = new Number(2);
var bar = foo(age); // bar is now a closure referencing age.
bar(10);

Come previsto, ogni chiamata a bar(10) incrementerà x.memb . Ciò che potrebbe non essere previsto, è che x si riferisce semplicemente allo stesso oggetto della variabile di age ! Dopo un paio di chiamate al bar , age.memb sarà 2! Questo riferimento è la base per perdite di memoria con oggetti HTML.





javascript regex string replace