How do I replace all occurrences of a string in JavaScript?

Question

Given a string:

string = "Test abc test test abc test test test abc test test abc";

This seems to only remove the first occurrence of abc in the string above:

string = string.replace('abc', '');

How do I replace all occurrences of it?

Sacttler

When replacing all occurrences of aba in ababa with ca, which result do you expect? caba? abca? cca? – Alarm

String.prototype.replaceAll() is now a standard part of ECMAScript tc39.es/ecma262/#sec-string.prototype.replaceall, documented at developer.mozilla.org/docs/Web/JavaScript/Reference/… and shipped in Safari 13.1, Firefox 77 and Chrome Dev/Canary and will ship in Chrome 85. From the docs: “If searchValue is a string, replaces all occurrences of searchValue (as if .split(searchValue).join(replaceValue) or a global & properly-escaped regular expression had been used). If searchValue is a non-global regular expression, throws an exception” – Gailgaile

Answer 1

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.js 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 regular expression method. But for most typical use cases, this is well worth not having to worry about special characters.

Imponderabilia

I discourage from using replaceAll at this moment (2020). It is not supported by some browsers that had updates in this year caniuse.com/?search=replaceAll It is too early – Hardecanute

NodeJS supports replaceAll in 15.x versions. – Coralloid

what to do in case-sensitive case – Nub

The benchmark's plain replace function is not the equivalent of regex /g. "If pattern is a string, only the first occurrence will be replaced. " EX: replaceAll_0("foo bar foo") => "bar foo" when it should just be "bar". -MDN – Buine

These solutions are way more readable than the reg-ex based solutions. Imo this should be the top answer. – Uhhuh

Answer 2

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

---

For older/legacy browsers:

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

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

Here is how this answer evolved:

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

In response to comment "what's if 'abc' is passed as a variable?":

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

Crumley

