regex string - Wie ersetze ich alle Vorkommen einer Zeichenfolge in JavaScript?




replace ersetzen (25)

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 abc in der obigen Zeichenfolge zu entfernen. Wie kann ich alle Vorkommnisse ersetzen?


Answers

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

http://jsfiddle.net/ANHR9/


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

Das führt den Austausch jedoch zweimal für jeden Zyklus durch. Vielleicht (in Gefahr, abgelehnt zu werden), kann dies für eine etwas effizientere, aber weniger lesbare 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 Zeichenketten suchen.
Wenn wir zum Beispiel 'a ,,, b' haben und alle doppelten Kommas entfernen möchten.
[In diesem Fall könnte man .replace tun (/, + / g, ','), aber irgendwann wird der Regex komplex und langsam genug, um ihn zu wiederholen.]


Anführungszeichen ersetzen:

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

    return text;
}

Ich mag diese Methode (sie sieht ein wenig sauberer aus):

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

Der Vollständigkeit halber habe ich überlegt, mit welcher Methode ich dies tun sollte. Es gibt grundsätzlich zwei Möglichkeiten, dies zu tun, wie in den anderen Antworten auf dieser Seite vorgeschlagen.

Hinweis: Im Allgemeinen wird die Erweiterung der integrierten Prototypen in JavaScript im Allgemeinen nicht empfohlen. Ich biete Erweiterungen für den String-Prototyp an, um nur die Darstellung zu erleichtern und verschiedene Implementierungen einer hypothetischen Standardmethode für den eingebauten String -Prototyp zu zeigen.

Implementierung auf Basis von regulären Ausdrücken

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

Split- und Join-Implementierung (funktional)

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

Da ich nicht so viel darüber wusste, wie reguläre Ausdrücke im Hinblick auf die Effizienz hinter den Kulissen funktionieren, neigte ich dazu, mich auf die Spaltung zu stützen und an der Implementierung zu arbeiten, ohne an Leistung zu denken. 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 Implementierung mit regulären Ausdrücken am schnellsten . Die Implementierung von Split- und Join-Operationen ist um 53% langsamer . Die regulären Ausdrücke sind also doppelt so schnell für die Eingabe von Lorem ipsum, die ich verwendet habe.

Schauen Sie sich diesen benchmark wenn diese beiden Implementierungen gegeneinander ausgeführt werden.

Wie im folgenden Kommentar von @ThomasLeduc und anderen erwähnt, kann es bei der Implementierung von auf regulären Ausdrücken basierenden Implementierungen zu Problemen kommen, wenn die search bestimmte Zeichen enthält, die in regulären Ausdrücken als Sonderzeichen reserviert sind. Bei der Implementierung wird davon ausgegangen, dass der Aufrufer die Zeichenfolge zuvor mit Escapezeichen überschreibt oder nur Zeichenfolgen überträgt, die keine Zeichen in der Tabelle in regulären Ausdrücken (MDN) enthalten.

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

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

escapeRegExp unserer Implementierung von escapeRegExp können wir String.prototype.replaceAll . Ich bin mir jedoch nicht sicher, wie stark sich dies auf die Leistung auswirkt (möglicherweise sogar für Zeichenfolgen, für die keine String.prototype.replaceAll erforderlich sind, wie bei allen alphanumerischen Zeichenfolgen).


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 über etwas einfacher nachgedacht, als den String-Prototyp zu modifizieren.


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

funktionierte für mich besser als die obigen Antworten. new RegExp("abc", 'g') erzeugt ein new RegExp("abc", 'g') ein RegExp, das allen Vorkommen ( 'g' Flag) des Texts ( "abc" ) entspricht. Der zweite Teil ist, was ersetzt wird, in Ihrem Fall leere Zeichenfolge ( "" ). str ist die Zeichenfolge, und wir müssen sie überschreiben, da replace(...) nur das Ergebnis liefert, aber keine Überschreibungen. In einigen Fällen möchten Sie dies vielleicht verwenden.


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

Wenn die Zeichenfolge ein ähnliches Muster wie abccc , können Sie abccc verwenden:

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

Die Verwendung eines regulären Ausdrucks mit dem g Flag wird alle ersetzen:

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


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 eine ist, bin ich glücklich mit. 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 verhindert. Ein Bindestrich - wird jedoch immer noch als Wortgrenze betrachtet. In diesem Fall können Bedingungen verwendet werden, um zu vermeiden, dass Zeichenfolgen wie 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"

Im Grunde ist diese Frage die gleiche wie die Frage hier: Javascript ersetzt "" mit "".

