How to replace all occurrences of a string in JavaScript

ID : 55

viewed : 411

Tags : javascriptstringreplacejavascript





Top 5 Answer for How to replace all occurrences of a string in JavaScript

vote vote

96

As of August 2020: Modern browsers have support for the String.replaceAll() method defined by the ECMAScript 2021 language specification.


For older/legacy browsers:

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

In response to comment:

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

In response to Click Upvote's comment, you could simplify it even more:

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

Note: Regular expressions contain special (meta) characters, and as such it is dangerous to blindly pass an argument in the find function above without pre-processing it to escape those characters. This is covered in the Mozilla Developer Network's JavaScript Guide on Regular Expressions, where they present the following utility function (which has changed at least twice since this answer was originally written, so make sure to check the MDN site for potential updates):

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

So in order to make the replaceAll() function above safer, it could be modified to the following if you also include escapeRegExp:

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

86

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

String.prototype.replaceAll = function(search, replacement) {     var target = this;     return target.replace(new RegExp(search, 'g'), replacement); }; 

Split and Join (Functional) Implementation

String.prototype.replaceAll = function(search, replacement) {     var target = this;     return target.split(search).join(replacement); }; 

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:

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

We could call escapeRegExp within our String.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).

vote vote

80

Update: In the latest versions of most popular browsers, you can use replaceAll as shown here:

let result = "1 abc 2 abc 3".replaceAll("abc", "xyz"); // `result` is "1 xyz 2 xyz 3" 

But check Can I use or another compatibility table first to make sure the browsers you're targeting have added support for it first.


For Node and compatibility with older/non-current browsers:

Note: Don't use the following solution in performance critical code.

As an alternative to regular expressions for a simple literal string, you could use

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

The general pattern is

str.split(search).join(replacement) 

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://jsben.ch/TZYzj

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.

vote vote

61

Using a regular expression with the g flag set will replace all:

someString = 'the cat looks like a cat'; anotherString = someString.replace(/cat/g, 'dog'); // anotherString now contains "the dog looks like a dog" 

See here also

vote vote

54

Here's a string prototype function based on the accepted answer:

String.prototype.replaceAll = function (find, replace) {     var str = this;     return str.replace(new RegExp(find, 'g'), replace); }; 

EDIT

If your find will contain special characters then you need to escape them:

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

Fiddle: http://jsfiddle.net/cdbzL/

Top 3 video Explaining How to replace all occurrences of a string in JavaScript







Related QUESTION?