Wie ersetze ich alle Vorkommen eines Strings?

Ich habe diese Zeichenfolge:

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

Tun:

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

scheint nur das erste Vorkommen von abcin der obigen Zeichenfolge zu entfernen .

Wie kann ich alle Vorkommen ersetzen ?

Hinweis: Verwenden Sie dies nicht in leistungskritischem Code.

Als Alternative zu regulären Ausdrücken für eine einfache Literalzeichenfolge können Sie verwenden

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

Das allgemeine Muster ist

str.split(search).join(replacement)

Dies war in einigen Fällen schneller als die Verwendung replaceAllund ein regulärer Ausdruck, aber dies scheint in modernen Browsern nicht mehr der Fall zu sein.

Benchmark: https://jsperf.com/replace-all-vs-split-join

Schlussfolgerung: Wenn Sie einen leistungskritischen Anwendungsfall haben (z. B. die Verarbeitung von Hunderten von Zeichenfolgen), verwenden Sie die Regexp-Methode. Für die meisten typischen Anwendungsfälle lohnt es sich jedoch, sich keine Gedanken über Sonderzeichen machen zu müssen.

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

Als Antwort auf den Kommentar:

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

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

Als Antwort auf den Kommentar von Click Upvote können Sie ihn noch weiter vereinfachen:

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

Hinweis: Reguläre Ausdrücke enthalten Sonderzeichen (Metazeichen). Daher ist es gefährlich, ein Argument in der findobigen Funktion blind zu übergeben, ohne es vorzuverarbeiten, um diesen Zeichen zu entkommen. Diese in dem abgedeckt ist Mozilla Developer Network ‚s JavaScript - Leitfaden für Reguläre Ausdrücke , in denen sie die folgende Nutzenfunktion darstellen (die zumindest verändert hat zweimal da diese Antwort wurde ursprünglich geschrieben, so stellen Sie sicher , dass die MDN Website für potenzielles Updates suchen):

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

Um die replaceAll()oben genannte Funktion sicherer zu machen , kann sie wie folgt geändert werden, wenn Sie auch Folgendes angeben escapeRegExp:

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

Der Vollständigkeit halber habe ich mir überlegt, mit welcher Methode ich das machen soll. Grundsätzlich gibt es zwei Möglichkeiten, dies zu tun, wie in den anderen Antworten auf dieser Seite vorgeschlagen.

Hinweis: Im Allgemeinen wird das Erweitern der in JavaScript integrierten Prototypen nicht empfohlen. Ich stelle den String-Prototyp lediglich zur Veranschaulichung als Erweiterung zur Verfügung und zeige verschiedene Implementierungen einer hypothetischen Standardmethode für den Stringeingebauten Prototyp.

Implementierung auf Basis regulärer Ausdrücke

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

Split and Join (funktionale) Implementierung

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

Da ich nicht zu viel darüber wusste, wie reguläre Ausdrücke hinter den Kulissen in Bezug auf Effizienz funktionieren, neigte ich dazu, mich in der Vergangenheit der Aufteilung zuzuwenden und mich der Implementierung anzuschließen, ohne über die Leistung nachzudenken. Als ich mich fragte, was effizienter war und mit welchem ​​Abstand, benutzte ich es als Ausrede, um es herauszufinden.

Auf meinem Chrome Windows 8-Computer ist die auf regulären Ausdrücken basierende Implementierung die schnellste , wobei die Split- und Join-Implementierung 53% langsamer ist . Das heißt, die regulären Ausdrücke sind für die von mir verwendete Lorem-Ipsum-Eingabe doppelt so schnell.

Schauen Sie sich diesen Benchmark an , in dem diese beiden Implementierungen gegeneinander ausgeführt werden.

Wie im folgenden Kommentar von @ThomasLeduc und anderen erwähnt, kann es zu Problemen bei der Implementierung auf der Basis regulärer Ausdrücke kommen, wenn searchbestimmte Zeichen enthalten sind, die in regulären Ausdrücken als Sonderzeichen reserviert sind . Bei der Implementierung wird davon ausgegangen, dass der Aufrufer die Zeichenfolge zuvor verlässt oder nur Zeichenfolgen übergibt, die in Regular Expressions (MDN) keine Zeichen in der Tabelle enthalten .

MDN bietet auch eine Implementierung, um unseren Zeichenfolgen zu entkommen. Es wäre schön, wenn dies auch standardisiert wäre RegExp.escape(str), aber leider existiert es nicht:

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

