it-swarm.com.de

So ersetzen Sie alle Vorkommen einer Zeichenfolge in JavaScript

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 Vorkommen davon ersetzen?

3564
Click Upvote

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 des String-Prototyps an, um nur die Darstellung zu erleichtern und verschiedene Implementierungen einer hypothetischen Standardmethode für den eingebauten Prototyp String 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 sich in der Vergangenheit der Implementierung anzuschließen, 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 auf regulären Ausdrücken basierende Implementierung die schnellste, wobei die split- und join-Implementierung um 53% langsamer ist. Die regulären Ausdrücke sind also doppelt so schnell für die Eingabe von Lorem ipsum, die ich verwendet habe.

Schauen Sie sich diese benchmark an, wenn diese beiden Implementierungen gegeneinander laufen.


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

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

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

Wir könnten escapeRegExp innerhalb unserer String.prototype.replaceAll-Implementierung nennen, allerdings bin ich nicht sicher, wie stark sich dies auf die Leistung auswirkt (möglicherweise sogar für Zeichenfolgen, für die keine Escapezeichen erforderlich sind, wie bei allen alphanumerischen Zeichenfolgen).

2009
Cory Gross
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);
}
3844
Sean Bright

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.

1244
Matthew Crumley

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

553
Adam A

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/

93
jesal

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
76

Übereinstimmung mit einem globalen regulären Ausdruck:

anotherString = someString.replace(/cat/g, 'dog');
57
scronide
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'
39
SolutionYogi

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.

34

Verwenden Sie einen regulären Ausdruck:

str.replace(/abc/g, '');
32
Donnie DeBoer

Anführungszeichen ersetzen:

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

    return text;
}
30
Chris Rosete

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
29
Adnan Toky

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.

28
Alireza

// 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;
    }
23
Raseela

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.
22
Cole Lawrence
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.

22
csomakk

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

18
rakslice
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;
}
16
Tim Rivoli

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

text = text.replace(new RegExp("cat","g"), "dog"); 
14
Owen
var str = "ff ff f f a de def";
str = str.replace(/f/g,'');
alert(str);

http://jsfiddle.net/ANHR9/

12
pkdkk
while (str.indexOf('abc') !== -1)
{
    str = str.replace('abc', '');
}
12
zdennis

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

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

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

11
Black

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.

9
SamGoody

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.

9
Cheezy Code

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.

7
Sandeep Gantait

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

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

7
Reza Fahmi

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/

7
Riajul Islam

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'
6
Termininja

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
5
User

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.

4
Ferie

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;
}
4
Vitim.us

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

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' 

3
Paulo Buchsbaum

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?]
3
prime
function replaceAll(str, find, replace) {
    var $r="";
    while($r!=str){ 
        $r = str;
        str = str.replace(find, replace);
    }
    return str;
}
3
theWalker

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);
};
3
Nivesh Saharan

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

2
TheAivis

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

2
ashish

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;
2
Guy

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

2
KARTHIKEYAN.A

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)
1
Andrés

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

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);
};
1
C. Morgan

Zum Ersetzen einer einmaligen Verwendung:

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

Zum mehrmaligen Ersetzen verwenden Sie:

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

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"));
1
jessie tessie

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('')
1
sajadre

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(" ")
1
Brijesh Kumar

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 "
0
Raghavendra S

Versuche dies:

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

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

    return str;
};
0

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;
};
0
Stefan Steiger
 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
0
Rinold

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);
0
Nouman Dilshad

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 findenth 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**.**

0
Yash