Ersetzen aller Vorkommen einer Zeichenkette in JavaScript

Question

Ich habe diese Zeichenfolge in meinem JavaScript-Code:

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

Wie kann ich die alle Vorkommnisse davon?

Answer 1

Verwendung von RegExp en JavaScript könnte die Arbeit für Sie erledigen, machen Sie einfach etwas wie den folgenden Code, vergessen Sie nicht die /g und danach für weltweit :

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

Wenn Sie an Wiederverwendung denken, können Sie eine Funktion erstellen, die das für Sie erledigt, aber es wird nicht empfohlen, da es sich nur um eine einzeilige Funktion handelt, aber auch hier können Sie so etwas schreiben, wenn Sie dies intensiv nutzen:

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

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

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

Aber wie ich bereits erwähnt, wird es nicht einen großen Unterschied in Bezug auf die Zeilen geschrieben werden oder Leistung, nur Zwischenspeichern der Funktion kann einige schnellere Leistung auf lange Zeichenfolgen und auch eine gute Praxis der DRY-Code, wenn Sie wiederverwenden möchten.

Answer 2

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, an etwas Einfacheres zu denken, als den String-Prototyp zu ändern.

Answer 3

Verwenden Sie einen regulären Ausdruck:

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

Answer 4

Leistung

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

Schlussfolgerungen

• El str.replace(/abc/g, ''); ( C ) ist eine gute und schnelle browserübergreifende Lösung für alle Zeichenketten.
• Lösungen auf der Grundlage von split-join ( A,B ) oder replace ( C,D ) sind schnell
• Lösungen auf der Grundlage von while ( E,F,G,H ) sind langsam - in der Regel ~4 mal langsamer für kleine Zeichenketten und etwa ~3000 mal (!) langsamer für lange Zeichenketten
• Die Rekursionslösungen ( RA,RB ) sind langsam und funktionieren nicht für lange Strings

Ich schaffe auch meine eigene Lösung. Es sieht so aus, als ob es derzeit die kürzeste Lösung ist, die die Aufgabe der Frage erfüllt:

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 RA y RB Rekursion verwenden. Ergebnisse

Kurze Zeichenfolge - 55 Zeichen

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

Lange Zeichenfolge: 275 000 Zeichen

Die rekursiven Lösungen RA y RB gibt

BereichFehler: Maximale Größe des Aufrufstapels überschritten

Für 1 Mio. Zeichen brechen sie sogar Chrome

Ich versuche, Tests für 1M Zeichen für andere Lösungen durchzuführen, aber E,F,G,H nimmt so viel Zeit, dass der Browser mich bittet, das Skript zu unterbrechen, so dass ich die Testzeichenfolge auf 275K Zeichen verkleinere. Sie können die Tests auf Ihrem Rechner durchführen HIER . 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>

Answer 5

Ersetzen von einfachen Anführungszeichen:

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

    return text;
}