Wir könnten escapeRegExpinnerhalb unserer String.prototype.replaceAllImplementierung aufrufen , ich bin mir jedoch nicht sicher, wie stark sich dies auf die Leistung auswirkt (möglicherweise sogar für Zeichenfolgen, für die das Escape nicht benötigt wird, wie bei allen alphanumerischen Zeichenfolgen).

Die Verwendung eines regulären Ausdrucks mit ggesetztem Flag ersetzt alle:

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

Siehe auch hier

Hier ist eine String-Prototyp-Funktion, die auf der akzeptierten Antwort basiert:

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

BEARBEITEN

Wenn Ihr findTestament Sonderzeichen enthält, müssen Sie ihnen entkommen:

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

Geige: http://jsfiddle.net/cdbzL/

Aktualisieren:

Es ist etwas spät für ein Update, aber da ich gerade über diese Frage gestolpert bin und festgestellt habe, dass meine vorherige Antwort nicht die ist, mit der ich zufrieden bin. Da die Frage das Ersetzen eines einzelnen Wortes betraf, ist es unglaublich, dass niemand daran gedacht hat, Wortgrenzen zu verwenden ( \b)

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

Dies ist eine einfache Regex, die in den meisten Fällen das Ersetzen von Wortteilen vermeidet. Ein Bindestrich -wird jedoch immer noch als Wortgrenze betrachtet. In diesem Fall können also Bedingungen verwendet werden, um das Ersetzen von Zeichenfolgen wie den cool-catfolgenden zu vermeiden :

'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"

Im Grunde ist diese Frage dieselbe wie die Frage hier: Javascript ersetzt "'" durch "' '"

@ Mike, überprüfen Sie die Antwort, die ich dort gegeben habe ... Regexp ist nicht die einzige Möglichkeit, mehrere Vorkommen eines Abonnements zu ersetzen, weit davon entfernt. Denken Sie flexibel, denken Sie gespalten!

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

Alternativ, um zu verhindern, dass Wortteile ersetzt werden - was auch für die genehmigte Antwort der Fall ist! Sie können dieses Problem mit regulären Ausdrücken umgehen, die zugegebenermaßen etwas komplexer und als Ergebnis auch etwas langsamer sind:

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

Die Ausgabe entspricht der akzeptierten Antwort, verwendet jedoch den Ausdruck / cat / g für diese Zeichenfolge:

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" ?? 

Hoppla, das ist wahrscheinlich nicht das, was du willst. Was ist dann? IMHO, eine Regex, die "Katze" nur bedingt ersetzt. (dh nicht Teil eines Wortes), wie so:

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"

Ich vermute, das entspricht Ihren Bedürfnissen. Es ist natürlich nicht vollständig sicher, aber es sollte ausreichen, um Ihnen den Einstieg zu erleichtern. Ich würde empfehlen, auf diesen Seiten mehr zu lesen. Dies wird sich als nützlich erweisen, um diesen Ausdruck so zu perfektionieren, dass er Ihren spezifischen Anforderungen entspricht.

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

http://www.regular-expressions.info

Letzte Ergänzung:

Angesichts der Tatsache, dass diese Frage immer noch viele Ansichten enthält, dachte ich, ich könnte ein Beispiel für die .replaceVerwendung mit einer Rückruffunktion hinzufügen . In diesem Fall vereinfacht dramatisch die Expression und bietet noch mehr Flexibilität, wie mit dem richtigen Kapitalisierung zu ersetzen oder beide ersetzen catund catsin einem Rutsch:

'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

Übereinstimmung mit einem globalen regulären Ausdruck:

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

Zum Ersetzen einer einmaligen Verwendung:

var res = str.replace('abc', "");

Zum mehrfachen Ersetzen verwenden Sie:

var res = str.replace(/abc/g, "");

Dies sind die gebräuchlichsten und lesbarsten Methoden.

var str = "Test abc test test abc test test test abc test test abc"

Methode 1:

str = str.replace(/abc/g, "replaced text");

Methode 2:

str = str.split("abc").join("replaced text");

Methode 3:

str = str.replace(new RegExp("abc", "g"), "replaced text");

Methode 4:

while(str.includes("abc")){
    str = str.replace("abc", "replaced text");
}

Ausgabe:

console.log(str);
// Test replaced text test test replaced text test test test replaced text test test replaced text

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

Oder probieren Sie die Funktion replaceAll von hier aus:

Was sind nützliche JavaScript-Methoden, die integrierte Objekte erweitern?

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

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

EDIT: Klarstellung über ErsetzenAlle Verfügbarkeit

Die Methode 'replaceAll' wird dem Prototyp von String hinzugefügt. Dies bedeutet, dass es für alle Zeichenfolgenobjekte / Literale verfügbar ist.