In escapeRegExp the ] and } are extra (not necessary to be escaped). It is better to be like: .replace(/[.^$*+?()[{|\\]/g, "\\$&") – Ediva

You also need to escape the replacement string (consider how escapeRegExp uses $& in the replacement string for special behavior). Change last replace in last code block to replace.replace(/\$/g, '$$$$'). See https://mcmap.net/q/21313/-escape-string-for-use-in-javascript-regex-duplicate Test case: replaceAll('abc def abc', 'abc', '$&@%#!') // Censor 'abc' – Marhtamari

@Sean Bright please read the comments https://mcmap.net/q/21258/-how-do-i-replace-all-occurrences-of-a-string-in-javascript – Chessy

@NishargShah the first sentence of this answer references the replaceAll() method. – Crumley

Yes, I know, I am talking about the comments that this answer has, please check that. – Chessy

@NishargShah I do not remember what comments were on this answer 2 years ago but if you would like to edit this answer and credit yourself feel free. – Crumley

No need @SeanBright, I just want to inform you that, If you are seeing the code of someone and you liked it and you want to improve your answer based on that, then specifying that user name in your answer is good. – Chessy

Answer 3

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

Rajasthan

In 2021 String.prototype.replaceAll() natively exist. So this implementation should be checked first before use. – Ediva

m using nestjs, so typescript showing error that replaceAll is not method of String prototype, any solution for this? – Oblong

Answer 4

These are the most common and readable methods.

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

Method 1:

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

Method 2:

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

Method 3:

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

Method 4:

while(str.includes("abc")){
   str = str.replace("abc", "replaced text");
}

Output:

console.log(str);
// Test replaced text test test replaced text test test test replaced text test test replaced text

Sperry

I found method 1 most easy & reliable till now. its also mentioned here. – Brigandine

method no 2 works great in Sharepoint SPFx for replacing dynamic strings - other methods are explicitly blocked by compiler rules – Foreskin

Answer 5

Use word boundaries (\b)

'a cat is not a caterpillar'.replace(/\bcat\b/gi,'dog');
//"a dog is not a caterpillar"

This is a simple regex that avoids replacing parts of words in most cases. However, a dash - is still considered a word boundary. So conditionals can be used in this case to avoid replacing strings like cool-cat:

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

---

Basically, this question is the same as the question here: Replace " ' " with " '' " in JavaScript

Regexp isn't the only way to replace multiple occurrences of a substring, far from it. Think flexible, think split!

var newText = "the cat looks like a cat".split('cat').join('dog');

Alternatively, to prevent replacing word parts—which the approved answer will do, too! You can get around this issue using regular expressions that are, I admit, somewhat more complex and as an upshot of that, a tad slower, too:

var regText = "the cat looks like a cat".replace(/(?:(^|[^a-z]))(([^a-z]*)(?=cat)cat)(?![a-z])/gi,"$1dog");

The output is the same as the accepted answer, however, using the /cat/g expression on this 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" ??

Oops indeed, this probably isn't what you want. What is, then? IMHO, a regex that only replaces 'cat' conditionally (i.e., not part of a word), like so:

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"

My guess is, this meets your needs. It's not foolproof, of course, but it should be enough to get you started. I'd recommend reading some more on these pages. This'll prove useful in perfecting this expression to meet your specific needs.

• RegExp (regular expression) object

• Regular-Expressions.info

---

Here is an example of .replace used with a callback function. In this case, it dramatically simplifies the expression and provides even more flexibility, like replacing with correct capitalisation or replacing both cat and cats in one go:

'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

Ardeliaardelis

Answer 6

Match against a global regular expression:

anotherString = someString.replace(/cat/g, 'dog');

Moreville

Answer 7

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

Or try the replaceAll method, as recommended in this answer:

str = str.replaceAll('abc', '');

or:

var search = 'abc';
str = str.replaceAll(search, '');

EDIT: Clarification about replaceAll availability

The replaceAll method is added to String's prototype. This means it will be available for all string objects/literals.

Example:

var output = "test this".replaceAll('this', 'that'); // output is 'test that'.
output = output.replaceAll('that', 'this'); // output is 'test this'

Unseal

Answer 8

Use a regular expression:

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

Stochmal

Answer 9

Performance

Today 27.12.2019 I perform tests on macOS v10.13.6 (High Sierra) for the chosen solutions.

Conclusions

• The str.replace(/abc/g, ''); (C) is a good cross-browser fast solution for all strings.
• Solutions based on split-join (A,B) or replace (C,D) are fast
• Solutions based on while (E,F,G,H) are slow - usually ~4 times slower for small strings and about ~3000 times (!) slower for long strings
• The recurrence solutions (RA,RB) are slow and do not work for long strings

I also create my own solution. It looks like currently it is the shortest one which does the question job:

str.split`abc`.join``

str = "Test abc test test abc test test test abc test test abc";
str = str.split`abc`.join``

console.log(str);

Details

The tests were performed on Chrome 79.0, Safari 13.0.4 and Firefox 71.0 (64 bit). The tests RA and RB use recursion. Results

Short 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

RangeError: Maximum call stack size exceeded

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

var t="Test abc test test abc test test test abc test test abc"; // .repeat(5000)
var log = (version,result) => console.log(`${version}: ${result}`);


function A(str) {
  return str.split('abc').join('');
}

function B(str) {
  return str.split`abc`.join``; // my proposition
}


function C(str) {
  return str.replace(/abc/g, '');
}

function D(str) {
  return str.replace(new RegExp("abc", "g"), '');
}

function E(str) {
  while (str.indexOf('abc') !== -1) { str = str.replace('abc', ''); }
  return str;
}

function F(str) {
  while (str.indexOf('abc') !== -1) { str = str.replace(/abc/, ''); }
  return str;
}

function G(str) {
  while(str.includes("abc")) { str = str.replace('abc', ''); }
  return str;
}

// src: https://mcmap.net/q/21258/-how-do-i-replace-all-occurrences-of-a-string-in-javascript
function H(str)
{
    let i = -1
    let find = 'abc';
    let newToken = '';

    if (!str)
    {
        if ((str == null) && (find == null)) return newToken;
        return str;
    }

    while ((
        i = str.indexOf(
            find, i >= 0 ? i + newToken.length : 0
        )) !== -1
    )
    {
        str = str.substring(0, i) +
            newToken +
            str.substring(i + find.length);
    }
    return str;
}

// src: https://mcmap.net/q/21258/-how-do-i-replace-all-occurrences-of-a-string-in-javascript
function RA(string, prevstring) {
  var omit = 'abc';
  var place = '';
  if (prevstring && string === prevstring)
    return string;
  prevstring = string.replace(omit, place);
  return RA(prevstring, string)
}

// src: https://mcmap.net/q/21258/-how-do-i-replace-all-occurrences-of-a-string-in-javascript
function RB(str) {
  var find = 'abc';
  var 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) + RB(st2, find, replace);
    }
  }
  return str;
}




log('A ', A(t));
log('B ', B(t));
log('C ', C(t));
log('D ', D(t));
log('E ', E(t));
log('F ', F(t));
log('G ', G(t));
log('H ', H(t));
log('RA', RA(t)); // use reccurence
log('RB', RB(t)); // use reccurence

<p style="color:red">This snippet only presents codes used in tests. It not perform test itself!<p>

Genro

Now this is one hell of an in depth answer! Thank you very much! Although, what I'm curious about is why the "new RegExp(...)" syntax gives that much of an improvement. – Hehre

Answer 10

Loop it until number occurrences comes to 0, like this:

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

Jungle

This method is dangerous, do not use it. If the replacement string contains the search keyword, then an infinite loop will occur. At the very least, store the result of .indexOf in a variable, and use this variable as the second parameter of .indexOf (minus length of keyword, plus length of replacement string). – Reflective

