So ersetzen Sie alle Vorkommen einer Zeichenfolge in JavaScript

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

Antwort auf Kommentar:

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

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

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

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

Hinweis: Reguläre Ausdrücke enthalten spezielle (Meta) Zeichen. Daher ist es gefährlich, ein Argument in der obigen find-Funktion blind zu übergeben, ohne es vorab zu verarbeiten, um diese Zeichen zu umgehen. Dies wird im Mozilla Developer Network 's JavaScript-Handbuch für reguläre Ausdrücke behandelt, in dem die folgende Dienstprogrammfunktion dargestellt wird:

function escapeRegExp(str) {
    return str.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
}

Um die replaceAll()-Funktion oben sicherer zu machen, kann sie folgendermaßen geändert werden, wenn Sie auch escapeRegExp hinzufügen:

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

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)

Dies war in manchen Fällen 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 verwendet werden muss.

Die Verwendung eines regulären Ausdrucks mit dem Flag g 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);
};

EDIT 

Wenn Ihre find Sonderzeichen enthält, müssen Sie sie mit Escapezeichen versehen:

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

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

Update:

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 dachte, Word-Grenzen 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 Word-Grenze betrachtet. In diesem Fall können Bedingungen verwendet werden, um das Ersetzen von Zeichenfolgen wie cool-cat 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 die gleiche wie die Frage hier: Javascript ersetzen "" 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 können Sie verhindern, dass Word-Teile ersetzt werden - was auch die genehmigte Antwort tut! Sie können dieses Problem umgehen, indem Sie reguläre Ausdrücke verwenden, die, wie ich gestehe, 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

Abschließende Hinzufügung:

Da diese Frage immer noch viele Ansichten hat, dachte ich, ich könnte ein Beispiel für .replace hinzufügen, das mit einer Rückruffunktion verwendet wird. In diesem Fall vereinfacht der Ausdruck und noch mehr Flexibilität. Ersetzen Sie ihn durch korrekte Großschreibung oder ersetzen Sie cat und cats gleichzeitig:

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

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

EDIT: 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'

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 Einfacheres nachgedacht als über den String-Prototyp.

Verwenden Sie einen regulären Ausdruck:

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

Anführungszeichen ersetzen:

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

    return text;
}

Dies sind die gebräuchlichsten und lesbarsten Methoden.

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

Methode-01:

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

Methode-02:

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

Methode-03:

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

Methode-04:

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

Die Verwendung von RegExp in JavaScript könnte die Aufgabe für Sie erledigen. Machen Sie einfach etwas wie das Folgende. Vergessen Sie nicht den /g - Wert, nach dem Sie für global) stehen:

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

Wenn Sie über eine Wiederverwendung nachdenken, 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 benutze es einfach in deinem Code immer und 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ähnte, macht es keinen großen Unterschied in Bezug auf die zu schreibenden Zeilen oder die Leistung. Nur das Zwischenspeichern der Funktion kann eine schnellere Leistung für lange Zeichenfolgen bewirken und es empfiehlt sich, DRY Code zu verwenden wiederverwenden wollen.

// Schleife, bis Nummer Vorkommen auf 0 kommt. OR einfach kopieren/einfügen

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

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 zweimal so schnell wie die Split- und Join-Methode.

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

Es gibt eine weitere Jsperf mit Varianten auf meinem rekursiven Replace, 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.

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

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

Wenn das, was Sie finden möchten, 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'));

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 ein bisschen sauberer aus):

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

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 wie abccc enthält, können Sie Folgendes verwenden:

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