Z.B

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

Die Verwendung RegExpin JavaScript könnte den Job für Sie erledigen. Machen Sie einfach etwas wie den folgenden Code. Vergessen Sie nicht, /gworaufhin sich Global auszeichnet :

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

Wenn Sie an eine Wiederverwendung denken, erstellen Sie eine Funktion, die dies für Sie erledigt. Dies wird jedoch nicht empfohlen, da es sich nur um eine einzeilige Funktion handelt. Wenn Sie diese Funktion jedoch häufig verwenden, können Sie Folgendes schreiben:

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

und verwenden Sie es einfach immer und immer wieder in Ihrem Code wie unten:

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

Wie ich bereits erwähnt habe, macht dies keinen großen Unterschied in Bezug auf die zu schreibenden Zeilen oder die Leistung. Nur das Zwischenspeichern der Funktion kann zu einer schnelleren Leistung bei langen Zeichenfolgen und auch zu einer bewährten Methode für DRY-Code führen, wenn Sie sie wiederverwenden möchten.

Angenommen, Sie möchten alle 'abc' durch 'x' ersetzen:

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

Ich habe versucht, über etwas Einfacheres nachzudenken, als den String-Prototyp zu modifizieren.

Verwenden Sie einen regulären Ausdruck:

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

Einfache Anführungszeichen ersetzen:

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

    return text;
}

// Schleife, bis die Anzahl auf 0 kommt. ODER einfach kopieren / einfügen

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

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

funktionierte besser für mich als die obigen Antworten. So new RegExp("abc", 'g')wird ein RegExp erstellt, das mit allen Vorkommen ( 'g'Flag) des Textes ( "abc") übereinstimmt . Der zweite Teil wird ersetzt, in Ihrem Fall leere Zeichenfolge ( ""). strist die Zeichenfolge, und wir müssen sie überschreiben, da sie replace(...)nur das Ergebnis zurückgibt, aber nicht überschreibt. In einigen Fällen möchten Sie das möglicherweise verwenden.

Dies ist die schnellste Version, die keine regulären Ausdrücke verwendet .

Überarbeitetes jsperf

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

Es ist fast doppelt so schnell wie die Split-and-Join-Methode.

Wie in einem Kommentar hier ausgeführt, funktioniert dies nicht, wenn Ihre omitVariable placewie in: enthält replaceAll("string", "s", "ss"), da sie immer ein anderes Vorkommen des Wortes ersetzen kann.

Es gibt einen anderen jsperf mit Varianten meines rekursiven Ersatzes, die noch schneller gehen ( http://jsperf.com/replace-all-vs-split-join/12 )!

• Update 27. Juli 2017: Es sieht so aus, als ob RegExp jetzt die schnellste Leistung im kürzlich veröffentlichten Chrome 59 hat.

Performance

Heute 27.12.2019 führe ich Tests unter macOS v10.13.6 (High Sierra) für die ausgewählten Lösungen durch.

Schlussfolgerungen

• Das str.replace(/abc/g, '');( C ) ist eine gute browserübergreifende schnelle Lösung für alle Zeichenfolgen.
• Lösungen basierend auf split-join( A, B ) oder replace( C, D ) sind schnell
• Lösungen, die auf while( E, F, G, H ) basieren , sind langsam - normalerweise ~ 4-mal langsamer für kleine Saiten und ungefähr ~ 3000-mal (!) Langsamer für lange Saiten
• Die Wiederholungslösungen ( RA, RB ) sind langsam und funktionieren nicht für lange Zeichenfolgen

Ich erstelle auch meine eigene Lösung. Es sieht so aus, als ob es derzeit das kürzeste ist, das die Frage beantwortet:

str.split`abc`.join``

str = "Test abc test test abc test test test abc test test abc";
str = str.split`abc`.join``

console.log(str);

Einzelheiten

Die Tests wurden mit Chrome 79.0, Safari 13.0.4 und Firefox 71.0 (64 Bit) durchgeführt. Die Tests RAund RBverwenden Rekursion. Ergebnisse

Kurze Zeichenfolge - 55 Zeichen

Sie können HIER Tests auf Ihrem Computer durchführen . Ergebnisse für Chrome:

Lange Zeichenfolge: 275 000 Zeichen

Die rekursiven Lösungen RA und RB ergeben

RangeError: Maximale Aufrufstapelgröße überschritten

Für 1 Million Zeichen brechen sie sogar Chrome

Ich versuche, Tests für 1 Million Zeichen für andere Lösungen durchzuführen, aber E, F, G, H benötigen so viel Zeit, dass der Browser mich auffordert, das Skript zu unterbrechen, sodass ich die Testzeichenfolge auf 275 KB Zeichen verkleinere. Sie können HIER Tests auf Ihrem Computer durchführen . Ergebnisse für Chrome

In Tests verwendeter Code

var t="Test abc test test abc test test test abc test test abc"; // .repeat(5000)
var log = (version,result) => console.log(`${version}: ${result}`);


function A(str) {
  return str.split('abc').join('');
}

function B(str) {
  return str.split`abc`.join``; // my proposition
}


function C(str) {
  return str.replace(/abc/g, '');
}

function D(str) {
  return str.replace(new RegExp("abc", "g"), '');
}

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

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

function G(str) {
  while(str.includes("abc")) { str = str.replace('abc', ''); }
  return str;
}

// src: https://stackoverflow.com/a/56989553/860099
function H(str)
{
    let i = -1
    let find = 'abc';
    let newToken = '';

    if (!str)
    {
        if ((str == null) && (find == null)) return newToken;
        return str;
    }

    while ((
        i = str.indexOf(
            find, i >= 0 ? i + newToken.length : 0
        )) !== -1
    )
    {
        str = str.substring(0, i) +
            newToken +
            str.substring(i + find.length);
    }
    return str;
}

// src: https://stackoverflow.com/a/22870785/860099
function RA(string, prevstring) {
  var omit = 'abc';
  var place = '';
  if (prevstring && string === prevstring)
    return string;
  prevstring = string.replace(omit, place);
  return RA(prevstring, string)
}

// src: https://stackoverflow.com/a/26107132/860099
function RB(str) {
  var find = 'abc';
  var 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) + RB(st2, find, replace);
    }
  }
  return str;
}




