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?
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.
String.prototype.replaceAll = function(search, replacement) {
var target = this;
return target.replace(new RegExp(search, 'g'), replacement);
};
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).
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"
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.
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 omit
place
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 )!
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);
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 60
und 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
findenth Indexposition abgleichen.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**.**