Die vorherigen Antworten sind viel zu kompliziert. Verwenden Sie einfach die Ersetzen-Funktion 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 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 Zeichenfolgen suchen.
Zum Beispiel, wenn wir 'a , b' haben und alle doppelten Kommas entfernen möchten.
[In diesem Fall könnte man .replace (/, +/g, ',') machen, aber irgendwann wird der Regex komplex und langsam genug, um ihn zu wiederholen.

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.

Sie können auf das detaillierte Beispiel hier verweisen.

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

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

Einfach /g hinzufügen 

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

Ich habe dieses Problem durch eine einfache Codezeile gelöst.

str.replace(/Current string/g, "Replaced string");

Überprüfen Sie das Beispiel auf jsfiddle https://jsfiddle.net/pot6whnx/1/

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 im String s ersetzen, bis es 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'

Die meisten Leute tun dies wahrscheinlich, um eine URL zu kodieren. Um eine URL zu kodieren, sollten Sie nicht nur Leerzeichen berücksichtigen, sondern die gesamte Zeichenfolge ordnungsgemäß mit encodeURI konvertieren.

encodeURI("http://www.google.com/a file with spaces.html")

bekommen:

http://www.google.com/a%20file%20with%20spaces.html

In Bezug auf die Leistung in Bezug auf die Hauptantworten dies sind einige Online-Tests .

Im Folgenden finden Sie einige Leistungstests, die console.time() verwenden (sie funktionieren am besten in Ihrer eigenen Konsole. Die Zeit ist jedoch sehr kurz, um sie im Snippet zu sehen.)

console.time('split and join');
"javascript-test-find-and-replace-all".split('-').join(' ');
console.timeEnd('split and join')

console.time('regular expression');
"javascript-test-find-and-replace-all".replace(new RegExp('-', 'g'), ' ');
console.timeEnd('regular expression');

console.time('while');
let str1 = "javascript-test-find-and-replace-all";
while (str1.indexOf('-') !== -1) {
    str1 = str1.replace('-', ' ');
}
console.timeEnd('while');

Das Interessante dabei ist, dass die Ergebnisse bei mehrmaliger Ausführung immer unterschiedlich sind, auch wenn die RegExp-Lösung im Durchschnitt die schnellste und die while-Schleifenlösung die langsamste ist.

Meine Umsetzung, sehr selbsterklärend

function replaceAll(string, token, newtoken) {
    if(token!=newtoken)
    while(string.indexOf(token) > -1) {
        string = string.replace(token, newtoken);
    }
    return string;
}

Versuchen Sie diesen Code, um alle Arten von Zeichen zu ersetzen:

Suppose we have need to send " and \ in my string, then we will convert it " to \" and \ to \\

Diese Methode löst also dieses Problem.

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

var message = $('#message').val();
             message = message.replaceAll('\\', '\\\\'); /*it will replace \ to \\ */
             message = message.replaceAll('"', '\\"');   /*it will replace " to \\"*/

Ich verwendete Ajax und ich musste Parameter im JSON-Format senden. Dann sieht meine Methode so aus:

 function sendMessage(source, messageID, toProfileID, userProfileID) {

     if (validateTextBox()) {
         var message = $('#message').val();
         message = message.replaceAll('\\', '\\\\');
         message = message.replaceAll('"', '\\"');
         $.ajax({
             type: "POST",
             async: "false",
             contentType: "application/json; charset=utf-8",
             url: "services/WebService1.asmx/SendMessage",
             data: '{"source":"' + source + '","messageID":"' + messageID + '","toProfileID":"' + toProfileID + '","userProfileID":"' + userProfileID + '","message":"' + message + '"}',
             dataType: "json",
             success: function (data) {
                 loadMessageAfterSend(toProfileID, userProfileID);
                 $("#<%=PanelMessageDelete.ClientID%>").hide();
                 $("#message").val("");
                 $("#delMessageContainer").show();
                 $("#msgPanel").show();
             },
             error: function (result) {
                 alert("message sending failed");
             }
         });
     }
     else {
         alert("Please type message in message box.");
         $("#message").focus();

     }
 }

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

In meinen Apps verwende ich eine benutzerdefinierte Funktion, die für diesen Zweck die leistungsstärkste ist, und sogar die split/join-Lösung im einfacheren Fall umschließt sie in Chrome 60und Firefox 54 ( JSBEN.CH ) etwas schneller als andere Lösungen. Mein Computer führt Windows 7 64 bits aus.

Der Vorteil ist, dass diese benutzerdefinierte Funktion viele Substitutionen gleichzeitig mit Zeichenfolgen oder Zeichen verarbeiten kann, was bei manchen Anwendungen eine Abkürzung sein kann.

Wie bei einer obigen split/join-Lösung hat die Lösung unten, anders als beim regulären Ausdruck, kein Problem mit Escape-Zeichen.

  function replaceAll(s,find,repl,caseOff,byChar){
  if (arguments.length<2)  return false; 
  var destDel = ! repl;       // if destDel delete all keys from target
  var isString = !! byChar;   // if byChar, replace set of characters 
  if (typeof find !==typeof repl && ! destDel)  return false; 
  if (isString  &&  (typeof find!=="string"))   return false; 

  if (! isString &&  (typeof find==="string"))  {
    return s.split(find).join(destDel?"":repl);
  }

  if ((! isString)  &&  ( ! Array.isArray(find) ||
          ( ! Array.isArray(repl) && ! destDel)   ))  return false;

     // if destOne replace all strings/characters by just one element
  var destOne = destDel ? false : (repl.length===1);   

     // Generally source and destination should have the same size
  if (! destOne && ! destDel && find.length!==repl.length)  return false    

  var prox,sUp,findUp,i,done;   
  if (caseOff)  {    // case insensitive    
       // Working with uppercase keys and target 
    sUp = s.toUpperCase();   
    if (isString)
       findUp = find.toUpperCase()   
    else
       findUp = find.map(function(el){  return el.toUpperCase();});    

  } else  {         // case sensitive
     sUp = s;
     findUp =find.slice();  // clone array/string
  }  

  done = new Array(find.length);  // size: number of keys
  done.fill(null);              

  var pos = 0;       // initial position in target s
  var r = "";   // initial result
  var aux, winner;
  while (pos < s.length)  {       // Scanning the target
     prox  = Number.MAX_SAFE_INTEGER;
     winner = -1;  // no winner at start
     for (i=0;i<findUp.length;i++)   // find next occurence for each string
       if (done[i]!==-1) {    // key still alive
             // Never search for the Word/char or is over?
         if (done[i]===null || done[i]<pos)  { 
           aux = sUp.indexOf(findUp[i],pos);
           done[i]=aux;  // Save the next occurrence
         } else
           aux = done[i]   // restore the position of last search
         if (aux<prox && aux!==-1) {   // if next occurrence is minimum
           winner = i;     // save it  
           prox = aux;
         }  
       }  // not done

      if (winner===-1) {   // No matches forward
         r += s.slice(pos);   
         break;
      } // no winner

      // found the character or string key in the target

      i = winner;  // restore the winner
      r += s.slice(pos,prox);   // update piece before the match

            // Append the replacement in target 
      if (! destDel) r += repl[ destOne?0:i ];  
      pos = prox + ( isString?1:findUp[i].length );       // go after match

  }  // loop
  return r;  // return the resulting string
}

Die Dokumentation ist unten

           replaceAll    
 Syntax    
 ======     
      replaceAll(s,find,[ repl ,caseOff, byChar)     

 Parameters    
 ==========    

   "s" is a string target of replacement.    
   "find" can be a string or array of strings.     
   "repl" should be the same type than "find" or empty     

  if "find" is a string, it is a simple replacement for      
    all "find" occurrences in "s" by string "repl"    

  if "find" is an array, it will replaced each string in "find"    
    that occurs in "s" for corresponding string in "repl" array.
  The replace specs are independent: A replacement part cannot    
    be replaced again. 


  if "repl" is empty all "find" occurrences in "s" will be deleted.   
  if "repl" has only one character or element,    
      all occurrences in "s" will be replaced for that one.   

  "caseOff" is true if replacement is case insensitive     
       (default is FALSE)

  "byChar" is true when replacement is based on set of characters.    
  Default is false   

  if "byChar", it will be replaced in "s" all characters in "find"   
  set of characters for corresponding character in  "repl"
  set of characters   

 Return   
 ======   
  the function returns the new string after the replacement.  

Um fair zu sein, habe ich den Benchmark ohne Parametertest ausgeführt. 

Hier ist mein Test-Set mit Node.js

function l() { return console.log.apply(null, arguments); }

var k=0;
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"],["do","fa"]));  //1
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"],["do"]));  //2
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"]));  //3
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
     "aeiou","","",true));  //4
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      "aeiou","a","",true));  //5
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      "aeiou","uoiea","",true));  //6
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      "aeiou","uoi","",true));  //7
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"],["do","fa","leg"]));  //8
l(++k,replaceAll("BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER",
      ["ri","nea"],["do","fa"]));  //9
