multiple - javascript zeichen ersetzen




Wie ersetze ich alle Vorkommen einer Zeichenfolge in JavaScript? (20)

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?

https://code.i-harness.com


Übereinstimmung mit einem globalen regulären Ausdruck:

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

// Schleife, bis Anzahl Vorkommen 0 ist. ODER einfach kopieren / einfügen

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

Anführungszeichen ersetzen:

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

    return text;
}

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.


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.


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


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.

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, "");

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/


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

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

Sie können die Methode unten einfach 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);
};

Sie können versuchen, diese beiden leistungsstarken Methoden zu kombinieren.

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

Ich hoffe es hilft!


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.]


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


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

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.


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

http://jsfiddle.net/ANHR9/


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(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 str ="Test abc test test abc test test test abc test test abc";
str = str.replaceAll('abc', '');




replace