O(n^2), no reason to ever use this. – Shuddering

Answer 11

This is the fastest version that doesn't use regular expressions.

Revised jsperf

replaceAll = function(string, omit, place, prevstring) {
  if (prevstring && string === prevstring)
    return string;
  prevstring = string.replace(omit, place);
  return replaceAll(prevstring, omit, place, string)
}

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 contains place, 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)!

• Update July 27th 2017: It looks like RegExp now has the fastest performance in the recently released Chrome 59.

Vociferance

Re "almost twice as fast": What was it tested on? Browser, JavaScript runtime, hardware, operating system, etc. All with versions and specifications (e.g. clock speed, CPU type, etc.). – Equiangular

If this benchmarked as the fastest at any point, you didn’t benchmark it comprehensively enough. O(n^2) worst case time for a given search string, easily stack overflows. Also doesn’t return typically expected output if the replacement creates new instances of the search string. – Shuddering

Answer 12

If what you want to find is already in a string, and you don't have a regex escaper handy, you can use join/split:

function replaceMulti(haystack, needle, replacement)
{
    return haystack.split(needle).join(replacement);
}

someString = 'the cat looks like a cat';
console.log(replaceMulti(someString, 'cat', 'dog'));

Zebe

Answer 13

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

Scrivens

Answer 14

I like this method (it looks a little cleaner):

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

Asinine

Answer 15

Of course in 2021 the right answer is:

String.prototype.replaceAll()

console.log(
  'Change this and this for me'.replaceAll('this','that') // Normal case
);
console.log(
  'aaaaaa'.replaceAll('aa','a') // Challenged case
);

If you don't want to deal with replace() + RegExp.

But what if the browser is from before 2020?

In this case we need polyfill (forcing older browsers to support new features) (I think for a few years will be necessary). I could not find a completely right method in answers. So I suggest this function that will be defined as a polyfill.

My suggested options for replaceAll polyfill:

replaceAll polyfill (with global-flag error) (more principled version)