l(++k,replaceAll("BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER",
      ["ri","nea"],["do","fa"],true)); //10
return;

Und die Ergebnisse:

1 'Banane ist eine Dope-Frucht, die weit über dem Dover geerntet wurde'
2 'Banane ist eine Dope-Frucht, die vom Dover geerntet wurde'
3 'banane ist eine pe-frucht, die geerntet wird'
4 'bnn s rp frt hrvstd nr th rvr'
5 'banane als rapa fraat harvastad naar tha ravar'
6 'bununu is u ripo frait hurvostod nour tho rivor'
7 falsch
8 falsch
9 'BANANA IS EINE REIFE-FRUCHT, DIE IN DER NÄHE DES FLUSSES ERNTEN WIRD
10 'BANANA IS A Dope-Frucht, die für den Macher geerntet wurde' 

Dies kann mit Regex erreicht werden. Einige Kombinationen, die jemandem helfen könnten,

var Word = "this,\\ .is*a*test,    '.and? / only /     'a \ test?";
var stri = "This      is    a test         and only a        test";

Um alle nicht alphanumerischen Zeichen zu ersetzen,

console.log(Word.replace(/([^a-z])/g,' ').replace(/ +/g, ' ')); 
Result: [this is a test and only a test]

Um mehrere durchgehende Leerzeichen durch ein Leerzeichen zu ersetzen,