@Mike, überprüfe die Antwort, die ich dort gegeben habe ... regexp ist nicht die einzige Möglichkeit, mehrere Vorkommen eines Abonnements zu ersetzen, weit davon entfernt. Flexibel denken, Split denken!

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

Alternativ, um zu verhindern, dass Wortteile ersetzt werden - was auch die genehmigte Antwort tut! Sie können dieses Problem umgehen, indem Sie reguläre Ausdrücke verwenden, die, wie ich gestatte, etwas komplexer und als Ergebnis 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 diesen String:

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

Ups, das ist wahrscheinlich nicht das, was Sie wollen. Was ist dann? IMHO, ein Regex, der "Katze" nur bedingt ersetzt. (dh nicht Teil eines Wortes), wie folgt:

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 den Einstieg zu erleichtern. Ich würde empfehlen, mehr auf diesen Seiten zu lesen. Dies wird sich als nützlich erweisen, um diesen Ausdruck zu perfektionieren, um Ihre spezifischen Anforderungen zu erfüllen.

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

http://www.regular-expressions.info

Endgültige Ergänzung:

Angesichts der Tatsache, dass diese Frage immer noch viele Ansichten hat, dachte ich, ich könnte ein Beispiel für .replace das mit einer Rückruffunktion verwendet wird. In diesem Fall vereinfacht es den Ausdruck erheblich und bietet noch mehr Flexibilität, z. B. durch korrekte Großschreibung oder durch gleichzeitiges Ersetzen von cat und cats :

'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

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

Überarbeitete 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- und Join-Methode.

Wie in einem Kommentar hier erwähnt, funktioniert dies nicht, wenn Ihre replaceAll("string", "s", "ss") place enthält, wie in: replaceAll("string", "s", "ss") , da sie ein anderes Vorkommen des Wortes immer ersetzen kann .

Es gibt eine weitere Jsperf mit Varianten auf meinem rekursiven Replacement, die noch schneller gehen ( http://jsperf.com/replace-all-vs-split-join/12 )!

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

Die Leute haben zwar die Verwendung von Regex erwähnt, aber es gibt einen besseren Ansatz, wenn Sie den Text unabhängig vom Textfall ersetzen möchten. Wie Groß- oder Kleinschreibung. Verwenden Sie die folgende Syntax

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

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

Das detaillierte Beispiel können Sie here verweisen.


Folgen Sie einfach diesem Oneliner-Regex und fügen Sie die Groß- / Kleinschreibung hinzu. Wenn Sie also "ABC" verwenden, verhält es sich genauso wie bei "abc".

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

Folgende Funktion funktioniert für mich:

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

Rufen Sie nun die Funktionen wie folgt auf:

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

Kopieren Sie diesen Code einfach in Ihre Browserkonsole und fügen Sie ihn in TEST ein.


Addiere einfach /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


Verwenden Sie einen regulären Ausdruck:

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

Hinweis: Verwenden Sie dies nicht in echtem Code.

Als Alternative zu regulären Ausdrücken für einen einfachen Literal-String könnten Sie verwenden

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

Das allgemeine Muster ist

str.split(search).join(replacement)

In einigen Fällen war dies früher schneller als die Verwendung von replaceAll und eines regulären Ausdrucks. Dies scheint jedoch bei modernen Browsern nicht mehr der Fall zu sein. Daher sollte dies nur als ein schneller Hack verwendet werden, um zu vermeiden, dass der reguläre Ausdruck nicht in echtem Code fluchtet.


Übereinstimmung mit einem globalen regulären Ausdruck:

anotherString = someString.replace(/cat/g, '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 verwende p , um das Ergebnis des vorherigen Rekursionsersatzes zu speichern:

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

Es wird alle Vorkommen in der Zeichenkette s ersetzen, bis dies möglich ist:

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

Um eine Endlosschleife zu vermeiden, überprüfe ich, ob der Ersatz r eine Übereinstimmung m enthält:

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

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 find Sonderzeichen enthält, müssen Sie diese entziehen:

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

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


Wenn das, was Sie suchen, bereits in einer Zeichenfolge enthalten ist 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'));


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

Oder probieren Sie die replaceAll-Funktion 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, '');

BEARBEITEN : Erläuterung der Verfügbarkeit von replaceAll

Die 'replaceAll'-Methode wird dem String von String hinzugefügt. Dies bedeutet, dass es für alle String-Objekte / 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'

Ein Abschluss ist, wenn eine innere Funktion in ihrer äußeren Funktion auf Variablen zugreifen kann. Dies ist wahrscheinlich die einfachste einzeilige Erklärung, die Sie für Schließungen erhalten können.







javascript regex string replace