if (!String.prototype.replaceAll) { // Check if the native function not exist
    Object.defineProperty(String.prototype, 'replaceAll', { // Define replaceAll as a prototype for (Mother/Any) String
        configurable: true, writable: true, enumerable: false, // Editable & non-enumerable property (As it should be)
        value: function(search, replace) { // Set the function by closest input names (For good info in consoles)
            return this.replace( // Using native String.prototype.replace()
                Object.prototype.toString.call(search) === '[object RegExp]' // IsRegExp?
                    ? search.global // Is the RegEx global?
                        ? search // So pass it
                        : function(){throw new TypeError('replaceAll called with a non-global RegExp argument')}() // If not throw an error
                    : RegExp(String(search).replace(/[.^$*+?()[{|\\]/g, "\\$&"), "g"), // Replace all reserved characters with '\' then make a global 'g' RegExp
                replace); // passing second argument
        }
    });
}

replaceAll polyfill (With handling global-flag missing by itself) (my first preference) - Why?

if (!String.prototype.replaceAll) { // Check if the native function not exist
    Object.defineProperty(String.prototype, 'replaceAll', { // Define replaceAll as a prototype for (Mother/Any) String
        configurable: true, writable: true, enumerable: false, // Editable & non-enumerable property (As it should be)
        value: function(search, replace) { // Set the function by closest input names (For good info in consoles)
            return this.replace( // Using native String.prototype.replace()
                Object.prototype.toString.call(search) === '[object RegExp]' // IsRegExp?
                    ? search.global // Is the RegEx global?
                        ? search // So pass it
                        : RegExp(search.source, /\/([a-z]*)$/.exec(search.toString())[1] + 'g') // If not, make a global clone from the RegEx
                    : RegExp(String(search).replace(/[.^$*+?()[{|\\]/g, "\\$&"), "g"), // Replace all reserved characters with '\' then make a global 'g' RegExp
                replace); // passing second argument
        }
    });
}

Minified (my first preference):

if(!String.prototype.replaceAll){Object.defineProperty(String.prototype,'replaceAll',{configurable:!0,writable:!0,enumerable:!1,value:function(search,replace){return this.replace(Object.prototype.toString.call(search)==='[object RegExp]'?search.global?search:RegExp(search.source,/\/([a-z]*)$/.exec(search.toString())[1]+'g'):RegExp(String(search).replace(/[.^$*+?()[{|\\]/g,"\\$&"),"g"),replace)}})}

Try it:

if(!String.prototype.replaceAll){Object.defineProperty(String.prototype,'replaceAll',{configurable:!0,writable:!0,enumerable:!1,value:function(search,replace){return this.replace(Object.prototype.toString.call(search)==='[object RegExp]'?search.global?search:RegExp(search.source,/\/([a-z]*)$/.exec(search.toString())[1]+'g'):RegExp(String(search).replace(/[.^$*+?()[{|\\]/g,"\\$&"),"g"),replace)}})}

console.log(
  'Change this and this for me'.replaceAll('this','that')
); // Change that and that for me

console.log(
  'aaaaaa'.replaceAll('aa','a')
); // aaa

console.log(
  '{} (*) (*) (RegEx) (*) (\*) (\\*) [reserved characters]'.replaceAll('(*)','X')
); // {} X X (RegEx) X X (\*) [reserved characters]

console.log(
  'How (replace) (XX) with $1?'.replaceAll(/(xx)/gi,'$$1')
); // How (replace) ($1) with $1?

console.log(
  'Here is some numbers 1234567890 1000000 123123.'.replaceAll(/\d+/g,'***')
); // Here is some numbers *** *** *** and need to be replaced.

console.log(
  'Remove numbers under 233: 236   229  711   200   5'.replaceAll(/\d+/g, function(m) {
    return parseFloat(m) < 233 ? '' : m
  })
); // Remove numbers under 233: 236     711

console.log(
  'null'.replaceAll(null,'x')
); // x


// The difference between My first preference and the original:
// Now in 2022 with browsers > 2020 it should throw an error (But possible it be changed in future)

//   console.log(
//      'xyz ABC abc ABC abc xyz'.replaceAll(/abc/i,'')
//   );

// Browsers < 2020:
// xyz     xyz
// Browsers > 2020
// TypeError: String.prototype.replaceAll called with a non-global RegExp

Browser support:

• Internet Explorer 9 and later (rested on Internet Explorer 11).
• All other browsers (after 2012).

The result is the same as the native replaceAll in case of the first argument input is: null, undefined, Object, Function, Date, ... , RegExp, Number, String, ...

Ref: 22.1.3.19 String.prototype.replaceAll ( searchValue, replaceValue) + RegExp Syntax

Important note: As some professionals mention it, many of recursive functions that suggested in answers, will return the wrong result. (Try them with the challenged case of the above snippet.) Maybe some tricky methods like .split('searchValue').join('replaceValue') or some well managed functions give same result, but definitely with much lower performance than native replaceAll() / polyfill replaceAll() / replace() + RegExp

---

Other methods of polyfill assignment

Naive, but supports even older browsers (be better to avoid)

For example, we can support IE7+ too, by not using Object.defineProperty() and using my old naive assignment method:

if (!String.prototype.replaceAll) {
    String.prototype.replaceAll = function(search, replace) { // <-- Naive method for assignment
        // ... (Polyfill code Here)
    }
}

And it should work well for basic uses on IE7+.
But as here @sebastian-simon explained about, that can make secondary problems in case of more advanced uses. E.g.:

for (var k in 'hi') console.log(k);
// 0
// 1
// replaceAll  <-- ?

Fully trustable, but heavy

In fact, my suggested option is a little optimistic. Like we trusted the environment (browser and Node.js), it is definitely for around 2012-2021. Also it is a standard/famous one, so it does not require any special consideration.

But there can be even older browsers or some unexpected problems, and polyfills still can support and solve more possible environment problems. So in case we need the maximum support that is possible, we can use polyfill libraries like:

https://polyfill.io/

Specially for replaceAll:

<script src="https://polyfill.io/v3/polyfill.min.js?features=String.prototype.replaceAll"></script>

Ediva

Answer 16

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

Desiccant

Answer 17

If the string contains a similar pattern like abccc, you can use this:

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

Sales

Answer 18

As of August 2020 there is a Stage 4 proposal to ECMAScript that adds the replaceAll method to String.

It's now supported in Chrome 85+, Edge 85+, Firefox 77+, Safari 13.1+.

The usage is the same as the replace method:

String.prototype.replaceAll(searchValue, replaceValue)

Here's an example usage:

'Test abc test test abc test.'.replaceAll('abc', 'foo'); // -> 'Test foo test test foo test.'

---

It's supported in most modern browsers, but there exist polyfills:

• core-js
• es-shims

It is supported in the V8 engine behind an experimental flag --harmony-string-replaceall. Read more on the V8 website.

Tb

According to MDN, this has been available since Firefox 77 and Chromium 85. – Assizes

Answer 19

After several trials and a lot of fails, I found that the below function seems to be the best all-rounder when it comes to browser compatibility and ease of use. This is the only working solution for older browsers that I found. (Yes, even though old browser are discouraged and outdated, some legacy applications still make heavy use of OLE browsers (such as old Visual Basic 6 applications or Excel .xlsm macros with forms.)

Anyway, here's the simple function.

function replaceAll(str, match, replacement){
   return str.split(match).join(replacement);
}

Agamic

This has already been suggested or mentioned in 18 other answers, and in the comments under the question. The compatibility considerations are easy to find on CanIUse and MDN. This is all mentioned in the accepted answer. – Nourish

well at first glance I didn't find anything mentioning older browsers and OLE implementations in legacy code. Just thought it might help someone no point of downvoting a helpful answer. You don't have to upvote either I just care that someone might find it useful. Thanks for your contribution nevertheless – Agamic

Answer 20

The previous answers are way too complicated. Just use the replace function like this:

str.replace(/your_regex_pattern/g, replacement_string);

Example:

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

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

console.log(res);

Peeve

Answer 21

If you are trying to ensure that the string you are looking for won't exist even after the replacement, you need to use a loop.

For example:

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

When complete, you will still have 'test abc'!

The simplest loop to solve this would be:

var str = 'test aabcbc';
while (str != str.replace(/abc/g, '')){
   str.replace(/abc/g, '');
}

But that runs the replacement twice for each cycle. Perhaps (at risk of being voted down) that can be combined for a slightly more efficient but less readable form:

var str = 'test aabcbc';
while (str != (str = str.replace(/abc/g, ''))){}
// alert(str); alerts 'test '!

This can be particularly useful when looking for duplicate strings.
For example, if we have 'a,,,b' and we wish to remove all duplicate commas.
[In that case, one could do .replace(/,+/g,','), but at some point the regex gets complex and slow enough to loop instead.]

Merriott

Answer 22

Although people have mentioned the use of regex, there's a better approach if you want to replace the text irrespective of the case of the text. Like uppercase or lowercase. Use the below syntax:

// Consider the below example
originalString.replace(/stringToBeReplaced/gi, '');

// The output will be all the occurrences removed irrespective of casing.

You can refer to the detailed example here.

Bonnibelle

from the example site: "/toBeReplacedString/gi is the regex you need to use. Here g represents for global match and i represents case insensitive. By default regex is case sensitive" – Disguise

Answer 23

My implementation, very self explanatory

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

Solubilize

This is incorrect. replaceAll("123434", "1234", "12") should return "1234" but instead returns "12". – Interment

it depends if you allow to replace "recursively" or not. – Solubilize

replaceAll("abc", "a", "ab") never terminates – Mcnulty

Answer 24

You can simply use below method

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

Abohm

Answer 25

The following function works for me:

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

Now call the functions like this:

"you could be a Project Manager someday, if you work like this.".replaceAllOccurence ("you", "I");

Simply copy and paste this code in your browser console to TEST.

Herwin

Answer 26

I use split and join or this function:

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

Podophyllin

That work wrong in case of replaceAll('aaaaaa','aa','a') – Ediva

Answer 27

There is now a finished proposal for integrating String.prototype.replaceAll into the official specification. Eventually, developers will not have to come up with their own implementations for replaceAll - instead, modern JavaScript engines will support it natively.

The proposal is at stage 4, which means that everything is complete, and all that's left is for browsers to start implementing it.

It has shipped in the latest versions of Chrome, Firefox, and Safari.

Here are the implementation details:

Per the current TC39 consensus, String.prototype.replaceAll behaves identically to String.prototype.replace in all cases, except for the following two cases:

1. If searchValue is a string, String.prototype.replace only replaces a single occurrence of the searchValue, whereas String.prototype.replaceAll replaces all occurrences of the searchValue (as if .split(searchValue).join(replaceValue) or a global & properly-escaped regular expression had been used).
2. If searchValue is a non-global regular expression, String.prototype.replace replaces a single match, whereas String.prototype.replaceAll throws an exception. This is done to avoid the inherent confusion between the lack of a global flag (which implies "do NOT replace all") and the name of the method being called (which strongly suggests "replace all").

Notably, String.prototype.replaceAll behaves just like String.prototype.replace if searchValue is a global regular expression.

You can see a specification-compliant polyfill here.

In supported environments, the following snippet will log foo-bar-baz, without throwing an error:

const str = 'foo bar baz';
console.log(
  str.replaceAll(' ', '-')
);

Progress

Answer 28

If using a library is an option for you then you will get the benefits of the testing and community support that goes with a library function. For example, the string.js library has a replaceAll() function that does what you're looking for:

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

Ney

Answer 29

In my applications, I use a custom function that is the most powerful for this purpose, and even wrapping the split/join solution in the simpler case, it is a little bit faster in Chrome 60 and Firefox 54 (JSBEN.CH) than other solutions. My computer runs Windows 7 64 bits.

The advantage is that this custom function can handle many substitutions at the same time using strings or characters, which can be a shortcut for some applications.

Like the above split/join solution, the solution below doesn't have any problems with escape characters, differently than the regular expression approach.

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

The documentation is below:

 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.

To be fair, I ran the benchmark with no parameter test.

Here is my test set, using 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;

And the results:

1 'banana is a dope fruit harvested far the dover'
2 'banana is a dope fruit harvested dor the dover'
3 'banana is a pe fruit harvested r the ver'
4 'bnn s rp frt hrvstd nr th rvr'
5 'banana as a rapa fraat harvastad naar tha ravar'
6 'bununu is u ripo frait hurvostod nour tho rivor'
7 false
8 false
9 'BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER'
10 'BANANA IS A doPE FRUIT HARVESTED faR THE doVER'

Punishment

Downvoted because using this much code to achieve something so basic feels overkill to me. – Flyblow

It's matter of opinion. For me It's a powerhouse and fast function. I've used for years. One cannot do it on fewer lines. For those who just want to replace chars and pieces in strings without worrying about escape characters from regular expressions, it might be a good choice. The number of lines does not matter much, since it works is a tested black box – Punishment

I like how the function deal with array inputs, same as method of str_replace of PHP, but: 1. The function "caseOff" will not work while inputs be Strings. - 2. The benchmark absolutely and logically look not fair, When you define a function as prototype and redefine this and comment part of your code and also use just string inputs, the result is not fair. The fair can be this : jsben.ch/38Gj1 (Much different in results) – Ediva

Answer 30

In November 2019, a new feature is added to the JavaScript, string.prototype.replaceAll().

Currently it's only supported with Babel, but maybe in the future it can be implemented in all the browsers. For more information, read here.

Destructionist

Wow, javascript is finally adding what Java 1.0 had in 1995. Great! – Sacttler

Answer 31

Here is the working code with prototype:

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

Dejadeject

Answer 32

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

Calibrate

if the replacement contains the "find" youi will have an infinite loop – Pentheam

Answer 33

Use split and join:

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

Someplace

Like many previous answers. What is different? – Equiangular

Split and join is a great way to do replaceAll for two reasons: 1- Availability for String.prototype.replaceAll depends on the NodeJS version you're using. 2- If the searched value for replacement contains characters, using replace with regex global flag becomes harder. – Meitner

Answer 34

This solution combines some previous answers and conforms somewhat better to the proposed August 2020 standard solution. This solution is still viable for me in September 2020, as String.replaceAll is not available in the Node.js binary I am using.

---

RegExp.escape is a separate issue to deal with, but it is important here, because the official proposed solution will automatically escape string-based find input. This String.replaceAll polyfill would not without the RegExp.escape logic.

I have added an answer which doesn't polyfill RegExp.Escape, in the case that you don't want that.

---

If you pass a regular expression to find, you must include g as a flag. This polyfill won't provide a nice TypeError for you and will cause you a major bad time.

If you need exact standards conformance, for an application which is rigorously relying on the standard implementation, then I suggest using Babel or some other tool to get you the 'right answer' every time instead of Stack Overflow. That way you won't have any surprises.

---

Code:

if (!Object.prototype.hasOwnProperty.call(RegExp, 'escape')) {
  RegExp.escape = function(string) {
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Escaping
    // https://github.com/benjamingr/RegExp.escape/issues/37
    return string.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
  };
}

if (!Object.prototype.hasOwnProperty.call(String, 'replaceAll')) {
  String.prototype.replaceAll = function(find, replace) {
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll
    // If you pass a RegExp to 'find', you _MUST_ include 'g' as a flag.
    // TypeError: "replaceAll must be called with a global RegExp" not included, will silently cause significant errors. _MUST_ include 'g' as a flag for RegExp.
    // String parameters to 'find' do not require special handling.
    // Does not conform to "special replacement patterns" when "Specifying a string as a parameter" for replace
    // Does not conform to "Specifying a function as a parameter" for replace
    return this.replace(
          Object.prototype.toString.call(find) == '[object RegExp]' ?
            find :
            new RegExp(RegExp.escape(find), 'g'),
          replace
        );
  }
}

Code, Minified:

Object.prototype.hasOwnProperty.call(RegExp,"escape")||(RegExp.escape=function(e){return e.replace(/[.*+\-?^${}()|[\]\\]/g,"\\$&")}),Object.prototype.hasOwnProperty.call(String,"replaceAll")||(String.prototype.replaceAll=function(e,t){return this.replace("[object RegExp]"==Object.prototype.toString.call(e)?e:new RegExp(RegExp.escape(e),"g"),t)});

---

Example:

console.log(
  't*.STVAL'
    .replaceAll(
      new RegExp(RegExp.escape('T*.ST'), 'ig'),
      'TEST'
    )
);

console.log(
  't*.STVAL'
    .replaceAll(
      't*.ST',
      'TEST'
    );
);

---

Code without RegExp.Escape:

if (!Object.prototype.hasOwnProperty.call(String, 'replaceAll')) {
  String.prototype.replaceAll = function(find, replace) {
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll
    // If you pass a RegExp to 'find', you _MUST_ include 'g' as a flag.
    // TypeError: "replaceAll must be called with a global RegExp" not included, will silently cause significant errors. _MUST_ include 'g' as a flag for RegExp.
    // String parameters to 'find' do not require special handling.
    // Does not conform to "special replacement patterns" when "Specifying a string as a parameter" for replace
    // Does not conform to "Specifying a function as a parameter" for replace
    return this.replace(
          Object.prototype.toString.call(find) == '[object RegExp]' ?
            find :
            new RegExp(find.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&'), 'g'),
          replace
        );
  }
}

Code without RegExp.Escape, Minified:

Object.prototype.hasOwnProperty.call(String,"replaceAll")||(String.prototype.replaceAll=function(e,t){return this.replace("[object RegExp]"==Object.prototype.toString.call(e)?e:new RegExp(e.replace(/[.*+\-?^${}()|[\]\\]/g,"\\$&"),"g"),t)});

Tendon

RegExp.Escape was based on my answer linked here: https://mcmap.net/q/21318/-is-there-a-regexp-escape-function-in-javascript – Tendon

The Object.prototype.hasOwnProperty.call(String, 'replaceAll') will return false anyway, because it owned by String.prototype So it should be like: Object.prototype.hasOwnProperty.call(String.prototype, 'replaceAll') – Ediva

MMMahdy-PAPION is right, but in addition it would be simpler and more transparent to simply check for String.prototype.hasOwnProperty('replaceAll') – Hazlett

Answer 35

For unique replaceable values

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

Adjudicate

Your code doesn't work if words share the same letters. Example : var test = "Groups_4_Questions_0__Options_0_Wording".replaceAll([4, 0, 0], [100, 200, 300]) – Tumor

Not meant for it. Only for unique replaceable values. – Adjudicate

this is useless then in most case – Tumor

Answer 36

The best solution, in order to replace any character we use the indexOf(), includes(), and substring() functions to replace the matched string with the provided string in the current string.

• The String.indexOf() function is to find the n^th match index position.
• The String.includes() method determines whether one string may be found within another string, returning true or false as appropriate.
• String.substring() function is to get the parts of String(preceding,exceding). Add the replace String in-between these parts to generate final return String.

The following function allows to use any character.
where as RegExp will not allow some special character like ** and some characters need to be escaped, like $.

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

---

We can also use the regular expression object for matching text with a pattern. The following are functions which will use the regular expression object.

You will get SyntaxError when you are using an invalid regular expression pattern like '**'.

• The String.replace() function is used to replace the specified String with the given String.
• The String.match() function is to find how many time the string is repeated.
• The RegExp.prototype.test method executes a search for a match between a regular expression and a specified string. Returns true or false.

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

Note that regular expressions are written without quotes.

---

Examples to use the above functions:

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', '\\$':'-'}));

Result:

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

---

Gnaw

In your loop you are repeatedly replacing in a string. This creates a new string on each iteration of the loop which for long strings will cost a lot of performance. Regex already have support to do all replaces in one go which is much faster as it will use tricks to avoid creating multiple new strings. – Royalroyalist

Answer 37

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

Basia

Answer 38

You can do it without Regex, but you need to be careful if the replacement text contains the search text.

e.g.

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

So here is a proper variant of replaceAll, including string-prototype:

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

Or, if you want to have a string-prototype function:

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

Countervail

Answer 39

Starting from v85, Chrome now supports String.prototype.replaceAll natively. Note this outperform all other proposed solutions and should be used once majorly supported.

Feature status: https://chromestatus.com/feature/6040389083463680

var s = "hello hello world";
s = s.replaceAll("hello", ""); // s is now "world"
console.log(s)

Matted

Answer 40

I just want to share my solution, based on some of the functional features of last versions of JavaScript:

   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)

Pleochroism

Answer 41

The simplest solution -

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

Futility

Answer 42

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

str.split(' ').join().replace(/abc/g,'').replace(/,/g, ' ')

Luetic

Answer 43

I added the function below to this performance test page in the "library" section:

https://jsben.ch/LFfWA

function _replace(t, s, r){
    var i = t.indexOf(s);
    if (i == -1) return t;
    return t.slice(0, i) + r + _replace(t.slice(i + s.length, t.length), s,r);
}

..and put this in as the test:

var replaced = _replace(testString, 'abc', '123');

.. and that function performs about 34% faster for me than split or regex. The idea / hope was to end up pasting smaller and smaller pieces of the string onto the stack and then building the entire result by unrolling the stack, thereby minimizing extra string copies and extra searches through the same string data and hopefully optimizing use of the CPU cache.

Part of the thought was that if the string isn't too big, it may end up in the CPU cache; passing it and pasting pieces of it puts those bits into the cache, and then the searching can operate entirely using CPU cached data. Now whether or not that's actually what ends up happening I'm sure is entirely JavaScript implementation-dependent.

This isn't as fast as possible, but it's as fast as I could manage without mutable strings. Arrays in JavaScript probably have a pointer for each element, so, a solution involving a lot of array elements is not likely to be as CPU cache friendly as this.

Treasatreason

Re "performs about 34% faster": What was it tested on? Browser, JavaScript runtime, hardware, operating system, etc. All with versions and specifications (e.g. clock speed, CPU type, etc.). – Equiangular

Answer 44

// Try this way

const str = "Test abc test test abc test test test abc test test abc";
const result = str.split('abc').join('');
console.log(result);

Joel

Answer 45

Repeat until you have replaced them all:

const regex = /^>.*/im;
while (regex.test(cadena)) {
    cadena = cadena.replace(regex, '*');
}

Reunionist

This approach will replace occurrences which only appear after replacing. E.g. when replacing all occurrences of "bc" by "b", then given the input string "abcc" should produce the output "abc", but your approach will produce "ab". – Nourish

This simple script, as Sebastian says, also removes the results that match the expression. This has its good and bad sides. The bad news has already been told by him. The good news is that it is very useful for removing JS tags in XSS and JavaScript Inject attacks. – Reunionist

Answer 46

I have read this question and answers, but I didn't find an appropriate solution for me. Although the answers are quite useful, I decided to create my own solution from scratch. The problems about this kind of replacing are:

• Often it's not enough to simply find a string which matches any upper- or lower case. E.g., for search results I need to replace it with the same case.
• If I deal with innerHTML, I can easily damage HTML tags (e.g., an occurrence of hr in the href attribute).
• The replaceAll() method is too fresh for many use cases, and it doesn't solve all the issues.

So, I was writing functions to highlight search results in a table, where table data cells may have links inside, as well as other HTML tags. And these links were intended to be kept, so innerText was not enough.

The solution I decided to provide for everyone with the same issues. Surely, you can use it not only for tables, but for any elements. Here is the code:

/* Iterate over table data cells to insert a highlight tag */
function highlightSearchResults(textFilter) {
  textFilter = textFilter.toLowerCase().replace('<', '&lt;').replace('>', '&gt;');
  let tds;
  tb = document.getElementById('sometable'); //root element where to search
  if (tb) {
    tds = tb.getElementsByTagName("td"); //sub-elements where to make replacements
  }
  if (textFilter && tds) {
    for (td of tds) {
      //specify your span class or whatever you need before and after
      td.innerHTML = insertCaseInsensitive(td.innerHTML, textFilter, '<span class="highlight">', '</span>');
    }
  }
}

/* Insert a highlight tag */
function insertCaseInsensitive(srcStr, lowerCaseFilter, before, after) {
  let lowStr = srcStr.toLowerCase();
  let flen = lowerCaseFilter.length;
  let i = -1;
  while ((i = lowStr.indexOf(lowerCaseFilter, i + 1)) != -1) {
    if (insideTag(i, srcStr)) continue;
    srcStr = srcStr.slice(0, i) + before + srcStr.slice(i, i+flen) + after + srcStr.slice(i+flen);
    lowStr = srcStr.toLowerCase();
    i += before.length + after.length;
  }
  return srcStr;
}

/* Check if an ocurrence is inside any tag by index */
function insideTag(si, s) {
  let ahead = false;
  let back = false;
  for (let i = si; i < s.length; i++) {
    if (s[i] == "<") {
      break;
    }
    if (s[i] == ">") {
      ahead = true;
      break;
    }
  }
  for (let i = si; i >= 0; i--) {
    if (s[i] == ">") {
      break;
    }
    if (s[i] == "<") {
      back = true;
      break;
    }
  }
  return (ahead && back);
}

Whiff

Related: How can I dynamically highlight strings on a web page?, Find and replace specific text characters across a document with JS. Both links are to my answers which go into quite a bit of depth as to how to replace text content in a document. – Nourish

Oh, those answers are more related to highlighting! However, I only found this replacing-related thread looking for some replacing solutions. Now I tried those functions: if I see correctly they do not highlight in a case-insensitive way, what i mean is: if phrases 'Text' or 'TEXT' (or even 'TexT', 'tExT', etc.) found, they should be highlighted as they are, without converting to lowercase/uppercase. The good thing about your code snippets that they work through the entire document and a ready-to-use solutions. These my functions should be adapted for one's needs and I think it's easy enough. – Whiff

Answer 47

Try this:

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

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

    return str;
};

Scab

Don’t modify objects you don’t own – Oligoclase

if the replacement contains the "find" youi will have an infinite loop – Pentheam

Answer 48

You can try like this:

Example data:

var text = "heloo,hai,hei"

text = text.replace(/[,]+/g, '')

or

text.forEach((value) => {
  hasil = hasil.replace(',', '')
})

Lucillelucina

Answer 49

I know this isn’t the best way to do this, but you can try this:

var annoyingString = "Test abc test test abc test test test abc test test abc";

while (annoyingString.includes("abc")) {
    annoyingString = annoyingString.replace("abc", "")
}

Parhelion

Answer 50

All the answers are accepted, and you can do this by many ways. One of the trick to do this is this:

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

Harquebus