log('A ', A(t));
log('B ', B(t));
log('C ', C(t));
log('D ', D(t));
log('E ', E(t));
log('F ', F(t));
log('G ', G(t));
log('H ', H(t));
log('RA', RA(t)); // use reccurence
log('RB', RB(t)); // use reccurence

<p style="color:red">This snippet only presents codes used in tests. It not perform test itself!<p>

Wenn sich das, was Sie suchen möchten, bereits in einer Zeichenfolge befindet und Sie keinen Regex-Escaper zur Hand haben, können Sie join / split verwenden:

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

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

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

Ich mag diese Methode (sie sieht etwas sauberer aus):

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

Der einfachste Weg, dies ohne Verwendung von Regex zu tun, ist das Teilen und Verbinden wie im folgenden Code:

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

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

http://jsfiddle.net/ANHR9/

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

Wenn die Zeichenfolge ein ähnliches Muster enthält abccc, können Sie Folgendes verwenden:

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

Die vorherigen Antworten sind viel zu kompliziert. Verwenden Sie einfach die Ersetzungsfunktion wie folgt:

str.replace(/your_regex_pattern/g, replacement_string);

Beispiel:

var str = "Test abc test test abc test test test abc test test abc";

var res = str.replace(/[abc]+/g, "");

console.log(res);

Wenn Sie sicherstellen möchten, dass die gesuchte Zeichenfolge auch nach dem Ersetzen nicht vorhanden ist, müssen Sie eine Schleife verwenden.

Zum Beispiel:

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

Wenn Sie fertig sind, haben Sie immer noch 'test abc'!

Die einfachste Schleife, um dies zu lösen, wäre:

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

Damit wird der Austausch jedoch für jeden Zyklus zweimal ausgeführt. Vielleicht (mit der Gefahr einer Ablehnung) kann dies zu einer etwas effizienteren, aber weniger lesbaren Form kombiniert werden:

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

Dies kann besonders nützlich sein, wenn Sie nach doppelten Zeichenfolgen suchen.
Zum Beispiel, wenn wir 'a ,,, b' haben und alle doppelten Kommas entfernen möchten.
[In diesem Fall könnte man .replace (/, + / g, ',') ausführen, aber irgendwann wird der reguläre Ausdruck komplex und langsam genug, um stattdessen eine Schleife zu erstellen.]

Obwohl die Leute die Verwendung von Regex erwähnt haben, gibt es einen besseren Ansatz, wenn Sie den Text unabhängig vom Fall des Textes ersetzen möchten. Wie Groß- oder Kleinbuchstaben. Verwenden Sie die folgende Syntax

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

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

Das ausführliche Beispiel finden Sie hier .

Sie können einfach die folgende Methode verwenden

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

Einfach hinzufügen /g

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

zu

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

/g bedeutet global