Come sostituire tutte le occorrenze di una stringa in JavaScript

Ho questa stringa:

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

Facendo

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

sembra di rimuovere solo la prima occorrenza di abc nella stringa di cui sopra. Come posso sostituire tutti occorrenze?

stackoverflow.com/questions/1137436/…
SEMPLICE: var str = 'abcabcbabc'; str.replace(/a/g, 'x'); --> 'xbcxbcxbc
Attenzione che Federico opzione è di gran lunga come la stringa-di-essere-sostituito non include speciali regex caratteri.
Speciale regex caratteri possono essere fuggito da caratteri normali.
Per chiunque si stia chiedendo, si può sfuggire a una regex da un backslash. Per esempio, str.replace(/\]/g) dovrebbe funzionare, ma non str.replace(/]/g)’] ‘ è una speciale regex carattere.

OriginaleL’autore Click Upvote | 2009-07-17

29 Replies
  1. 1828

    Per completezza, ho avuto modo di pensare che metodo devo utilizzare per fare questo. Ci sono fondamentalmente due modi per fare questo, come suggerito dalle altre risposte su questa pagina.

    Nota: In generale, estendendo il built-in di prototipi in JavaScript non è generalmente raccomandato. Io sono in grado di fornire estensioni sulla Corda prototipo semplicemente per scopi di illustrazione, che mostra diverse implementazioni di un ipotetico metodo standard sul String built-in prototipo.


    Espressione Regolare Basata Attuazione

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

    Split e Join (Funzionale) Attuazione

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

    Non sapere troppo su come le espressioni regolari lavorare dietro le quinte, in termini di efficienza, ho la tendenza ad appoggiarsi verso lo split e join attuazione in passato, senza pensare prestazioni. Quando l’ho fatto chiedo che era più efficiente, e con quale margine, ho usato come una scusa per trovare out.

    Sul mio Chrome 8 macchina, l’espressione regolare a base di implementazione è il più veloce, con il split e join attuazione del 53% più lento. Significato di espressioni regolari sono due volte più veloce per i lorem ipsum input che ho usato.

    Check out questo benchmark l’esecuzione di queste due implementazioni contro l’altro.


    Come indicato nel commento di seguito da @ThomasLeduc e gli altri, ci potrebbe essere un problema con l’espressione regolare implementazione basata su se search contiene alcuni caratteri sono riservati come caratteri speciali nelle espressioni regolari. L’attuazione si presuppone che il chiamante sfuggire la corda, prima o solo passare le stringhe che sono senza i caratteri nella tabella in Le Espressioni Regolari (MDN).

    MDN, inoltre, fornisce un’implementazione di sfuggire alle nostre corde. Sarebbe bello se questo è stato standardizzato come RegExp.escape(str), ma, ahimè, non esiste:

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

    Potremmo chiamare escapeRegExp all’interno del nostro String.prototype.replaceAll attuazione, tuttavia, io non sono sicuro di quanto questo influisce sulle prestazioni (potenzialmente anche per le stringhe, per cui la fuga non è necessario, come tutte le stringhe alfanumeriche).

    Su Android 4.1 regexp metodo è il 15% più velocemente, ma non in fuga l’espressione per la ricerca, in modo che questo benchmark è incompleta.
    C’è un problema con questa soluzione, se siete di ricerca appare una stringa contiene caratteri speciali di una regexp di espressione, che sarà interpretato. Mi raccomando @Sandy Unitedwolf risposta.
    Il primo a fare questo: ‘bla.bla’.replaceAll(‘.’, ‘_’); “_______”. La seconda sarà la do ‘bla_bla’, che è più in generale che cosa si vuole fare.
    Sorvolare risposta. Vai al prossimo, “non corretto”-segnato risposta con 5 volte in più di voti. Che è quello che vuoi.
    sembra che il problema che hai citato può essere lavorato con lodash => lodash.com/docs/4.17.5#escapeRegExp

    OriginaleL’autore Cory Gross

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

    In risposta al commento:

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

    In risposta a Fare Clic Su Upvote‘s commento, si potrebbe semplificare ancora di più:

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

    Nota: espressioni Regolari contengono speciali (meta) caratteri, e come tale è pericoloso, alla cieca, il passaggio di un argomento in find funzione di cui sopra, senza pre-trattamento per la fuga di quei personaggi. Questo è coperto in Mozilla Developer Network‘s JavaScript Guida sulle Espressioni Regolari, dove presentano la seguente funzione di utilità:

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

    Modo per rendere il replaceAll() funzione di cui sopra è più sicura, ma potrebbe essere modificato per il seguente se si includono anche escapeRegExp:

    function replaceAll(str, find, replace) {
        return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);
    }
    Le espressioni regolari sono l’unico modo per realizzare questo “out of the box” senza la necessità di implementare il proprio ‘replaceAll’ metodo. Non sto suggerendo loro utilizzo solo per il bene del loro utilizzo.
    Questa è la mia funzione da questo commento: function replaceAll(find, replace,str) { var re = new RegExp(find, 'g'); str = str.replace(re, replace); return str; }
    Grande prudenza del replaceAll implementazione è che non funziona se find contiene metacaratteri.
    hai ragione. Ho usato il tuo codice javascript in un codice php, quindi ho dovuto aggiungere un’ulteriore barra rovesciata di fuga. Il violino il codice è perfetto. Ho dovuto controllare. Scuse jsfiddle.net/7y19xyq8
    e ‘ la cattiva pratica di estendere il prototipo di JavaScript nativo tipi.

    OriginaleL’autore Sean Bright

  3. 1220

    Nota: non utilizzare questo codice vero e proprio.

    Come alternativa alle espressioni regolari per una semplice stringa letterale, si potrebbe utilizzare

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

    Lo schema generale è

    str.split(search).join(replacement)

    Questo usato per essere più veloce, in alcuni casi, rispetto all’utilizzo di replaceAll e una espressione regolare, ma che non sembra essere il caso più moderni browser. Quindi, questo in realtà dovrebbe essere utilizzato solo come un rapido trucco per evitare di dover sfuggire l’espressione regolare, non nel codice reale.

    Mi ha sorpreso, come mi sarei aspettato questo metodo di allocazione di oggetti, creare più rifiuti, e quindi richiede più tempo, ma quando ho effettivamente testato in un browser questo metodo è stato costantemente circa il 20% più veloce rispetto del accettato la risposta. I risultati possono variare, naturalmente.
    Ero curioso di me, e impostare in questo modo: jsperf.com/replace-all-vs-split-join . Sembra che il v8 è solo pazzo veloce a dividere/unire le matrici rispetto ad altri motori javascript.
    Molto bella, anche evita la possibilità di bad Espressioni quando si passa in caratteri speciali. Io sono l’aggiunta di un generico contrassegno per “trovare questo e sostituirlo” in una proprietà di un oggetto, ma è stato interessato, se avevo bisogno di sostituire “.” o “}” e si è dimenticato che stavo usando l’espressione regolare, dopo 3 mesi!
    Sul mio ipad2/safari, split/join è il 65% più lento di sostituire in modo che i risultati possono variare.
    E come Stringa.prototipo: String.prototype.replaceAll = function(f,r){return this.split(f).join(r);}. Utilizzo: "My string".replaceAll('st', ''); produce “il Mio anello”

    OriginaleL’autore Matthew Crumley

  4. 525

    Utilizzando un’espressione regolare con il g impostato il flag andrà a sostituire tutti:

    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

    Un pò sciocco penso, ma il JS globale regex è l’unico modo per fare più sostituisce.
    tecnicamente è possibile scorrere var sourceText contare il numero di istanze (numOfInstances) utilizzando substring o dividere e contare la lunghezza (che tra le altre strategie) di thatWhichYouWantToReplace quindi fare for (var i = 0; i < numOfInstances; i++){ sourceText = sourceText.replace('thatWhichYouWantToReplace', ''); } o anche più facile basta usare un ciclo while (while sourceText.indexOf(thatWhichYouWantToReplace > -1){ sourceText = sourceText.replace(...)) ma non vedo il motivo per cui si desidera farlo in quel modo quando si utilizza /g è così facile e, probabilmente, più performante.

    OriginaleL’autore Adam A

  5. 92

    Ecco una stringa prototipo di funzione basata sull’accettato risposta:

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

    MODIFICA

    Se il tuo find con caratteri speciali, allora avete bisogno di fuggire da loro:

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

    Violino: http://jsfiddle.net/cdbzL/

    Ma cosa succede se find contiene caratteri come . o $ che hanno significati speciali in regex?
    In quel caso avresti anche per sfuggire trovare variabile (vedere modifica di cui sopra).
    non modificare gli oggetti non proprio
    jesal, questa è una soluzione meravigliosa per una sostituzione di stringa problema che ho incontrato, e a quanto pare vince il “immutabilità” di stringhe in JavaScript. Si potrebbe, o qualcun altro, spiega come questo prototipo di funzione sostituisce l’immutabilità delle stringhe? Questo non di lavoro; voglio solo capire questo ausiliari, la questione si pone.
    non superare l’immutabilità: var str = this crea un secondo riferimento all’immutabile stringa, per cui il replace metodo è applicato, che a sua volta restituisce un nuovo immutabile string. questi prototipi di funzioni restituiscono un nuovo immutabile stringa, se non, si sarebbe in grado di scrivere someStrVar.replaceAll('o', '0'); e someStrVar sarebbe cambiato. Invece, è necessario scrivere someStrVar = someStrVar.replaceAll('o', '0'); <– di riassegnare a impostare il var per tenere il nuovo immutabile string. non c’è alcun modo per aggirare. Provare in console: x = 'foobar'; x.replaceAll('o', '0'); x;

    OriginaleL’autore jesal

  6. 75

    Aggiornamento:

    È un po ‘ tardi per un aggiornamento, ma siccome mi sono appena imbattuto in questa domanda, e ho notato che la mia precedente risposta non è uno, sono felice con. Poiché la domanda coinvolti replaceing una sola parola, e ‘ incredibile come nessuno ha mai pensato di usare i confini di parola (\b)

    'a cat is not a caterpillar'.replace(/\bcat\b/gi,'dog');
    //"a dog is not a caterpillar"

    Questa è una semplice espressione regolare che evita la sostituzione di parti di parole, nella maggior parte dei casi. Tuttavia, un pizzico - è ancora considerato un confine di parola. Così condizionali possono essere utilizzati in questo caso per evitare la sostituzione di stringhe come 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"

    fondamentalmente, questa domanda è la stessa domanda qui:
    Javascript sostituire “‘ “” ” “

    @Mike, controllare la risposta che ho dato… regexp non è l’unico modo per sostituire più occorrenze di un subsrting, lontano da esso. Penso flessibile, pensare a split!

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

    In alternativa, per evitare la sostituzione di parti parola -che l’ha approvato risposta farà, troppo! È possibile ottenere intorno a questo problema utilizzando le espressioni regolari che sono, lo ammetto, un po ‘più complesso, e come risultato di che, un po’ più lento, troppo:

    var regText = "the cat looks like a cat".replace(/(?:(^|[^a-z]))(([^a-z]*)(?=cat)cat)(?![a-z])/gi,"$1dog");

    L’output è lo stesso come il accettato la risposta, tuttavia, utilizzando il /cat/g espressione questa stringa:

    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, infatti, questo probabilmente non è ciò che si desidera. Che cos’è, allora? IMHO, una regex che solo si sostituisce al ‘gatto’ in modo condizionale. (cioè non una parte di una parola), in questo modo:

    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"

    La mia ipotesi è che questo soddisfi le vostre esigenze. Non fullproof, naturalmente, ma dovrebbe essere sufficiente per iniziare. Mi raccomando la lettura di alcuni di più su queste pagine. Questo sarà rivelarsi utile per il perfezionamento di questa espressione per soddisfare le vostre esigenze specifiche.

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

    http://www.regular-expressions.info


    Aggiunta finale:

    Dato che questa domanda non ottiene ancora un sacco di punti di vista, ho pensato di aggiungere un esempio di .replace utilizzato con una funzione di callback. In questo caso, si semplifica notevolmente l’espressione e offre una maggiore flessibilità, come la sostituzione con una corretta capitalizzazione o la sostituzione di entrambi cat e cats in un colpo solo:

    '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
    Penso che l’interesse ulteriore, da parte messo in fondo. ps.: Ho notato solo ora che la metà della prima riga è al di fuori della zona, mi permetta di consentire di risolvere i!

    OriginaleL’autore Elias Van Ootegem

  7. 51

    Partita contro una globale espressione regolare:

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

    OriginaleL’autore scronide

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

    O provare il replaceAll funzione da qui:

    Che cosa sono utili metodi JavaScript che si estende oggetti incorporati?

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

    EDIT: Chiarimenti in merito replaceAll disponibilità

    ‘ReplaceAll’ metodo viene aggiunto alla Stringa del prototipo. Questo significa che sarà disponibile per tutti gli oggetti stringa/letterali.

    E. g.

    var output = "test this".replaceAll('this', 'that');  //output is 'test that'.
    output = output.replaceAll('that', 'this'); //output is 'test this'
    Si può riscrivere la replaceAll() funzione per coloro che non utilizzano prototipo?
    Upvote….si utilizza prototipo, è parte di tutti i oggetti JS. Penso che si sta pensando di prototype.js la libreria JS.
    seth, un po ‘ di correzione. Se si aggiunge il metodo di un prototipo, è a disposizione di tutti gli oggetti di quel tipo. Il replceAll metodo è stato aggiunto alla Stringa di prototipo e dovrebbe funzionare per tutti gli oggetti stringa.
    Sì, ho utilizzato un prototipo (correttamente) prima. Ero solo affrontare l’OP commento su “non utilizzare prototipo” che ho assunto a significare Prototype.js (forse in modo non corretto?). Io avrei detto “un prototipo di” come stavo cercando di dire JavaScript oggetti hanno un prototipo. Così, l’OP era gia ‘utilizzando prototipo,’ anche se in maniera “indiretta”. Indiretta potrebbe essere il termine sbagliato a usare qui, ma io sono stanco, quindi mea culpa.

    OriginaleL’autore SolutionYogi

  9. 30

    Dire che si desidera sostituire all ‘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 che modificare la stringa di prototipo.

    Semplice, facile, e probabilmente il più performante opzione: bella risposta.
    Non so se a livello di prestazioni, ma…. funziona.
    In realtà, mentre non ho metrico-de personalmente, split/join è di solito un molto performante soluzione.
    è anche in chrome, 100% più veloce di firefox, e il 50% più lento di IE…: jsperf.com/replace-regex-split-join

    OriginaleL’autore Emilio Grisolía

  10. 25

    Sostituzione di citazioni:

    function JavaScriptEncode(text){
        text = text.replace(/'/g,'&apos;')
        //More encode here if required
    
        return text;
    }
    Come posso modificare la seconda riga, sostituire le stringhe? Questo non funziona: testo = testo.replace(‘ciao’, ‘ciao’); Qualche idea?
    Certo Stefan, ecco il codice… testo = testo.replace(/hey/g, ‘ciao’);

    OriginaleL’autore Chris OnDaRocks

  11. 22

    //loop fino a quando il numero di occorrenze arriva a 0. O semplicemente copia/incolla

        function replaceAll(find, replace, str) 
        {
          while( str.indexOf(find) > -1)
          {
            str = str.replace(find, replace);
          }
          return str;
        }
    Questo metodo è pericoloso, non lo uso. Se la stringa di sostituzione contiene la parola chiave di ricerca, quindi un ciclo infinito si verificherà. Almeno, di memorizzare il risultato di .indexOf in una variabile, e utilizzare questa variabile come secondo parametro di .indexOf (meno la lunghezza della parola chiave, più la lunghezza della stringa di sostituzione).
    Sto pensando prima di sostituire il modello di ricerca con un weired unicode char, di che, siamo sicuri, non è utilizzato nella stringa di input. Come U+E000 in area privata. E poi sostituirlo verso la destinazione. ne ho costruito qui.. Non so se è una buona Idea.

    OriginaleL’autore Raseela

  12. 20

    Questo è il più veloce versione che non usare le espressioni regolari.

    Rivisto 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 veloce come la separazione e il metodo join.

    Come sottolineato in un commento qui, questo non funzionerà se il tuo omit variabile contiene place, come in: replaceAll("string", "s", "ss"), poiché sarà sempre in grado di sostituire un’altra occorrenza della parola.

    C’è un altro jsperf con varianti sul mio ricorsiva sostituire che andare ancora più veloce (http://jsperf.com/replace-all-vs-split-join/12)!

    • Aggiornamento 27 luglio 2017: sembra RegExp ora ha le prestazioni più elevate, con il rilascio di Chrome 59.
    Ho amato la tua soluzione… vorrei poter dare +10 ma qui è il mio +1. Penso che si può indice di archivio della sotto-stringa che è stato sostituito e passare al successivo, se viene trovata una corrispondenza, a un più basso indice per evitare che il ciclo infinito problema. Io non commento sulle prestazioni, perché io non l’ho provato ma solo i miei 2 cents su questo pezzo di eccellenza.
    se si desidera controllare se omettere è a posto (per evitare loop infinito) si potrebbe fare un condizionale come if(place.replace(omit) === omit) { Non c’è partita, quindi è sicuro da usare sostituire loop } else { Partita, quindi utilizzare il metodo diverso come dividere e unire }
    Hmm.. ma che cosa è il punto di combinazione di due soluzioni? Io comunque non sono un fan di split/join approccio comunque.. grazie per i consigli..
    Credo che lo scopo di combinare le due soluzioni sarebbe il ripiego su un metodo più lento se non è possibile utilizzare il più veloce (quando il ciclo sarebbe infinito per esempio). Quindi sarebbe una sicura protezione per assicurare la funzionalità, l’efficienza, ma senza possibilità di errore.
    Viziata…………

    OriginaleL’autore Cole Lawrence

  13. 19
    str = str.replace(new RegExp("abc", 'g'), "");

    lavorato meglio per me le risposte di cui sopra. così new RegExp("abc", 'g') crea una RegExp che corrisponda a tutte le occorrenze ('g' bandiera) del testo ("abc"). La seconda parte è ciò che viene sostituito, nel tuo caso la stringa vuota ("").
    str è la stringa, e dobbiamo ignorare, come replace(...) restituisce solo il risultato, ma non la sostituisce. In alcuni casi è possibile che si desidera utilizzare.

    Mentre questo frammento di codice può essere la soluzione, tra una spiegazione aiuta davvero a migliorare la qualità del tuo post. Ricordati che stai rispondendo alla domanda per i lettori in futuro, e che queste persone potrebbero non sapere le ragioni per il vostro suggerimento di codice.
    Sì, hai ragione. aggiunto. anche essere modificate per rispondere alla domanda originale 🙂
    Nota: g flag in regex significa che è flag globale che corrisponde a tutte le occorrenze

    OriginaleL’autore csomakk

  14. 15
    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;
    }
    Mi chiedo come bene che la esegue … sottostringa è nativo o passeggiate su array di char per creare nuovi personaggi.

    OriginaleL’autore Tim Rivoli

  15. 14

    Utilizzando RegExp in JavaScript potrebbe fare il lavoro per voi, basta semplicemente fare qualcosa, come di seguito:

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

    Se si pensa di reimpiego, di creare una funzione per fare questo per voi, ma non è raccomandato in quanto è solo una funzione di riga, ma, se è pesantemente ottenere l’uso di questo, si può scrivere qualcosa di simile a questo:

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

    e basta che il tuo codice, codice e come di seguito:

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

    Ma come ho detto in precedenza, non farà una differenza enorme in termini di linee di prestazioni o scritta, solo la cache la funzione è possibile effettuare alcune prestazioni più veloci su stringhe lunghe e anche una buona pratica di LAVAGGIO codice se si desidera riutilizzare.

    OriginaleL’autore Alireza

  16. 12
    var str = "ff ff f f a de def";
    str = str.replace(/f/g,'');
    alert(str);

    http://jsfiddle.net/ANHR9/

    qual è stato il punto di un violino che contiene solo lo stesso javascript

    OriginaleL’autore pkdkk

  17. 12
    while (str.indexOf('abc') !== -1)
    {
        str = str.replace('abc', '');
    }
    che cosa è sbagliato con questo? Ho pensato che era molto bello

    OriginaleL’autore zdennis

  18. 11

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

    text = text.replace(new RegExp("cat","g"), "dog"); 
    Ok, come si fa sfuggire la stringa da utilizzare come una espressione regolare?

    OriginaleL’autore Owen

  19. 10

    Se la stringa contiene modello simile come abccc, è possibile utilizzare questo:

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

    OriginaleL’autore

  20. 10

    Basta seguire questa oneliner regex aggiunta il caso di sensibilità, in modo che, se “ABC”, avrebbe agito lo stesso per “abc”.

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

    OriginaleL’autore Ankit

  21. 9

    Se si sta cercando di fare in modo che la stringa che si sta cercando non esiste, anche dopo la sostituzione, è necessario utilizzare un ciclo.

    Per esempio:

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

    Al termine, si avrà ancora ‘test abc’!

    Più semplice anello per risolvere questo sarebbe:

    var str = 'test aabcbc';
    while (str != str.replace(/abc/g, '')){
       str.replace(/abc/g, '');
    }

    Ma che esegue la sostituzione di due volte per ogni ciclo. Forse (a rischio di essere trombato) che possono essere combinati per un po ‘ più efficiente, ma meno leggibile:

    var str = 'test aabcbc';
    while (str != (str = str.replace(/abc/g, ''))){}
    //alert(str); alerts 'test '!

    Questo può essere particolarmente utile quando si cerca di duplicare le stringhe.

    Per esempio, se abbiamo una,,,b’ e si desidera rimuovere tutti i duplicati virgole.

    [In questo caso, si potrebbe fare .replace(/,+/g,’,’), ma a un certo punto la regex diventa lento e complesso abbastanza per loop.]

    Downvoters cura di spiegare? La risposta è corretta nel caso in cui tale soluzione è necessario.

    OriginaleL’autore SamGoody

  22. 8
    var string  = 'Test abc Test abc Test abc Test abc'
    string = string.replace(/abc/g, '')
    console.log(string)
    Questa sembra essere una semplice ripetizione di risposta (e molti altri esistenti risposte).

    OriginaleL’autore Ashutosh Narang

  23. 7

    Si può semplicemente utilizzare il metodo sotto

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

    OriginaleL’autore tk_

  24. 7

    Anche se hanno menzionato l’uso delle espressioni regolari, ma non c’è un migliore approccio se si desidera sostituire il testo, a prescindere dal caso del testo. Come maiuscole o minuscole. Utilizzare sotto sintassi

    //Consider below example
    originalString.replace(/stringToBeReplaced/gi, '');
    
    //Output will be all the occurrences removed irrespective of casing.

    È possibile consultare la cartina esempio qui.

    dal sito di esempio: “/toBeReplacedString/gi è la regex che è necessario utilizzare. Qui g rappresenta globale per partita e mi rappresenta distinzione tra maiuscole e minuscole. Per impostazione predefinita regex è case sensitive”

    OriginaleL’autore Cheezy Code

  25. 6

    Si potrebbe provare a combinare le due potenti metodi.

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

    Speranza che aiuta!

    OriginaleL’autore Victor

  26. 6

    Basta aggiungere /g

    document.body.innerHTML = document.body.innerHTML.replace('hello', 'hi');

    per

    //Replace 'hello' string with /hello/g regular expression.
    document.body.innerHTML = document.body.innerHTML.replace(/hello/g, 'hi');

    /g a livello mondiale

    OriginaleL’autore Reza Fahmi

  27. 6

    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 di chiamare le funzioni di simile a questo:

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

    Semplicemente copia e incolla questo codice nel tuo browser console di TEST.

    OriginaleL’autore Sandeep Gantait

  28. 5

    Io uso p per memorizzare il risultato di un precedente ricorsione sostituzione:

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

    Andrà a sostituire tutte le occorrenze della stringa s fino a quando è possibile:

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

    Per evitare loop infinito verificare se la sostituzione r contiene una partita m:

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

    OriginaleL’autore Termininja

Lascia un commento