console.log(stri.replace(/  +/g,' ')); 
Result: [This is a test and only a test]

Um alle * Zeichen zu ersetzen,

console.log(Word.replace(/\*/g,'')); 
Result: [this,\ .isatest,    '.and? / only /     'a  test?]

Fragezeichen ersetzen (?)

console.log(Word.replace(/\?/g,'#')); 
Result: [this,\ .is*a*test,    '.and# / only /     'a  test#]

Um Anführungszeichen zu ersetzen,

console.log(Word.replace(/'/g,'#'));  
Result: [this,\ .is*a*test,    #.and? / only /     #a  test?]

Um alle 'Zeichen zu ersetzen,

console.log(Word.replace(/,/g,'')); 
Result: [this\ .is*a*test    '.and? / only /     'a  test?]

Um ein bestimmtes Wort zu ersetzen,

console.log(Word.replace(/test/g,'')); 
Result: [this,\ .is*a*,    '.and? / only /     'a  ?]

Um den Schrägstrich zu ersetzen,

console.log(Word.replace(/\\/g,''));  
Result: [this, .is*a*test,    '.and? / only /     'a  test?]

Um den Schrägstrich zu ersetzen,

console.log(Word.replace(/\//g,''));  
Result: [this,\ .is*a*test,    '.and?  only      'a  test?]

Um alle Leerzeichen zu ersetzen,

console.log(Word.replace(/ /g,'#'));  
Result: [this,\#.is*a*test,####'.and?#/#only#/#####'a##test?]

Punkte ersetzen,

console.log(Word.replace(/\./g,'#')); 
Result: [this,\ #is*a*test,    '#and? / only /     'a  test?]

function replaceAll(str, find, replace) {
    var $r="";
    while($r!=str){ 
        $r = str;
        str = str.replace(find, replace);
    }
    return str;
}

Hier ist der Arbeitscode mit dem Prototyp:

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

Für eindeutige ersetzbare Werte

String.prototype.replaceAll = function(search_array, replacement_array) {
  //
  var target = this;
  //
  search_array.forEach(function(substr, index) {
    if (typeof replacement_array[index] != "undefined") {
      target = target.replace(new RegExp(substr, 'g'), replacement_array[index])
    }
  });
  //
  return target;
};

//  Use:
var replacedString = "This topic commented on :year. Talking :question.".replaceAll([':year', ':question'], ['2018', 'How to replace all occurrences of a string in JavaScript']);
//
console.log(replacedString);

Methode 1

Versuchen Sie, einen regulären Ausdruck zu implementieren

"Test abc test test abc test test test abc test test abc" .replace (/\abc/g, '');

Methode 2

Split und beitreten. Mit abc aufteilen und mit leerem Raum verbinden

"Test abc test test abc test test abc test test abc" .split ("abc"). Join ("")

Wenn die Verwendung einer Bibliothek für Sie eine Option ist, erhalten Sie die Vorteile der Test- und Community-Unterstützung, die mit einer Bibliotheksfunktion verbunden ist. Zum Beispiel verfügt die Bibliothek string.js über eine replaceAll () - Funktion, die das tut, wonach Sie suchen:

// Include a reference to the string.js library and call it (for example) S.
str = S(str).replaceAll('abc', '').s;

In string erstes Element suchen und ersetzen  

var str = '[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var i = str.replace('"[','[').replace(']"',']');
console.log(i,'//first element search and replace')

In String global suchen und ersetzen  

var str = '[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var j = str.replace(/\"\[/g,'[').replace(/\]\"/g,']');
console.log(j,'//global search and replace')

Ich möchte nur meine Lösung freigeben, basierend auf einigen Funktionsfunktionen der letzten JavaScript-Versionen:

   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)

Ich benutze split and join oder diese Funktion

function replaceAll( text, busca, reemplaza ){
  while (text.toString().indexOf(busca) != -1)
      text = text.toString().replace(busca,reemplaza);
  return text;
}

Dies kann durch reguläre Ausdrücke und das Flag g gelöst werden. Dies bedeutet, dass Sie nach dem ersten Treffer nicht aufhören. Wirklich, reguläre Ausdrücke sind Lebensretter!

function replaceAll(string, pattern, replacement) {
    return string.replace(new RegExp(pattern, "g"), replacement);
}

// or if you want myString.replaceAll("abc", "");

String.prototype.replaceAll = function(pattern, replacement) {
    return this.replace(new RegExp(pattern, "g"), replacement);
};

Zum Ersetzen einer einmaligen Verwendung:

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

Zum mehrmaligen Ersetzen verwenden Sie:

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

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

Der einfachste Weg, um dies zu erreichen, ohne Regex zu verwenden, besteht darin, den Code wie folgt zu teilen und zu verbinden:

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

Einfachste Lösung -

let str = "Test abc test test abc test test test abc test test abc";

str = str.split(" ");
str = str.filter((ele, key)=> ele!=="abc")
str = str.join(" ")

Or Simply - 

str = str.split(" ").filter((ele, key) => ele != "abc").join(" ")

Wenn Sie diese Antwort überprüfen, wird sie möglicherweise hilfreich sein, und ich habe sie in meinem Projekt verwendet.

function replaceAll(searchString, replaceString, str) {
   return str.split(searchString).join(replaceString);
}
replaceAll('abc', '',"Test abc test test abc test test test abc test test abc" ); // "Test  test test  test test test  test test "

Versuche dies:

String.prototype.replaceAll = function (sfind, sreplace) {
    var str = this;

    while (str.indexOf(sfind) > -1) {
        str = str.replace(sfind, sreplace);
    }

    return str;
};

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

z.B.

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

Hier ist also eine passende Variante von replaceAll, einschließlich String-Prototyp:

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 möchten:

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

 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

Alle Antworten werden akzeptiert, Sie können dies auf viele Arten tun. Einer der Tricks, um dies zu tun, ist dies.

const str = "Test abc test test abc test test test abc test test abc";

const compare = "abc";
arrayStr = str.split(" ");
arrayStr.forEach((element, index) => {
  if (element == compare) {
    arrayStr.splice(index, 1);
  }
});
const newString = arrayStr.join(" ");
console.log(newString);

Beste Lösung: Um ein beliebiges Zeichen zu ersetzen, verwenden wir diese indexOf(), includes(), substring() - Funktionen, um matched String durch den provided String in der aktuellen Zeichenfolge zu ersetzen.

• String.indexOf() Funktion soll die n finden^th Indexposition abgleichen.
• Die String.includes() -Methode bestimmt, ob eine Zeichenfolge in einer anderen Zeichenfolge gefunden werden kann, und gibt je nach Bedarf true oder false zurück.
• String.substring() Funktion soll die Teile von String (preceding, exceding) abrufen. Der ersetzte String wurde zwischen diesen Teilen hinzugefügt, um den endgültigen Return-String zu erzeugen.

Die folgende Funktion erlaubt die Verwendung eines beliebigen Zeichens .
dabei wird als RegExp kein Sonderzeichen wie ** zugelassen, und einige Zeichen müssen wie $ mit Escapezeichen versehen werden.

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 ein reguläres Ausdrucksobjekt verwenden, um Text mit einem Muster abzugleichen. Das Folgende sind Funktionen, die reguläre Ausdrücke werden.

Sie erhalten SyntaxError, wenn Sie ein Muster für ungültigen regulären Ausdruck wie '**' verwenden.

• String.replace() Funktion wird verwendet, um den angegebenen String durch den angegebenen String zu ersetzen.
• String.match() Funktion soll finden, wie oft der String wiederholt wird.
• RegExp.prototype.test Die Methode führt eine Suche nach einer Übereinstimmung zwischen einem regulären Ausdruck und einer angegebenen Zeichenfolge durch. Gibt wahr oder falsch 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 zur Verwendung der obigen 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**.**