I have this string:
"Test abc test test abc test test test abc test test abc"
Doing:
str = str.replace('abc', '');
seems to only remove the first occurrence of abc
in the string above.
How can I replace all occurrences of it?
I have this string:
"Test abc test test abc test test test abc test test abc"
Doing:
str = str.replace('abc', '');
seems to only remove the first occurrence of abc
in the string above.
How can I replace all occurrences of it?
The previous answers are way too complicated. Just use the replace function like this:
Example:
For the sake of completeness, I got to thinking about which method I should use to do this. There are basically two ways to do this as suggested by the other answers on this page.
Note: In general, extending the built-in prototypes in JavaScript is generally not recommended. I am providing as extensions on the String prototype simply for purposes of illustration, showing different implementations of a hypothetical standard method on the
String
built-in prototype.Regular Expression Based Implementation
Split and Join (Functional) Implementation
Not knowing too much about how regular expressions work behind the scenes in terms of efficiency, I tended to lean toward the split and join implementation in the past without thinking about performance. When I did wonder which was more efficient, and by what margin, I used it as an excuse to find out.
On my Chrome Windows 8 machine, the regular expression based implementation is the fastest, with the split and join implementation being 53% slower. Meaning the regular expressions are twice as fast for the lorem ipsum input I used.
Check out this benchmark running these two implementations against each other.
As noted in the comment below by @ThomasLeduc and others, there could be an issue with the regular expression-based implementation if
search
contains certain characters which are reserved as special characters in regular expressions. The implementation assumes that the caller will escape the string beforehand or will only pass strings that are without the characters in the table in Regular Expressions (MDN).MDN also provides an implementation to escape our strings. It would be nice if this was also standardized as
RegExp.escape(str)
, but alas, it does not exist:We could call
escapeRegExp
within ourString.prototype.replaceAll
implementation, however, I'm not sure how much this will affect the performance (potentially even for strings for which the escape is not needed, like all alphanumeric strings).This is the fastest version that doesn't use regular expressions.
Revised jsperf
It is almost twice as fast as the split and join method.
As pointed out in a comment here, this will not work if your
omit
variable containsplace
, as in:replaceAll("string", "s", "ss")
, because it will always be able to replace another occurrence of the word.There is another jsperf with variants on my recursive replace that go even faster (http://jsperf.com/replace-all-vs-split-join/12)!
Performance
Today 27.12.2019 I perform tests on MacOs HighSierra 10.13.6 for chosen solutions
Conclusions
str.replace(/abc/g, '');
(C) is good-cross-browser fast solution for all strings.split-join
(A,B) orreplace
(C,D) are fastwhile
(E,F,G,H) are slow - usually ~4x slower for small strings and about ~3000x (!) slower for long stringsI also create my own solution it looks like currently it is the shortest one which do question job
Details
The tests was perform on Chrome 79.0, Safari 13.0.4 and Firefox 71.0 (64bit). The tests
RA
andRB
use recurrence. ResultsShort string - 55 characters
You can run tests on your machine HERE. Results for chrome
Long string: 275 000 characters
The recursive solutions RA and RB gives
For 1M characters they even break chrome
I try to perform tests for 1M characters for other solutions, but E,F,G,H takes so much time that browser ask me to break script so I shrink test string to 275K characters. You can run tests on your machine HERE. Results for chrome
Code used in tests
Note: Don't use this in performance critical code.
As an alternative to regular expressions for a simple literal string, you could use
The general pattern is
This used to be faster in some cases than using
replaceAll
and a regular expression, but that doesn't seem to be the case anymore in modern browsers.Benchmark: https://jsperf.com/replace-all-vs-split-join
Conclusion: If you have a performance critical use case (e.g processing hundreds of strings), use the Regexp method. But for most typical use cases, this is well worth not having to worry about special characters.