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

Die beste Lösung, um ein beliebiges Zeichen zu ersetzen, ist die Verwendung der indexOf() , includes() und substring() Funktionen, um die übereinstimmende Zeichenfolge durch die angegebene Zeichenfolge in der aktuellen Zeichenfolge zu ersetzen.

• El String.indexOf() Funktion ist die Suche nach dem n th Indexposition übereinstimmen.
• El String.includes() bestimmt, ob eine Zeichenkette innerhalb einer anderen Zeichenkette gefunden werden kann, und gibt je nach Fall true oder false zurück.
• String.substring() Funktion ist es, die Teile von String( preceding , exceding ). Fügen Sie die Ersetzungszeichenfolge zwischen diesen Teilen ein, um die endgültige Rückgabezeichenfolge zu erzeugen.

Die folgende Funktion erlaubt die Verwendung beliebiger Zeichen.
wobei als RegExp erlaubt keine Sonderzeichen wie ** und einige Zeichen müssen escaped werden, wie $ .

String.prototype.replaceAllMatches = function(obj) { // Obj format: { 'matchkey' : 'replaceStr' }
    var retStr = this;
    for (var x in obj) {
        //var matchArray = retStr.match(new RegExp(x, 'ig'));
        //for (var i = 0; i < matchArray.length; i++) {
        var prevIndex = retStr.indexOf(x); // matchkey = '*', replaceStr = '$*' While loop never ends.
        while (retStr.includes(x)) {
            retStr = retStr.replaceMatch(x, obj[x], 0);
            var replaceIndex = retStr.indexOf(x);
            if( replaceIndex <  prevIndex + (obj[x]).length) {
                break;
            } else {
                prevIndex = replaceIndex;
            }
        }
    }
    return retStr;
};
String.prototype.replaceMatch = function(matchkey, replaceStr, matchIndex) {
    var retStr = this, repeatedIndex = 0;
    //var matchArray = retStr.match(new RegExp(matchkey, 'ig'));
    //for (var x = 0; x < matchArray.length; x++) {
    for (var x = 0; (matchkey != null) && (retStr.indexOf(matchkey) > -1); x++) {
        if (repeatedIndex == 0 && x == 0) {
            repeatedIndex = retStr.indexOf(matchkey);
        } else { // matchIndex > 0
            repeatedIndex = retStr.indexOf(matchkey, repeatedIndex + 1);
        }
        if (x == matchIndex) {
            retStr = retStr.substring(0, repeatedIndex) + replaceStr + retStr.substring(repeatedIndex + (matchkey.length));
            matchkey = null; // To break the loop.
        }
    }
    return retStr;
};

---

Wir können auch das Objekt "Regulärer Ausdruck" verwenden, um Text mit einem Muster abzugleichen. Im Folgenden sind Funktionen aufgeführt, die das Objekt "Regulärer Ausdruck" verwenden.

Sie erhalten einen SyntaxError, wenn Sie eine ungültig Muster für reguläre Ausdrücke wie '**' .

• El String.replace() wird verwendet, um die angegebene Zeichenkette durch die angegebene Zeichenkette zu ersetzen.
• El String.match() Funktion ist es, herauszufinden, wie oft die Zeichenkette wiederholt wird.

• El RegExp.prototype.test Methode führt eine Suche nach einer Übereinstimmung zwischen einem regulären Ausdruck und einer angegebenen Zeichenkette durch. Gibt true oder false zurück.

  String.prototype.replaceAllRegexMatches = function(obj) { // Obj format: { 'matchkey' : 'replaceStr' } var retStr = this; for (var x in obj) { retStr = retStr.replace(new RegExp(x, 'ig'), obj[x]); } return retStr; };

Beachten Sie, dass reguläre Ausdrücke ohne Anführungszeichen geschrieben werden.

---

Beispiele für die Verwendung der oben genannten Funktionen:

var str = "yash yas $dfdas.**";
console.log('String: ', str);

// No need to escape any special character
console.log('Index matched replace: ', str.replaceMatch('as', '*', 2));
console.log('Index Matched replace: ', str.replaceMatch('y', '~', 1));
console.log('All Matched replace: ', str.replaceAllMatches({'as': '**', 'y':'Y', '$':'-'}));
console.log('All Matched replace : ', str.replaceAllMatches({'**': '~~', '$':'&$&', '&':'%', '~':'>'}));

// You need to escape some special Characters
console.log('REGEX all matched replace: ', str.replaceAllRegexMatches({'as' : '**', 'y':'Y', '\\$':'-'}));

Ergebnis:

String:  yash yas $dfdas.**
Index Matched replace:  yash yas $dfd*.**
Index Matched replace:  yash ~as $dfdas.**

All Matched replace:  Y**h Y** -dfd**.**
All Matched replace:  yash yas %$%dfdas.>>

REGEX All Matched replace:  Y**h Y** -dfd**.**

---

Answer 2

Sie können es auch ohne Regex machen, aber Sie müssen vorsichtig sein, wenn der Ersatztext den Suchtext enthält.

z.B..

replaceAll("nihIaohi", "hI", "hIcIaO", true)

Hier ist also eine richtige Variante von replaceAll, einschließlich string-prototype:

function replaceAll(str, find, newToken, ignoreCase)
{
    let i = -1;

    if (!str)
    {
        // Instead of throwing, act as COALESCE if find == null/empty and str == null
        if ((str == null) && (find == null))
            return newToken;

        return str;
    }

    if (!find) // sanity check 
        return str;

    ignoreCase = ignoreCase || false;
    find = ignoreCase ? find.toLowerCase() : find;

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

    return str;
}

Oder, wenn Sie eine String-Prototyp-Funktion haben wollen:

String.prototype.replaceAll = function (find, replace) {
    let str = this;

    let i = -1;

    if (!str)
    {
        // Instead of throwing, act as COALESCE if find == null/empty and str == null
        if ((str == null) && (find == null))
            return newToken;

        return str;
    }

    if (!find) // sanity check 
        return str;

    ignoreCase = ignoreCase || false;
    find = ignoreCase ? find.toLowerCase() : find;

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

    return str;
};

Answer 3

 var myName = 'r//i//n//o//l////d';
  var myValidName = myName.replace(new RegExp('\//', 'g'), ''); > // rinold
  console.log(myValidName);

var myPetName = 'manidog';
var renameManiToJack = myPetName.replace(new RegExp('mani', 'g'), 'jack'); > // jackdog

Answer 4

Das sollte funktionieren.

String.prototype.replaceAll = function (search, replacement) {
    var str1 = this.replace(search, replacement);
    var str2 = this;
    while(str1 != str2) {
        str2 = str1;
        str1 = str1.replace(search, replacement);
    }
    return str1;
}

Beispiel:

Console.log("Steve is the best character in Minecraft".replaceAll("Steve", "Alex"));

Answer 5

Ich möchte nur meine Lösung mitteilen, die auf einigen der funktionalen Merkmale der letzten Versionen von JavaScript basiert:

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

   var result = str.split(' ').reduce((a, b) => {
      return b == 'abc' ? a : a + ' ' + b;   })

  console.warn(result)