blocks|key|2390931|text|使用带有g标志集的正则表达式将替换所有：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2390932|someString+=+'the+cat+looks+like+a+cat';
anotherString+=+someString.replace(/cat/g,+'dog');
//+anotherString+now+contains+"the+dog+looks+like+a+dog"|code-block|syntax|javascript|2390933|也见这里|2390934|entityMap|0|LINK|mutability|MUTABLE|url|http://www.tizag.com/javascriptT/javascript-string-replace.php^0|4|1|0|0|0|4|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

Using a regular expression with the <code>g</code> flag set will replace all:
<pre class="lang-js prettyprint-override"><code>someString = 'the cat looks like a cat';
anotherString = someString.replace(/cat/g, 'dog');
// anotherString now contains &quot;the dog looks like a dog&quot;
</code></pre>
<a href="http://www.tizag.com/javascriptT/javascript-string-replace.php" rel="noreferrer">See here also</a>

blocks|key|865208|text|匹配全局正则表达式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|865209|anotherString+=+someString.replace(/cat/g,+'dog');|code-block|syntax|javascript|865210|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Match against a global regular expression:

<pre><code>anotherString = someString.replace(/cat/g, 'dog');
</code></pre>

blocks|key|964209|text|截至2020年8月的：由ECMAScript+2021语言规范定义的方法的+现代浏览器支持。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|964210|用于旧版/旧版浏览器的：|964211|function+escapeRegExp(string)+{
++return+string.replace(/[.*%2B?%5E${}()%7C[\]\\]/g,+'\\$&');+//+$&+means+the+whole+matched+string
}

function+replaceAll(str,+find,+replace)+{
++return+str.replace(new+RegExp(escapeRegExp(find),+'g'),+replace);
}|code-block|syntax|javascript|964212|以下是这个答案的演变过程：|964213|str+=+str.replace(/abc/g,+'');|964214|在回答评论时，“如果'abc‘作为一个变量传递，怎么办？”：|964215|var+find+=+'abc';
var+re+=+new+RegExp(find,+'g');

str+=+str.replace(re,+'');|964216|在回应单击“向上”的评论时，你可以把它简化得更简单：|964217|function+replaceAll(str,+find,+replace)+{
++return+str.replace(new+RegExp(find,+'g'),+replace);
}|964218|注释：正则表达式包含特殊(元)字符，因此，如果不对参数进行预处理以转义这些字符，那么盲目地在上面的find函数中传递参数是危险的。这在Mozilla开发人员网络的正则表达式JavaScript指南中有介绍，其中他们提供了以下实用函数(自从最初编写这个答案以来，这个函数至少已经更改了两次，所以请确保检查MDN站点是否有可能更新)：|CODE|964219|function+escapeRegExp(string)+{
++return+string.replace(/[.*%2B?%5E${}()%7C[\]\\]/g,+'\\$&');+//+$&+means+the+whole+matched+string
}|964220|因此，为了使上述replaceAll()函数更安全，如果还包括escapeRegExp，则可以将其修改为以下内容|964221|function+replaceAll(str,+find,+replace)+{
++return+str.replace(new+RegExp(escapeRegExp(find),+'g'),+replace);
}|964222|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll|1|https://www.caniuse.com/mdn-javascript_builtins_string_replaceall|2|https://stackoverflow.com/users/49153/click-upvote|3|https://developer.mozilla.org/en-US/|4|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Escaping^0|A|R|Y|2|0|12|7|1|0|B|1|0|0|0|0|0|0|3|6|2|0|0|0|3|1D|4|1V|D|3|29|H|4|0|0|8|C|V|C|0|0^^$0|@$1|2|3|4|5|6|7|1N|8|@$9|1O|A|1P|B|C]]|D|@$9|1Q|A|1R|1|1S]|$9|1T|A|1U|1|1V]]|E|$]]|$1|F|3|G|5|6|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1Z|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|20|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|21|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|22|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|23|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|24|8|@]|D|@$9|25|A|26|1|27]]|E|$]]|$1|W|3|X|5|J|7|28|8|@]|D|@]|E|$K|L]]|$1|Y|3|Z|5|6|7|29|8|@$9|2A|A|2B|B|C]|$9|2C|A|2D|B|10]]|D|@$9|2E|A|2F|1|2G]|$9|2H|A|2I|1|2J]]|E|$]]|$1|11|3|12|5|J|7|2K|8|@]|D|@]|E|$K|L]]|$1|13|3|14|5|6|7|2L|8|@$9|2M|A|2N|B|10]|$9|2O|A|2P|B|10]]|D|@]|E|$]]|$1|15|3|16|5|J|7|2Q|8|@]|D|@]|E|$K|L]]|$1|17|3|-4|5|6|7|2R|8|@]|D|@]|E|$]]]|18|$19|$5|1A|1B|1C|E|$1D|1E]]|1F|$5|1A|1B|1C|E|$1D|1G]]|1H|$5|1A|1B|1C|E|$1D|1I]]|1J|$5|1A|1B|1C|E|$1D|1K]]|1L|$5|1A|1B|1C|E|$1D|1M]]]]

As of August 2020: <a href="https://www.caniuse.com/mdn-javascript_builtins_string_replaceall" rel="noreferrer">Modern browsers have support</a> for the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll" rel="noreferrer"><code>String.replaceAll()</code> method</a> defined by the ECMAScript 2021 language specification.
<hr />
For older/legacy browsers:
<pre class="lang-js prettyprint-override"><code>function escapeRegExp(string) {
 return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&amp;'); // $&amp; means the whole matched string
}

function replaceAll(str, find, replace) {
 return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);
}
</code></pre>
Here is how this answer evolved:
<pre class="lang-js prettyprint-override"><code>str = str.replace(/abc/g, '');
</code></pre>
In response to comment &quot;what's if 'abc' is passed as a variable?&quot;:
<pre class="lang-js prettyprint-override"><code>var find = 'abc';
var re = new RegExp(find, 'g');

str = str.replace(re, '');
</code></pre>
In response to <a href="https://stackoverflow.com/users/49153/click-upvote">Click Upvote</a>'s comment, you could simplify it even more:
<pre class="lang-js prettyprint-override"><code>function replaceAll(str, find, replace) {
 return str.replace(new RegExp(find, 'g'), replace);
}
</code></pre>
Note: Regular expressions contain special (meta) characters, and as such it is dangerous to blindly pass an argument in the <code>find</code> function above without pre-processing it to escape those characters. This is covered in the <a href="https://developer.mozilla.org/en-US/" rel="noreferrer">Mozilla Developer Network</a>'s <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Escaping" rel="noreferrer">JavaScript Guide on Regular Expressions</a>, 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):
<pre class="lang-js prettyprint-override"><code>function escapeRegExp(string) {
 return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&amp;'); // $&amp; means the whole matched string
}
</code></pre>
So in order to make the <code>replaceAll()</code> function above safer, it could be modified to the following if you also include <code>escapeRegExp</code>:
<pre class="lang-js prettyprint-override"><code>function replaceAll(str, find, replace) {
 return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);
}
</code></pre>

blocks|key|2391064|text|使用正则表达式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2391065|str.replace(/abc/g,+'');|code-block|syntax|javascript|2391066|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Use a regular expression:

<pre><code>str.replace(/abc/g, '');
</code></pre>

blocks|key|2391109|text|在大多数流行浏览器的最新版本中，您可以使用replaceAll，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2391110|let+result+=+"1+abc+2+abc+3".replaceAll("abc",+"xyz");
//+`result`+is+"1+xyz+2+xyz+3"|code-block|syntax|javascript|2391111|但是，首先检查我能用一下吗或其他兼容性表，以确保您针对的浏览器首先添加了对它的支持。|2391112|对于Node.js和与旧的/非当前浏览器的兼容性：|2391113|注意:在性能关键代码中不要使用以下解决方案.|BOLD|2391114|作为简单文字字符串的正则表达式的替代方法，可以使用|2391115|str+=+"Test+abc+test+test+abc+test...".split("abc").join("");|2391116|一般的模式是|2391117|str.split(search).join(replacement)|2391118|在某些情况下，这比使用replaceAll和正则表达式要快，但在现代浏览器中似乎不再是这样了。|2391119|基准：https://jsben.ch/TZYzj|2391120|结论：|2391121|如果您有一个性能关键的用例(例如，处理数百个字符串)，请使用正则表达式方法。但是对于大多数典型的用例来说，这是非常值得的，不必担心特殊的角色。|2391122|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll|1|https://caniuse.com/?search=replaceAll|2|https://jsben.ch/TZYzj^0|L|A|L|A|0|0|0|7|6|1|0|0|0|M|0|0|0|0|0|B|A|0|3|M|2|0|0|0^^$0|@$1|2|3|4|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|D|@$9|1M|A|1N|1|1O]]|E|$]]|$1|F|3|G|5|H|7|1P|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1Q|8|@]|D|@$9|1R|A|1S|1|1T]]|E|$]]|$1|M|3|N|5|6|7|1U|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1V|8|@$9|1W|A|1X|B|Q]]|D|@]|E|$]]|$1|R|3|S|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|T|3|U|5|H|7|1Z|8|@]|D|@]|E|$I|J]]|$1|V|3|W|5|6|7|20|8|@]|D|@]|E|$]]|$1|X|3|Y|5|H|7|21|8|@]|D|@]|E|$I|J]]|$1|Z|3|10|5|6|7|22|8|@$9|23|A|24|B|C]]|D|@]|E|$]]|$1|11|3|12|5|6|7|25|8|@]|D|@$9|26|A|27|1|28]]|E|$]]|$1|13|3|14|5|6|7|29|8|@]|D|@]|E|$]]|$1|15|3|16|5|6|7|2A|8|@]|D|@]|E|$]]|$1|17|3|-4|5|6|7|2B|8|@]|D|@]|E|$]]]|18|$19|$5|1A|1B|1C|E|$1D|1E]]|1F|$5|1A|1B|1C|E|$1D|1G]]|1H|$5|1A|1B|1C|E|$1D|1I]]]]

In the latest versions of most popular browsers, you can use <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll" rel="noreferrer"><code>replaceAll</code></a>
as shown here:
<pre class="lang-js prettyprint-override"><code>let result = &quot;1 abc 2 abc 3&quot;.replaceAll(&quot;abc&quot;, &quot;xyz&quot;);
// `result` is &quot;1 xyz 2 xyz 3&quot;
</code></pre>
But check <a href="https://caniuse.com/?search=replaceAll" rel="noreferrer">Can I use</a> or another compatibility table first to make sure the browsers you're targeting have added support for it first.
<hr />
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
<pre class="lang-js prettyprint-override"><code>str = &quot;Test abc test test abc test...&quot;.split(&quot;abc&quot;).join(&quot;&quot;);
</code></pre>
The general pattern is
<pre class="lang-js prettyprint-override"><code>str.split(search).join(replacement)
</code></pre>
This used to be faster in some cases than using <code>replaceAll</code> and a regular expression, but that doesn't seem to be the case anymore in modern browsers.
Benchmark: <a href="https://jsben.ch/TZYzj" rel="noreferrer">https://jsben.ch/TZYzj</a>
<h3>Conclusion:</h3>
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.

blocks|key|2391131|text|我的实现，很清楚|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2391132|function+replaceAll(string,+token,+newtoken)+{
++++if(token!=newtoken)
++++while(string.indexOf(token)+>+-1)+{
++++++++string+=+string.replace(token,+newtoken);
++++}
++++return+string;
}|code-block|syntax|javascript|2391133|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

My implementation, very self explanatory

<pre><code>function replaceAll(string, token, newtoken) {
 if(token!=newtoken)
 while(string.indexOf(token) &gt; -1) {
 string = string.replace(token, newtoken);
 }
 return string;
}
</code></pre>

blocks|key|865410|text|使用单词边界(\b)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|865411|'a+cat+is+not+a+caterpillar'.replace(/\bcat\b/gi,'dog');
//"a+dog+is+not+a+caterpillar"|code-block|syntax|javascript|865412|这是一个简单的正则表达式，在大多数情况下避免替换部分单词。然而，破折号-仍然被认为是一个单词边界。因此，在这种情况下，可以使用条件词来避免替换字符串(如cool-cat+)。|865413|'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([%5E-]))cat(?:\b([%5E-]))/gi,'$1dog$2');
//"a+dog+is+not+a+cool-cat"|865414|基本上，这个问题与这里的问题相同：在JavaScript中将“‘”改为“'’”|865415|Regexp不是替换子字符串多次出现的唯一方法，而不是它。思想灵活，思想分裂！|865416|var+newText+=+"the+cat+looks+like+a+cat".split('cat').join('dog');|865417|或者，为了防止替换单词部分--批准的答案也会这样做！您可以使用正则表达式来解决这个问题，我承认，正则表达式稍微复杂一些，结果也会慢一点：|865418|var+regText+=+"the+cat+looks+like+a+cat".replace(/(?:(%5E%7C[%5Ea-z]))(([%5Ea-z]*)(?=cat)cat)(?![a-z])/gi,"$1dog");|865419|但是，使用此字符串上的被接受的答案表达式，输出与/cat/g相同：|865420|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"+??|865421|噢-事实上，这可能不是你想要的。那是什么？IMHO，一种只有条件地取代“cat”(即，不是单词的一部分)的正则表达式，如下所示：|865422|var+caterpillar+=+'the+cat+looks+like+a+cat,+not+a+caterpillar+or+coolcat'.replace(/(?:(%5E%7C[%5Ea-z]))(([%5Ea-z]*)(?=cat)cat)(?![a-z])/gi,"$1dog");
//return+"the+dog+looks+like+a+dog,+not+a+caterpillar+or+coolcat"|865423|我猜这符合你的需要。当然，这不是万无一失的，但它应该足以让你开始。我建议在这几页上多读一些。这将证明在完善这个表达式以满足您的特定需求方面很有用。|865424|http://www.javascriptkit.com/jsref/regexp.shtml|unordered-list-item|865425|http://www.regular-expressions.info/|865426|下面是一个与回调函数一起使用的.replace示例。在这种情况下，它极大地简化了表达式，并提供了更大的灵活性，比如用正确的大写替换，或者一次性替换cat和cats：|865427|'Two+cats+are+not+1+Cat!+They\'re+just+cool-cats,+you+caterpillar'
+++.replace(/(%5E%7C.\b)(cat)(s?\b.%7C$)/gi,function(all,char1,cat,char2)
++++{
+++++++//+Check+1st,+capitalize+if+required
+++++++var+replacement+=+(cat.charAt(0)+===+'C'+?+'D'+:+'d')+%2B+'og';
+++++++if+(char1+===+'+'+&&+char2+===+'s')
+++++++{+//+Replace+plurals,+too
+++++++++++cat+=+replacement+%2B+'s';
+++++++}
+++++++else
+++++++{+//+Do+not+replace+if+dashes+are+matched
+++++++++++cat+=+char1+===+'-'+%7C%7C+char2+===+'-'+?+cat+:+replacement;
+++++++}
+++++++return+char1+%2B+cat+%2B+char2;//return+replacement+string
++++});
//returns:
//Two+dogs+are+not+1+Dog!+They're+just+cool-cats,+you+caterpillar|865428|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/9499075/javascript-replace-with/9499926|1|https://stackoverflow.com/questions/1144783/how-do-i-replace-all-occurrences-of-a-string-in-javascript/1145525#1145525|2|3^0|7|2|0|0|Z|1|24|8|0|0|H|M|0|0|0|0|0|0|O|6|B|6|1|0|0|0|0|0|0|1B|2|0|0|10|3|0|F|8|21|3|25|4|0|0^^$0|@$1|2|3|4|5|6|7|1T|8|@$9|1U|A|1V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1W|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|22|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|23|8|@]|D|@$9|24|A|25|1|26]]|E|$]]|$1|Q|3|R|5|6|7|27|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|28|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|29|8|@]|D|@]|E|$]]|$1|W|3|X|5|H|7|2A|8|@]|D|@]|E|$I|J]]|$1|Y|3|Z|5|6|7|2B|8|@$9|2C|A|2D|B|C]]|D|@$9|2E|A|2F|1|2G]]|E|$]]|$1|10|3|11|5|H|7|2H|8|@]|D|@]|E|$I|J]]|$1|12|3|13|5|6|7|2I|8|@]|D|@]|E|$]]|$1|14|3|15|5|H|7|2J|8|@]|D|@]|E|$I|J]]|$1|16|3|17|5|6|7|2K|8|@]|D|@]|E|$]]|$1|18|3|19|5|1A|7|2L|8|@]|D|@$9|2M|A|2N|1|2O]]|E|$]]|$1|1B|3|1C|5|1A|7|2P|8|@]|D|@$9|2Q|A|2R|1|2S]]|E|$]]|$1|1D|3|1E|5|6|7|2T|8|@$9|2U|A|2V|B|C]|$9|2W|A|2X|B|C]|$9|2Y|A|2Z|B|C]]|D|@]|E|$]]|$1|1F|3|1G|5|H|7|30|8|@]|D|@]|E|$I|J]]|$1|1H|3|-4|5|6|7|31|8|@]|D|@]|E|$]]]|1I|$1J|$5|1K|1L|1M|E|$1N|1O]]|1P|$5|1K|1L|1M|E|$1N|1Q]]|1R|$5|1K|1L|1M|E|$1N|19]]|1S|$5|1K|1L|1M|E|$1N|1C]]]]

Use word boundaries (<code>\b</code>)
<pre class="lang-js prettyprint-override"><code>'a cat is not a caterpillar'.replace(/\bcat\b/gi,'dog');
//&quot;a dog is not a caterpillar&quot;
</code></pre>
This is a simple regex that avoids replacing parts of words in most cases. However, a dash <code>-</code> is still considered a word boundary. So conditionals can be used in this case to avoid replacing strings like <code>cool-cat</code>:
<pre class="lang-js prettyprint-override"><code>'a cat is not a cool-cat'.replace(/\bcat\b/gi,'dog');//wrong
//&quot;a dog is not a cool-dog&quot; -- nips
'a cat is not a cool-cat'.replace(/(?:\b([^-]))cat(?:\b([^-]))/gi,'$1dog$2');
//&quot;a dog is not a cool-cat&quot;
</code></pre>
<hr />
Basically, this question is the same as the question here:
<a href="https://stackoverflow.com/questions/9499075/javascript-replace-with/9499926">Replace &quot; &#39; &quot; with &quot; &#39;&#39; &quot; in JavaScript</a>
Regexp isn't the only way to replace multiple occurrences of a substring, far from it. Think flexible, think split!
<pre class="lang-js prettyprint-override"><code>var newText = &quot;the cat looks like a cat&quot;.split('cat').join('dog');
</code></pre>
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:
<pre class="lang-js prettyprint-override"><code>var regText = &quot;the cat looks like a cat&quot;.replace(/(?:(^|[^a-z]))(([^a-z]*)(?=cat)cat)(?![a-z])/gi,&quot;$1dog&quot;);
</code></pre>
The output is the same as <a href="https://stackoverflow.com/questions/1144783/how-do-i-replace-all-occurrences-of-a-string-in-javascript/1145525#1145525">the accepted answer</a>, however, using the <code>/cat/g</code> expression on this string:
<pre class="lang-js prettyprint-override"><code>var oops = 'the cat looks like a cat, not a caterpillar or coolcat'.replace(/cat/g,'dog');
//returns &quot;the dog looks like a dog, not a dogerpillar or cooldog&quot; ??
</code></pre>
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:
<pre class="lang-js prettyprint-override"><code>var caterpillar = 'the cat looks like a cat, not a caterpillar or coolcat'.replace(/(?:(^|[^a-z]))(([^a-z]*)(?=cat)cat)(?![a-z])/gi,&quot;$1dog&quot;);
//return &quot;the dog looks like a dog, not a caterpillar or coolcat&quot;
</code></pre>
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.
<ul>
<li><a href="http://www.javascriptkit.com/jsref/regexp.shtml" rel="nofollow noreferrer">RegExp (regular expression) object</a>
</li>
<li><a href="http://www.regular-expressions.info" rel="nofollow noreferrer">Regular-Expressions.info</a>
</li>
</ul>
<hr />
Here is an example of <code>.replace</code> 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 <code>cat</code> and <code>cats</code> in one go:
<pre class="lang-js prettyprint-override"><code>'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 === ' ' &amp;&amp; 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
</code></pre>

blocks|key|963578|text|下面是一个基于被接受的答案的字符串原型函数|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|963579|String.prototype.replaceAll+=+function(find,+replace)+{
++++var+str+=+this;
++++return+str.replace(new+RegExp(find,+'g'),+replace);
};|code-block|syntax|javascript|963580|如果find包含特殊字符，则需要转义它们：|style|CODE|963581|String.prototype.replaceAll+=+function(find,+replace)+{
++++var+str+=+this;
++++return+str.replace(new+RegExp(find.replace(/[-\/\\%5E$*%2B?.()%7C[\]{}]/g,+'\\$&'),+'g'),+replace);
};|963582|小提琴：http://jsfiddle.net/cdbzL/|963583|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1144783/how-do-i-replace-all-occurrences-of-a-string-in-javascript/1145525#1145525|1|http://jsfiddle.net/cdbzL/^0|7|6|0|0|0|2|4|0|0|4|Q|1|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|15|8|@$A|16|B|17|K|L]]|9|@]|C|$]]|$1|M|3|N|5|F|7|18|8|@]|9|@]|C|$G|H]]|$1|O|3|P|5|6|7|19|8|@]|9|@$A|1A|B|1B|1|1C]]|C|$]]|$1|Q|3|-4|5|6|7|1D|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]|Y|$5|T|U|V|C|$W|Z]]]]

Here's a string prototype function based on <a href="https://stackoverflow.com/questions/1144783/how-do-i-replace-all-occurrences-of-a-string-in-javascript/1145525#1145525">the accepted answer</a>:
<pre class="lang-js prettyprint-override"><code>String.prototype.replaceAll = function(find, replace) {
 var str = this;
 return str.replace(new RegExp(find, 'g'), replace);
};
</code></pre>
If your <code>find</code> contains special characters then you need to escape them:
<pre class="lang-js prettyprint-override"><code>String.prototype.replaceAll = function(find, replace) {
 var str = this;
 return str.replace(new RegExp(find.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&amp;'), 'g'), replace);
};
</code></pre>
Fiddle: <a href="http://jsfiddle.net/cdbzL/" rel="nofollow noreferrer">http://jsfiddle.net/cdbzL/</a>

blocks|key|865477|text|我喜欢这种方法(看起来有点干净)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|865478|text+=+text.replace(new+RegExp("cat","g"),+"dog");+|code-block|syntax|javascript|865479|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

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

<pre><code>text = text.replace(new RegExp("cat","g"), "dog"); 
</code></pre>

blocks|key|2391234|text|如果您想要查找的内容已经在字符串中，而且您手头没有正则表达式转义符，则可以使用联接/拆分：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2391235|​|2391236|++++function+replaceMulti(haystack,+needle,+replacement)
++++{
++++++++return+haystack.split(needle).join(replacement);
++++}

++++someString+=+'the+cat+looks+like+a+cat';
++++console.log(replaceMulti(someString,+'cat',+'dog'));|code-block|syntax|javascript|2391237|2391238|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

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:

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code> function replaceMulti(haystack, needle, replacement)
 {
 return haystack.split(needle).join(replacement);
 }

 someString = 'the cat looks like a cat';
 console.log(replaceMulti(someString, 'cat', 'dog'));</code></pre>
</div>
</div>

blocks|key|2391281|text|为了完整起见，我不得不考虑应该使用哪种方法来完成这项工作。基本上有两种方法可以做到这一点，如本页的其他答案所建议的那样。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2391282|注意:一般情况下，不建议在JavaScript中扩展内置的原型。我只是为了说明而在字符串原型上提供扩展，在String内置原型上展示一个假设的标准方法的不同实现。|offset|length|style|BOLD|CODE|2391283|基于正则表达式的实现|2391284|String.prototype.replaceAll+=+function(search,+replacement)+{
++++var+target+=+this;
++++return+target.replace(new+RegExp(search,+'g'),+replacement);
};|code-block|syntax|javascript|2391285|拆分和连接(功能)实现|2391286|String.prototype.replaceAll+=+function(search,+replacement)+{
++++var+target+=+this;
++++return+target.split(search).join(replacement);
};|2391287|由于不太了解正则表达式在幕后的工作效率，我倾向于过去的拆分和加入实现，而不考虑性能。当我想知道哪一个更有效率，有多大的差距时，我就用它作为找出答案的借口。|2391288|在我的Chrome+8机器上，基于正则表达式的实现是最快的，拆分和连接实现的慢53%25。这意味着对于我使用的lorem输入，正则表达式的速度是以前的两倍。|2391289|查看这个运行这两个实现的基准测试。|2391290|正如@ThomasLeduc和其他人在下面的评论中所指出的，如果search包含某些保留为正则表达式中的特殊字符的字符，则基于正则表达式的实现可能会出现问题。该实现假定调用方将提前转义字符串，或者只传递https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Using_special_characters+(MDN)中表中没有字符的字符串。|2391291|MDN还提供了一个转义字符串的实现。如果这也被标准化为RegExp.escape(str)，那就太好了，但是遗憾的是，它并不存在：|2391292|function+escapeRegExp(str)+{
++return+str.replace(/[.*%2B?%5E${}()%7C[\]\\]/g,+"\\$&");+//+$&+means+the+whole+matched+string
}|2391293|我们可以在我们的escapeRegExp实现中调用String.prototype.replaceAll，但是，我不确定这会对性能产生多大的影响(甚至对于那些不需要转义的字符串，就像所有字母数字字符串一样)。|2391294|entityMap|0|LINK|mutability|MUTABLE|url|http://jsben.ch/#/LFfWA|1|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Using_special_characters|2^0|0|0|9|1H|6|0|0|0|0|0|0|P|4|U|8|0|C|4|0|0|W|6|19|B|1|2T|2Y|2|0|R|I|0|0|8|C|P|R|0^^$0|@$1|2|3|4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1J|8|@$D|1K|E|1L|F|G]|$D|1M|E|1N|F|H]]|9|@]|A|$]]|$1|I|3|J|5|6|7|1O|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|1P|8|@]|9|@]|A|$N|O]]|$1|P|3|Q|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|R|3|S|5|M|7|1R|8|@]|9|@]|A|$N|O]]|$1|T|3|U|5|6|7|1S|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1T|8|@$D|1U|E|1V|F|G]|$D|1W|E|1X|F|G]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1Y|8|@]|9|@$D|1Z|E|20|1|21]]|A|$]]|$1|Z|3|10|5|6|7|22|8|@$D|23|E|24|F|H]]|9|@$D|25|E|26|1|27]|$D|28|E|29|1|2A]]|A|$]]|$1|11|3|12|5|6|7|2B|8|@$D|2C|E|2D|F|H]]|9|@]|A|$]]|$1|13|3|14|5|M|7|2E|8|@]|9|@]|A|$N|O]]|$1|15|3|16|5|6|7|2F|8|@$D|2G|E|2H|F|H]|$D|2I|E|2J|F|H]]|9|@]|A|$]]|$1|17|3|-4|5|6|7|2K|8|@]|9|@]|A|$]]]|18|$19|$5|1A|1B|1C|A|$1D|1E]]|1F|$5|1A|1B|1C|A|$1D|1G]]|1H|$5|1A|1B|1C|A|$1D|1G]]]]

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 <code>String</code> built-in prototype.

<hr>

<h3>Regular Expression Based Implementation</h3>

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

<h3>Split and Join (Functional) Implementation</h3>

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

<hr>

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&nbsp;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 <a href="http://jsben.ch/#/LFfWA" rel="noreferrer">benchmark</a> running these two implementations against each other.

<hr>

As noted in the comment below by @ThomasLeduc and others, there could be an issue with the regular expression-based implementation if <code>search</code> contains certain characters which are reserved as <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Using_special_characters" rel="noreferrer">special characters in regular expressions</a>. 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 <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Using_special_characters" rel="noreferrer">Regular Expressions</a> (MDN).

MDN also provides an implementation to escape our strings. It would be nice if this was also standardized as <code>RegExp.escape(str)</code>, but alas, it does not exist:

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

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

blocks|key|865586|text|var+str+=+"ff+ff+f+f+a+de+def";
str+=+str.replace(/f/g,'');
alert(str);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|865587|http://jsfiddle.net/ANHR9/|unstyled|offset|length|865588|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|Q|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|Q|8|@]|9|@$G|R|H|S|1|T]]|A|$]]|$1|I|3|-4|5|F|7|U|8|@]|9|@]|A|$]]]|J|$K|$5|L|M|N|A|$O|E]]]]

<pre><code>var str = "ff ff f f a de def";
str = str.replace(/f/g,'');
alert(str);
</code></pre>

<a href="http://jsfiddle.net/ANHR9/">http://jsfiddle.net/ANHR9/</a>

blocks|key|2391319|text|要替换所有类型的字符，请尝试以下代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2391320|假设我们需要在我的字符串中发送和\，然后我们将它转换为“to”和\+to。|2391321|因此，这种方法将解决这一问题。|2391322|String.prototype.replaceAll+=+function+(find,+replace)+{
+++++var+str+=+this;
+++++return+str.replace(new+RegExp(find.replace(/[-\/\\%5E$*%2B?.()%7C[\]{}]/g,+'\\$&'),+'g'),+replace);
+};

var+message+=+$('#message').val();
message+=+message.replaceAll('\\',+'\\\\');+/*it+will+replace+\+to+\\+*/
message+=+message.replaceAll('"',+'\\"');+++/*it+will+replace+"+to+\\"*/|code-block|syntax|javascript|2391323|我使用的是Ajax，我需要以JSON格式发送参数。我的方法是这样的：|2391324|+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":"'+%2B+source+%2B+'","messageID":"'+%2B+messageID+%2B+'","toProfileID":"'+%2B+toProfileID+%2B+'","userProfileID":"'+%2B+userProfileID+%2B+'","message":"'+%2B+message+%2B+'"}',
+++++++++++++dataType:+"json",
+++++++++++++success:+function+(data)+{
+++++++++++++++++loadMessageAfterSend(toProfileID,+userProfileID);
+++++++++++++++++$("#<%25=PanelMessageDelete.ClientID%25>").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(/[-\/\\%5E$*%2B?.()%7C[\]{}]/g,+'\\$&'),+'g'),+replace);
+};|2391325|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

For replacing all kind of characters, try this code:
Suppose we have a need to send &quot; and \ in my string. Then we will convert it &quot; to &quot; and \ to \.
So this method will solve this issue.
<pre><code>String.prototype.replaceAll = function (find, replace) {
 var str = this;
 return str.replace(new RegExp(find.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&amp;'), 'g'), replace);
 };

var message = $('#message').val();
message = message.replaceAll('\\', '\\\\'); /*it will replace \ to \\ */
message = message.replaceAll('&quot;', '\\&quot;'); /*it will replace &quot; to \\&quot;*/
</code></pre>
I was using Ajax, and I had the need to send parameters in JSON format. Then my method is looking like this:
<pre><code> function sendMessage(source, messageID, toProfileID, userProfileID) {

 if (validateTextBox()) {
 var message = $('#message').val();
 message = message.replaceAll('\\', '\\\\');
 message = message.replaceAll('&quot;', '\\&quot;');
 $.ajax({
 type: &quot;POST&quot;,
 async: &quot;false&quot;,
 contentType: &quot;application/json; charset=utf-8&quot;,
 url: &quot;services/WebService1.asmx/SendMessage&quot;,
 data: '{&quot;source&quot;:&quot;' + source + '&quot;,&quot;messageID&quot;:&quot;' + messageID + '&quot;,&quot;toProfileID&quot;:&quot;' + toProfileID + '&quot;,&quot;userProfileID&quot;:&quot;' + userProfileID + '&quot;,&quot;message&quot;:&quot;' + message + '&quot;}',
 dataType: &quot;json&quot;,
 success: function (data) {
 loadMessageAfterSend(toProfileID, userProfileID);
 $(&quot;#&lt;%=PanelMessageDelete.ClientID%&gt;&quot;).hide();
 $(&quot;#message&quot;).val(&quot;&quot;);
 $(&quot;#delMessageContainer&quot;).show();
 $(&quot;#msgPanel&quot;).show();
 },
 error: function (result) {
 alert(&quot;message sending failed&quot;);
 }
 });
 }
 else {
 alert(&quot;Please type message in message box.&quot;);
 $(&quot;#message&quot;).focus();

 }
 }

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

blocks|key|865610|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|865611|String.prototype.replaceAll+=+function+(sfind,+sreplace)+{
++++var+str+=+this;

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

++++return+str;
};|code-block|syntax|javascript|865612|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Try this:

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

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

 return str;
};
</code></pre>

blocks|key|865642|text|这是不使用正则表达式的最快的版本。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|865643|修订后的jsperf|865644|replaceAll+=+function(string,+omit,+place,+prevstring)+{
++if+(prevstring+&&+string+===+prevstring)
++++return+string;
++prevstring+=+string.replace(omit,+place);
++return+replaceAll(prevstring,+omit,+place,+string)
}|code-block|syntax|javascript|865645|它几乎是的两倍，其速度是拆分和连接方法的两倍。|865646|正如在这里的注释中指出的那样，如果omit变量包含place+(如：replaceAll("string",+"s",+"ss")+)，这将无法工作，因为它总是能够替换另一个单词的出现。|CODE|865647|还有另一个带有变体的jsperf在我的递归替换中运行得更快了(http://jsperf.com/replace-all-vs-split-join/12)！|865648|更新2017年7月27日:看起来RegExp现在的表现在最近发布的Chrome+59中是最快的。|unordered-list-item|865649|entityMap|0|LINK|mutability|MUTABLE|url|http://jsperf.com/replace-all-vs-split-join/10|1|http://jsperf.com/replace-all-vs-split-join/12^0|B|3|0|0|A|0|0|0|0|H|4|P|5|Y|V|0|V|1A|1|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|19|8|@]|D|@$9|1A|A|1B|1|1C]]|E|$]]|$1|H|3|I|5|J|7|1D|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1E|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1F|8|@$9|1G|A|1H|B|Q]|$9|1I|A|1J|B|Q]|$9|1K|A|1L|B|Q]]|D|@]|E|$]]|$1|R|3|S|5|6|7|1M|8|@]|D|@$9|1N|A|1O|1|1P]]|E|$]]|$1|T|3|U|5|V|7|1Q|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]|14|$5|Z|10|11|E|$12|15]]]]

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

<a href="http://jsperf.com/replace-all-vs-split-join/10" rel="noreferrer">Revised jsperf</a>

<pre><code>replaceAll = function(string, omit, place, prevstring) {
 if (prevstring &amp;&amp; string === prevstring)
 return string;
 prevstring = string.replace(omit, place);
 return replaceAll(prevstring, omit, place, string)
}
</code></pre>

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 <code>omit</code> variable contains <code>place</code>, as in: <code>replaceAll("string", "s", "ss")</code>, 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 (<a href="http://jsperf.com/replace-all-vs-split-join/12" rel="noreferrer">http://jsperf.com/replace-all-vs-split-join/12</a>)!

<ul>
<li>Update July 27th 2017: It looks like RegExp now has the fastest performance in the recently released Chrome 59.</li>
</ul>

blocks|key|865691|text|while+(str.indexOf('abc')+!==+-1)
{
++++str+=+str.replace('abc',+'');
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|865692|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>while (str.indexOf('abc') !== -1)
{
 str = str.replace('abc', '');
}
</code></pre>

blocks|key|2391426|text|如果对您来说使用库是一种选择，那么您将从库函数的测试和社区支持中获得好处。例如，string.js库有一个replaceAll()函数，用于执行所需的任务：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2391427|//+Include+a+reference+to+the+string.js+library+and+call+it+(for+example)+S.
str+=+S(str).replaceAll('abc',+'').s;|code-block|syntax|javascript|2391428|entityMap|0|LINK|mutability|MUTABLE|url|http://stringjs.com/^0|14|9|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

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 <a href="http://stringjs.com/" rel="nofollow">string.js</a> library has a replaceAll() function that does what you're looking for:

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

blocks|key|865759|text|如果您试图确保您正在寻找的字符串即使在替换之后也不存在，则需要使用一个循环。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|865760|例如：|865761|var+str+=+'test+aabcbc';
str+=+str.replace(/abc/g,+'');|code-block|syntax|javascript|865762|当完成后，你还会有‘测试abc'！|865763|解决这一问题的最简单的循环是：|865764|var+str+=+'test+aabcbc';
while+(str+!=+str.replace(/abc/g,+'')){
+++str.replace(/abc/g,+'');
}|865765|但是，在每个周期中，这个替代方案会运行两次。也许(有被投票否决的风险)可以合并成一种略为更有效率但可读性较低的形式：|865766|var+str+=+'test+aabcbc';
while+(str+!=+(str+=+str.replace(/abc/g,+''))){}
//+alert(str);+alerts+'test+'!|865767|在查找重复字符串时，这可能特别有用。|865768|例如，如果我们有'a，，，b‘并且希望删除所有重复的逗号。|865769|在这种情况下，可以执行.replace(/，%2B/g，')，但是在某个时候，正则表达式会变得复杂和缓慢，可以循环。|865770|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|15|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|17|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

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:

<pre><code>var str = 'test aabcbc';
str = str.replace(/abc/g, '');
</code></pre>

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

The simplest loop to solve this would be:

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

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:

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

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

blocks|key|964434|text|function+replaceAll(str,+find,+replace)+{
++var+i+=+str.indexOf(find);
++if+(i+>+-1){
++++str+=+str.replace(find,+replace);+
++++i+=+i+%2B+replace.length;
++++var+st2+=+str.substring(i);
++++if(st2.indexOf(find)+>+-1){
++++++str+=+str.substring(0,i)+%2B+replaceAll(st2,+find,+replace);
++++}+++++++
++}
++return+str;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|964435|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function replaceAll(str, find, replace) {
 var i = str.indexOf(find);
 if (i &gt; -1){
 str = str.replace(find, replace); 
 i = i + replace.length;
 var st2 = str.substring(i);
 if(st2.indexOf(find) &gt; -1){
 str = str.substring(0,i) + replaceAll(st2, find, replace);
 } 
 }
 return str;
}
</code></pre>

blocks|key|963771|text|只需添加/g|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|963772|document.body.innerHTML+=+document.body.innerHTML.replace('hello',+'hi');|code-block|syntax|javascript|963773|至|963774|//+Replace+'hello'+string+with+/hello/g+regular+expression.
document.body.innerHTML+=+document.body.innerHTML.replace(/hello/g,+'hi');|963775|/g的意思是全局|963776|entityMap^0|4|2|0|0|0|0|0|2|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

Just add <code>/g</code> 

<pre><code>document.body.innerHTML = document.body.innerHTML.replace('hello', 'hi');
</code></pre>

to

<pre><code>// Replace 'hello' string with /hello/g regular expression.
document.body.innerHTML = document.body.innerHTML.replace(/hello/g, 'hi');
</code></pre>

<code>/g</code> means global

blocks|key|964464|text|取代单引号：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|964465|function+JavaScriptEncode(text){
++++text+=+text.replace(/'/g,'&apos;')
++++//+More+encode+here+if+required

++++return+text;
}|code-block|syntax|javascript|964466|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Replacing single quotes:

<pre><code>function JavaScriptEncode(text){
 text = text.replace(/'/g,'&amp;apos;')
 // More encode here if required

 return text;
}
</code></pre>

blocks|key|963794|text|我使用p存储上一次递归替换的结果：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|963795|function+replaceAll(s,+m,+r,+p)+{
++++return+s+===+p+%7C%7C+r.contains(m)+?+s+:+replaceAll(s.replace(m,+r),+m,+r,+s);
}|code-block|syntax|javascript|963796|它将替换字符串的中的所有事件，直到可能：|963797|replaceAll('abbbbb',+'ab',+'a')+→+'abbbb'+→+'abbb'+→+'abb'+→+'ab'+→+'a'|963798|为了避免无限循环，我检查替换的r是否包含匹配的m。|963799|replaceAll('abbbbb',+'a',+'ab')+→+'abbbbb'|963800|entityMap^0|3|1|0|0|7|1|0|0|F|1|N|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|T|$]]

I use p to store the result from the previous recursion replacement:

<pre><code>function replaceAll(s, m, r, p) {
 return s === p || r.contains(m) ? s : replaceAll(s.replace(m, r), m, r, s);
}
</code></pre>

It will replace all occurrences in the string s until it is possible:

<pre><code>replaceAll('abbbbb', 'ab', 'a') → 'abbbb' → 'abbb' → 'abb' → 'ab' → 'a'
</code></pre>

To avoid infinite loop I check if the replacement r contains a match m:

<pre><code>replaceAll('abbbbb', 'a', 'ab') → 'abbbbb'
</code></pre>

blocks|key|964480|text|您可以简单地使用以下方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|964481|/**
+*+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);
};|code-block|syntax|javascript|964482|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can simply use below method

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

blocks|key|865934|text|以下功能适用于我：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|865935|String.prototype.replaceAllOccurence+=+function(str1,+str2,+ignore)
{
++++return+this.replace(new+RegExp(str1.replace(/([\/\,\!\\\%5E\$\{\}\[\]\.\*\%2B\?\%7C\<\>\-\&])/g,"\\$&"),(ignore?"gi":"g")),(typeof(str2)=="string")?str2.replace(/\$/g,"$$$$"):str2);
}+;|code-block|syntax|javascript|865936|现在调用这样的函数：|865937|"you+could+be+a+Project+Manager+someday,+if+you+work+like+this.".replaceAllOccurence+("you",+"I");|865938|只需将此代码复制并粘贴到浏览器控制台中即可进行测试。|865939|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

The following function works for me:

<pre><code>String.prototype.replaceAllOccurence = function(str1, str2, ignore)
{
 return this.replace(new RegExp(str1.replace(/([\/\,\!\\\^\$\{\}\[\]\.\*\+\?\|\&lt;\&gt;\-\&amp;])/g,"\\$&amp;"),(ignore?"gi":"g")),(typeof(str2)=="string")?str2.replace(/\$/g,"$$$$"):str2);
} ;
</code></pre>

Now call the functions like this:

<pre><code>"you could be a Project Manager someday, if you work like this.".replaceAllOccurence ("you", "I");
</code></pre>

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

blocks|key|865967|text|下面是带有原型的工作代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|865968|String.prototype.replaceAll+=+function(find,+replace)+{
++++var+str+=+this;
++++return+str.replace(new+RegExp(find.replace(/([.*%2B?%5E=!:${}()%7C\[\]\/\\])/g,+"\\$1"),+'g'),+replace);
};|code-block|syntax|javascript|865969|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is the working code with prototype:

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

blocks|key|2391639|text|function+replaceAll(str,+find,+replace)+{
++++var+$r="";
++++while($r!=str){+
++++++++$r+=+str;
++++++++str+=+str.replace(find,+replace);
++++}
++++return+str;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2391640|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

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

blocks|key|2391661|text|尽管人们已经提到了regex的使用，但是如果您想要替换文本，而不管文本的情况如何，那么还有一种更好的方法。比如大写还是小写。使用以下语法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2391662|//+Consider+the+below+example
originalString.replace(/stringToBeReplaced/gi,+'');

//+The+output+will+be+all+the+occurrences+removed+irrespective+of+casing.|code-block|syntax|javascript|2391663|您可以参考详细的示例这里。|offset|length|2391664|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cheezycode.com/2015/08/javascript-hacks-for-html-webpage.html^0|0|0|A|2|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

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:
<pre><code>// Consider the below example
originalString.replace(/stringToBeReplaced/gi, '');

// The output will be all the occurrences removed irrespective of casing.
</code></pre>
You can refer to the detailed example <a href="http://www.cheezycode.com/2015/08/javascript-hacks-for-html-webpage.html" rel="nofollow noreferrer">here</a>.

blocks|key|2391669|text|假设您想将所有的abc替换为x：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2391670|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|code-block|syntax|javascript|2391671|我试着想一些比修改字符串原型更简单的东西。|2391672|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Say you want to replace all the 'abc' with 'x':

<pre><code>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
</code></pre>

I was trying to think about something more simple than modifying the string prototype.

blocks|key|866110|text|这可以使用正则表达式和标志g来解决，这意味着在找到第一个匹配后不停止。真的，正则表达式是生命的救星！|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|866111|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);
};|code-block|syntax|javascript|866112|entityMap^0|D|1|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

This can be solved using regular expressions and the flag <code>g</code>, which means to not stop after finding the first match. Really, regular expressions are life savers!

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

blocks|key|963881|text|大多数人这么做可能是为了编码一个URL。要对URL进行编码，您不应该只考虑空格，还应该使用encodeURI正确地转换整个字符串。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|963882|encodeURI("http://www.google.com/a+file+with+spaces.html")|code-block|syntax|javascript|963883|得到：|963884|http://www.google.com/a%2520file%2520with%2520spaces.html|963885|entityMap^0|19|9|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

Most people are likely doing this to encode a URL. To encode a URL, you shouldn't only consider spaces, but convert the entire string properly with <code>encodeURI</code>.
<pre><code>encodeURI(&quot;http://www.google.com/a file with spaces.html&quot;)
</code></pre>
to get:
<pre class="lang-none prettyprint-override"><code>http://www.google.com/a%20file%20with%20spaces.html
</code></pre>

blocks|key|963896|text|在RegExp中使用JavaScript可以为您完成这项工作。只需做下面的代码，不要忘记/g之后，全局的突出表现|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|963897|var+str+="Test+abc+test+test+abc+test+test+test+abc+test+test+abc";
str+=+str.replace(/abc/g,+'');|code-block|syntax|javascript|963898|如果您考虑重用，请为您创建一个函数，但不建议这样做，因为它只是一行函数。但是，如果您大量使用它，您可以编写如下内容：|963899|String.prototype.replaceAll+=+String.prototype.replaceAll+%7C%7C+function(string,+replaced)+{
++return+this.replace(new+RegExp(string,+'g'),+replaced);
};|963900|只需在代码中反复使用它，如下所示：|963901|var+str+="Test+abc+test+test+abc+test+test+test+abc+test+test+abc";
str+=+str.replaceAll('abc',+'');|963902|但是，正如我前面提到的，它在要编写的行和性能方面不会有太大的不同。只有缓存函数可能会影响长字符串上一些更快的性能，如果您想要重用，这也是干的代码的一个很好的实践。|963903|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Don%2527t_repeat_yourself^0|1|6|18|2|A|A|1D|2|0|0|0|0|0|0|1W|2|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|D]|$9|1A|A|1B|B|D]]|E|@]|F|$]]|$1|G|3|H|5|I|7|1C|8|@]|E|@]|F|$J|K]]|$1|L|3|M|5|6|7|1D|8|@]|E|@]|F|$]]|$1|N|3|O|5|I|7|1E|8|@]|E|@]|F|$J|K]]|$1|P|3|Q|5|6|7|1F|8|@]|E|@]|F|$]]|$1|R|3|S|5|I|7|1G|8|@]|E|@]|F|$J|K]]|$1|T|3|U|5|6|7|1H|8|@]|E|@$9|1I|A|1J|1|1K]]|F|$]]|$1|V|3|-4|5|6|7|1L|8|@]|E|@]|F|$]]]|W|$X|$5|Y|Z|10|F|$11|12]]]]

Using <code>RegExp</code> in JavaScript could do the job for you. Just simply do something like below code, and don't forget the <code>/g</code> after which standout for global:
<pre><code>var str =&quot;Test abc test test abc test test test abc test test abc&quot;;
str = str.replace(/abc/g, '');
</code></pre>
If you think of reuse, create a function to do that for you, but it's not recommended as it's only one line function. But again, if you heavily use this, you can write something like this:
<pre><code>String.prototype.replaceAll = String.prototype.replaceAll || function(string, replaced) {
 return this.replace(new RegExp(string, 'g'), replaced);
};
</code></pre>
And simply use it in your code over and over like below:
<pre><code>var str =&quot;Test abc test test abc test test test abc test test abc&quot;;
str = str.replaceAll('abc', '');
</code></pre>
But as I mention earlier, it won't make a huge difference in terms of lines to be written or performance. Only caching the function may affect some faster performance on long strings and is also a good practice of <a href="https://en.wikipedia.org/wiki/Don%27t_repeat_yourself" rel="nofollow noreferrer">DRY</a> code if you want to reuse.

blocks|key|2391830|text|在我的应用程序中，我使用了一个功能最强大的定制函数，甚至在更简单的情况下包装split/join解决方案，在Chrome60和Firefox54+(JSBEN.CH)中，它比其他解决方案要快一些。我的电脑运行Windows+7+64位。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2391831|这个自定义函数的优点是可以同时使用字符串或字符处理多个替换，这对于某些应用程序来说是一种快捷方式。|2391832|与上面的拆分/连接解决方案一样，下面的解决方案与正则表达式方法不同，在转义字符方面没有任何问题。|2391833|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)+%7C%7C
++++++++(!+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%2B%2B)+//+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+%7C%7C+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+%2B=+s.slice(pos);
++++++++++++break;
++++++++}+//+No+winner

++++++++//+Found+the+character+or+string+key+in+the+target

++++++++i+=+winner;++//+Restore+the+winner
++++++++r+%2B=+s.slice(pos,+prox);+//+Update+piece+before+the+match

++++++++//+Append+the+replacement+in+target
++++++++if+(!+destDel)
++++++++++++r+%2B=+repl[destOne+?+0+:+i];
++++++++pos+=+prox+%2B+(isString+?+1+:+findUp[i].length);+//+Go+after+match
++++}++//+Loop

++++return+r;+//+Return+the+resulting+string
}|code-block|syntax|javascript|2391834|文件如下：|2391835|replaceAll语法======+replaceAll(s，find，[repl，caseOff，byChar)参数==========+"s“是替换的字符串目标。"find“可以是字符串或字符串数组。如果"find“是字符串，则"repl”应该是与"find“或空类型相同的类型，如果"find”是数组，则用字符串"repl“替换所有"find”中出现的"find“，如果”find“是数组，则将”查找“中的每个字符串替换为"repl”数组中相应的字符串。替换规范是独立的:替换部件不能再次替换。如果"repl“为空，则将删除"s”中的所有"find“事件。如果"repl“只有一个字符或元素，则"s”中的所有出现将被替换为该字符或元素。如果替换不区分大小写(默认值为FALSE)，则"caseOff“为真，如果替换是基于字符集的，则"byChar”为真。默认情况下，如果"byChar"，它将被替换为"s“中所有字符中的”查找“字符集合中的对应字符，在"repl”字符集中返回======函数在替换后返回新的字符串。|blockquote|2391836|公平地说，我运行基准测试时没有参数测试。|2391837|下面是我的测试集，使用Node.js：|2391838|function+l()+{
++++return+console.log.apply(null,+arguments);
}

var+k+=+0;
l(%2B%2Bk,+replaceAll("banana+is+a+ripe+fruit+harvested+near+the+river",
++++++["ri",+"nea"],+["do",+"fa"]));++//+1
l(%2B%2Bk,+replaceAll("banana+is+a+ripe+fruit+harvested+near+the+river",
++++++["ri",+"nea"],+["do"]));+//+2
l(%2B%2Bk,+replaceAll("banana+is+a+ripe+fruit+harvested+near+the+river",
++++++["ri",+"nea"]));+//+3
l(%2B%2Bk,+replaceAll("banana+is+a+ripe+fruit+harvested+near+the+river",
+++++"aeiou",+"",+"",+true));+//+4
l(%2B%2Bk,+replaceAll("banana+is+a+ripe+fruit+harvested+near+the+river",
++++++"aeiou",+"a",+"",+true));+//+5
l(%2B%2Bk,+replaceAll("banana+is+a+ripe+fruit+harvested+near+the+river",
++++++"aeiou",+"uoiea",+"",+true));+//+6
l(%2B%2Bk,+replaceAll("banana+is+a+ripe+fruit+harvested+near+the+river",
++++++"aeiou",+"uoi",+"",+true));+//+7
l(%2B%2Bk,+replaceAll("banana+is+a+ripe+fruit+harvested+near+the+river",
++++++["ri",+"nea"],+["do",+"fa",+"leg"]));+//+8
l(%2B%2Bk,+replaceAll("BANANA+IS+A+RIPE+FRUIT+HARVESTED+NEAR+THE+RIVER",
++++++["ri",+"nea"],+["do",+"fa"]));+//+9
l(%2B%2Bk,+replaceAll("BANANA+IS+A+RIPE+FRUIT+HARVESTED+NEAR+THE+RIVER",
++++++["ri",+"nea"],+["do",+"fa"],+true));+//+10
return;|2391839|其结果是：|2391840|‘香蕉是在多佛收获的一种毒品水果’
2‘香蕉是采自多佛的毒品水果’
‘香蕉是采来的果实’
4+'bnn的rp+frt+hrvstd+nr+th+rvr‘
5‘香蕉在收获时像一只强奸犯
6+'bununu+is+u+ripo+frait+hurvostod+nour+tho+rivor‘
7假
8假
‘香蕉是在河边收获的成熟水果’
10‘香蕉是一种doPE水果收获的faR+faR+doVER’|2391841|entityMap|0|LINK|mutability|MUTABLE|url|http://jsben.ch/kdv27|1^0|12|A|22|8|0|0|0|0|0|0|0|8|4|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@$9|1F|A|1G|1|1H]]|E|$]]|$1|F|3|G|5|6|7|1I|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1J|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1K|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1L|8|@]|D|@]|E|$]]|$1|Q|3|R|5|S|7|1M|8|@]|D|@]|E|$]]|$1|T|3|U|5|6|7|1N|8|@]|D|@$9|1O|A|1P|1|1Q]]|E|$]]|$1|V|3|W|5|6|7|1R|8|@]|D|@]|E|$]]|$1|X|3|Y|5|L|7|1S|8|@]|D|@]|E|$M|N]]|$1|Z|3|10|5|6|7|1T|8|@]|D|@]|E|$]]|$1|11|3|12|5|S|7|1U|8|@]|D|@]|E|$]]|$1|13|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]]|14|$15|$5|16|17|18|E|$19|1A]]|1B|$5|16|17|18|E|$19|1A]]]]

In my applications, I use a custom function that is the most powerful for this purpose, and even wrapping the <code>split/join</code> solution in the simpler case, it is a little bit faster in Chrome 60 and Firefox 54 (<a href="http://jsben.ch/kdv27" rel="nofollow noreferrer">JSBEN.CH</a>) 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.
<pre><code>function replaceAll(s, find, repl, caseOff, byChar) {
 if (arguments.length&lt;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 &amp;&amp; ! destDel)
 return false;
 if (isString &amp;&amp; (typeof find !== &quot;string&quot;))
 return false;

 if (! isString &amp;&amp; (typeof find === &quot;string&quot;)) {
 return s.split(find).join(destDel ? &quot;&quot; : repl);
 }

 if ((! isString) &amp;&amp; (! Array.isArray(find) ||
 (! Array.isArray(repl) &amp;&amp; ! 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 &amp;&amp; ! destDel &amp;&amp; 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 = &quot;&quot;; // Initial result
 var aux, winner;
 while (pos &lt; s.length) { // Scanning the target
 prox = Number.MAX_SAFE_INTEGER;
 winner = -1; // No winner at the start
 for (i=0; i&lt;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] &lt; 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 &lt; prox &amp;&amp; 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
}
</code></pre>
The documentation is below:
<blockquote>
<pre class="lang-none prettyprint-override"><code> replaceAll

 Syntax
 ======

 replaceAll(s, find, [repl, caseOff, byChar)

 Parameters
 ==========

 &quot;s&quot; is a string target of replacement.
 &quot;find&quot; can be a string or array of strings.
 &quot;repl&quot; should be the same type than &quot;find&quot; or empty

 If &quot;find&quot; is a string, it is a simple replacement for
 all &quot;find&quot; occurrences in &quot;s&quot; by string &quot;repl&quot;

 If &quot;find&quot; is an array, it will replaced each string in &quot;find&quot;
 that occurs in &quot;s&quot; for corresponding string in &quot;repl&quot; array.
 The replace specs are independent: A replacement part cannot
 be replaced again.


 If &quot;repl&quot; is empty all &quot;find&quot; occurrences in &quot;s&quot; will be deleted.
 If &quot;repl&quot; has only one character or element,
 all occurrences in &quot;s&quot; will be replaced for that one.

 &quot;caseOff&quot; is true if replacement is case insensitive
 (default is FALSE)

 &quot;byChar&quot; is true when replacement is based on set of characters.
 Default is false

 If &quot;byChar&quot;, it will be replaced in &quot;s&quot; all characters in &quot;find&quot;
 set of characters for corresponding character in &quot;repl&quot;
 set of characters

 Return
 ======

 The function returns the new string after the replacement.
</code></pre>
</blockquote>
To be fair, I ran the <a href="http://jsben.ch/kdv27" rel="nofollow noreferrer">benchmark</a> with no parameter test.
Here is my test set, using Node.js:
<pre><code>function l() {
 return console.log.apply(null, arguments);
}

var k = 0;
l(++k, replaceAll(&quot;banana is a ripe fruit harvested near the river&quot;,
 [&quot;ri&quot;, &quot;nea&quot;], [&quot;do&quot;, &quot;fa&quot;])); // 1
l(++k, replaceAll(&quot;banana is a ripe fruit harvested near the river&quot;,
 [&quot;ri&quot;, &quot;nea&quot;], [&quot;do&quot;])); // 2
l(++k, replaceAll(&quot;banana is a ripe fruit harvested near the river&quot;,
 [&quot;ri&quot;, &quot;nea&quot;])); // 3
l(++k, replaceAll(&quot;banana is a ripe fruit harvested near the river&quot;,
 &quot;aeiou&quot;, &quot;&quot;, &quot;&quot;, true)); // 4
l(++k, replaceAll(&quot;banana is a ripe fruit harvested near the river&quot;,
 &quot;aeiou&quot;, &quot;a&quot;, &quot;&quot;, true)); // 5
l(++k, replaceAll(&quot;banana is a ripe fruit harvested near the river&quot;,
 &quot;aeiou&quot;, &quot;uoiea&quot;, &quot;&quot;, true)); // 6
l(++k, replaceAll(&quot;banana is a ripe fruit harvested near the river&quot;,
 &quot;aeiou&quot;, &quot;uoi&quot;, &quot;&quot;, true)); // 7
l(++k, replaceAll(&quot;banana is a ripe fruit harvested near the river&quot;,
 [&quot;ri&quot;, &quot;nea&quot;], [&quot;do&quot;, &quot;fa&quot;, &quot;leg&quot;])); // 8
l(++k, replaceAll(&quot;BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER&quot;,
 [&quot;ri&quot;, &quot;nea&quot;], [&quot;do&quot;, &quot;fa&quot;])); // 9
l(++k, replaceAll(&quot;BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER&quot;,
 [&quot;ri&quot;, &quot;nea&quot;], [&quot;do&quot;, &quot;fa&quot;], true)); // 10
return;
</code></pre>
And the results:
<blockquote>
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'
</blockquote>

blocks|key|964609|text|如果字符串包含类似于abccc的模式，则可以使用以下方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|964610|str.replace(/abc(\s%7C$)/g,+"")|code-block|syntax|javascript|964611|entityMap^0|A|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

If the string contains a similar pattern like <code>abccc</code>, you can use this:
<pre><code>str.replace(/abc(\s|$)/g, &quot;&quot;)
</code></pre>

blocks|key|866280|text|字符串第一元素中的搜索和替换|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|866281|​|866282|var+str+=+'[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var+i+=+str.replace('"[','[').replace(']"',']');
console.log(i,'//first+element+search+and+replace')|code-block|syntax|javascript|866283|866284|字符串全局搜索中的和替换|866285|866286|var+str+=+'[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var+j+=+str.replace(/\"\[/g,'[').replace(/\]\"/g,']');
console.log(j,'//global+search+and+replace')|866287|866288|entityMap^0|9|5|0|0|0|0|9|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Z|8|@]|D|@]|E|$K|L]]|$1|M|3|G|5|6|7|10|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|P|3|G|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|R|5|J|7|15|8|@]|D|@]|E|$K|L]]|$1|S|3|G|5|6|7|16|8|@]|D|@]|E|$]]|$1|T|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|U|$]]

In string first element search and replace 

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var str = '[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var i = str.replace('"[','[').replace(']"',']');
console.log(i,'//first element search and replace')</code></pre>
</div>
</div>


In string global search and replace 

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var str = '[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var j = str.replace(/\"\[/g,'[').replace(/\]\"/g,']');
console.log(j,'//global search and replace')</code></pre>
</div>
</div>

blocks|key|2391888|text|使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2391889|str+=+str.replace(new+RegExp("abc",+'g'),+"");|code-block|syntax|javascript|2391890|对我来说比以前的答案更有效。因此，new+RegExp("abc",+'g')创建了一个与文本("abc")的所有事件('g'标志)匹配的正则表达式。第二部分是被替换为什么，在您的例子中是空字符串("")。str是字符串，我们必须重写它，因为replace(...)只是返回结果，而不是重写。在某些情况下，您可能需要使用它。|offset|length|style|CODE|2391891|entityMap^0|0|0|H|M|1C|5|1O|3|2R|2|2V|3|3D|C|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]|$I|Z|J|10|K|L]|$I|11|J|12|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|N|$]]

Using
<pre><code>str = str.replace(new RegExp(&quot;abc&quot;, 'g'), &quot;&quot;);
</code></pre>
worked better for me than the previous answers. So <code>new RegExp(&quot;abc&quot;, 'g')</code> creates a regular expression what matches all occurrences (<code>'g'</code> flag) of the text (<code>&quot;abc&quot;</code>). The second part is what gets replaced to, in your case empty string (<code>&quot;&quot;</code>).
<code>str</code> is the string, and we have to override it, as <code>replace(...)</code> just returns result, but not overrides. In some cases you might want to use that.

blocks|key|2391902|text|我只想分享我的解决方案，基于JavaScript最后一个版本的一些功能特性：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2391903|+++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+%2B+'+'+%2B+b;+++})

++console.warn(result)|code-block|syntax|javascript|2391904|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

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

<pre><code> var str = "Test abc test test abc test test test abc test test abc";

 var result = str.split(' ').reduce((a, b) =&gt; {
 return b == 'abc' ? a : a + ' ' + b; })

 console.warn(result)
</code></pre>

blocks|key|866334|text|对于唯一的可替换值|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|866335|​|866336|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);|code-block|syntax|javascript|866337|866338|entityMap^0|2|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|T|8|@]|D|@]|E|$K|L]]|$1|M|3|G|5|6|7|U|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|O|$]]

For unique replaceable values

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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);</code></pre>
</div>
</div>

blocks|key|866379|text|就性能而言，主要的答案是这些是一些在线测试。。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|866380|下面是使用console.time()进行的一些性能测试(它们在您自己的控制台中工作得最好，因为在下面的代码片段中所需的时间非常短)。|style|CODE|866381|​|866382|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');|code-block|syntax|javascript|866383|866384|值得注意的是，如果您多次运行它们，结果总是不同的，即使正则表达式解决方案看起来平均速度最快，而while循环解决方案的运行速度最慢。|866385|entityMap|0|LINK|mutability|MUTABLE|url|http://jsben.ch/BVIHC^0|C|A|0|0|5|E|0|0|0|0|1B|5|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|6|7|13|8|@$A|14|B|15|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|16|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|17|8|@]|9|@]|C|$M|N]]|$1|O|3|I|5|6|7|18|8|@]|9|@]|C|$]]|$1|P|3|Q|5|6|7|19|8|@$A|1A|B|1B|F|G]]|9|@]|C|$]]|$1|R|3|-4|5|6|7|1C|8|@]|9|@]|C|$]]]|S|$T|$5|U|V|W|C|$X|Y]]]]

In terms of performance related to the main answers, <a href="http://jsben.ch/BVIHC" rel="nofollow noreferrer">these are some online tests</a>.
While the following are some performance tests using <code>console.time()</code> (they work best in your own console because the time is very short to be seen in the following snippet).
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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');</code></pre>
</div>
</div>

The interesting thing to notice is that if you run them multiple times, the results are always different even though the regular expression solution seems the fastest on average and the <code>while</code> loop solution the slowest.

blocks|key|866403|text|以前的答案太复杂了。只需像这样使用https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|866404|str.replace(/your_regex_pattern/g,+replacement_string);|code-block|syntax|javascript|866405|示例：|866406|​|866407|var+str+=+"Test+abc+test+test+abc+test+test+test+abc+test+test+abc";

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

console.log(res);|866408|866409|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace^0|H|2N|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|12|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|13|8|@]|9|@]|C|$]]|$1|M|3|N|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|O|3|L|5|6|7|15|8|@]|9|@]|C|$]]|$1|P|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|Q|$R|$5|S|T|U|C|$V|W]]]]

The previous answers are way too complicated. Just use the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace" rel="nofollow noreferrer">replace</a> function like this:
<pre><code>str.replace(/your_regex_pattern/g, replacement_string);
</code></pre>
Example:
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var str = "Test abc test test abc test test test abc test test abc";

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

console.log(res);</code></pre>
</div>
</div>

blocks|key|866424|text|你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|866425|示例数据：|866426|var+text+=+"heloo,hai,hei"

text+=+text.replace(/[,]%2B/g,+'')|code-block|syntax|javascript|866427|或|866428|text.forEach((value)+=>+{
++hasil+=+hasil.replace(',',+'')
})|866429|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can try like this:
Example data:
<pre><code>var text = &quot;heloo,hai,hei&quot;

text = text.replace(/[,]+/g, '')
</code></pre>
or
<pre><code>text.forEach((value) =&gt; {
 hasil = hasil.replace(',', '')
})
</code></pre>

blocks|key|866457|text|方法1|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|866458|尝试实现一个正则表达式：|866459|.replace(/\+abc+/g，‘')；|866460|方法2|866461|分头加入。用abc分割，用空空间连接。|866462|.split(“abc+")+.join(”“)|866463|entityMap^0|0|3|0|0|0|0|3|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|V|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|Z|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|10|8|@]|D|@]|E|$]]|$1|P|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|Q|$]]

Method 1

Try to implement a regular expression:

"Test abc test test abc test test test abc test test abc".replace(/\abc/g, ' ');

Method 2

Split and join. Split with abc and join with empty space.

"Test abc test test abc test test test abc test test abc".split("abc").join(" ")

blocks|key|866471|text|最简单的解决办法-|type|unstyled|depth|inlineStyleRanges|entityRanges|data|866472|​|866473|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("+")|code-block|syntax|javascript|866474|866475|或者简单地说-|866476|866477|str+=+str.split("+").filter((ele,+key)+=>+ele+!=+"abc").join("+")|866478|866479|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|T|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|V|8|@]|9|@]|A|$]]|$1|L|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|X|8|@]|9|@]|A|$G|H]]|$1|O|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|Q|$]]

The simplest solution -

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>let str = "Test abc test test abc test test test abc test test abc";

str = str.split(" ");
str = str.filter((ele, key)=&gt; ele!=="abc")
str = str.join(" ")</code></pre>
</div>
</div>


Or simply -

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>str = str.split(" ").filter((ele, key) =&gt; ele != "abc").join(" ")</code></pre>
</div>
</div>

blocks|key|866506|text|这可以使用正则表达式来实现。可以帮助某人的几种组合：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|866507|var+word+=+"this,\\+.is*a*test,++++'.and?+/+only+/+++++'a+\+test?";
var+stri+=+"This++++++is++++a+test+++++++++and+only+a++++++++test";|code-block|syntax|javascript|866508|替换所有非alpha字符，|offset|length|style|BOLD|866509|console.log(word.replace(/([%5Ea-z])/g,'+').replace(/+%2B/g,+'+'));
Result:+[this+is+a+test+and+only+a+test]|866510|将多个连续空间替换为一个空间的，|866511|console.log(stri.replace(/++%2B/g,'+'));
Result:+[This+is+a+test+and+only+a+test]|866512|替换所有*字符，|866513|console.log(word.replace(/\*/g,''));
Result:+[this,\+.isatest,++++'.and?+/+only+/+++++'a++test?]|866514|替换问号(?)|866515|console.log(word.replace(/\?/g,'#'));
Result:+[this,\+.is*a*test,++++'.and#+/+only+/+++++'a++test#]|866516|替换引号，|866517|console.log(word.replace(/'/g,'#'));
Result:+[this,\+.is*a*test,++++#.and?+/+only+/+++++#a++test?]|866518|替换所有的字符，|866519|console.log(word.replace(/,/g,''));
Result:+[this\+.is*a*test++++'.and?+/+only+/+++++'a++test?]|866520|用替换特定的单词|866521|console.log(word.replace(/test/g,''));
Result:+[this,\+.is*a*,++++'.and?+/+only+/+++++'a++?]|866522|替换反斜杠，|866523|console.log(word.replace(/\\/g,''));
Result:+[this,+.is*a*test,++++'.and?+/+only+/+++++'a++test?]|866524|替换正斜杠，|866525|console.log(word.replace(/\//g,''));
Result:+[this,\+.is*a*test,++++'.and?++only++++++'a++test?]|866526|替换所有空格，|866527|console.log(word.replace(/+/g,'#'));
Result:+[this,\#.is*a*test,####'.and?#/#only#/#####'a##test?]|866528|取代dots，|866529|console.log(word.replace(/\./g,'#'));
Result:+[this,\+#is*a*test,++++'#and?+/+only+/+++++'a++test?]|866530|entityMap^0|0|0|0|D|0|0|F|1|0|0|0|8|0|0|0|7|0|0|0|5|0|0|0|8|0|0|1|7|0|0|0|6|0|0|0|6|0|0|0|7|0|0|0|7|0|0^^$0|@$1|2|3|4|5|6|7|1U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1W|8|@$I|1X|J|1Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|1Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|20|8|@$I|21|J|22|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|23|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|24|8|@$I|25|J|26|K|L]]|9|@]|A|$]]|$1|U|3|V|5|D|7|27|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|28|8|@$I|29|J|2A|K|L]]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|2B|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|2C|8|@$I|2D|J|2E|K|L]]|9|@]|A|$]]|$1|12|3|13|5|D|7|2F|8|@]|9|@]|A|$E|F]]|$1|14|3|15|5|6|7|2G|8|@$I|2H|J|2I|K|L]]|9|@]|A|$]]|$1|16|3|17|5|D|7|2J|8|@]|9|@]|A|$E|F]]|$1|18|3|19|5|6|7|2K|8|@$I|2L|J|2M|K|L]]|9|@]|A|$]]|$1|1A|3|1B|5|D|7|2N|8|@]|9|@]|A|$E|F]]|$1|1C|3|1D|5|6|7|2O|8|@$I|2P|J|2Q|K|L]]|9|@]|A|$]]|$1|1E|3|1F|5|D|7|2R|8|@]|9|@]|A|$E|F]]|$1|1G|3|1H|5|6|7|2S|8|@$I|2T|J|2U|K|L]]|9|@]|A|$]]|$1|1I|3|1J|5|D|7|2V|8|@]|9|@]|A|$E|F]]|$1|1K|3|1L|5|6|7|2W|8|@$I|2X|J|2Y|K|L]]|9|@]|A|$]]|$1|1M|3|1N|5|D|7|2Z|8|@]|9|@]|A|$E|F]]|$1|1O|3|1P|5|6|7|30|8|@$I|31|J|32|K|L]]|9|@]|A|$]]|$1|1Q|3|1R|5|D|7|33|8|@]|9|@]|A|$E|F]]|$1|1S|3|-4|5|6|7|34|8|@]|9|@]|A|$]]]|1T|$]]

This can be achieved using regular expressions. A few combinations that might help someone:
<pre><code>var word = &quot;this,\\ .is*a*test, '.and? / only / 'a \ test?&quot;;
var stri = &quot;This is a test and only a test&quot;;
</code></pre>
To replace all non alpha characters,
<pre class="lang-none prettyprint-override"><code>console.log(word.replace(/([^a-z])/g,' ').replace(/ +/g, ' '));
Result: [this is a test and only a test]
</code></pre>
To replace multiple continuous spaces with one space,
<pre class="lang-none prettyprint-override"><code>console.log(stri.replace(/ +/g,' '));
Result: [This is a test and only a test]
</code></pre>
To replace all * characters,
<pre class="lang-none prettyprint-override"><code>console.log(word.replace(/\*/g,''));
Result: [this,\ .isatest, '.and? / only / 'a test?]
</code></pre>
To replace question marks (?)
<pre class="lang-none prettyprint-override"><code>console.log(word.replace(/\?/g,'#'));
Result: [this,\ .is*a*test, '.and# / only / 'a test#]
</code></pre>
To replace quotation marks,
<pre class="lang-none prettyprint-override"><code>console.log(word.replace(/'/g,'#'));
Result: [this,\ .is*a*test, #.and? / only / #a test?]
</code></pre>
To replace all ' characters,
<pre class="lang-none prettyprint-override"><code>console.log(word.replace(/,/g,''));
Result: [this\ .is*a*test '.and? / only / 'a test?]
</code></pre>
To replace a specific word,
<pre class="lang-none prettyprint-override"><code>console.log(word.replace(/test/g,''));
Result: [this,\ .is*a*, '.and? / only / 'a ?]
</code></pre>
To replace backslash,
<pre class="lang-none prettyprint-override"><code>console.log(word.replace(/\\/g,''));
Result: [this, .is*a*test, '.and? / only / 'a test?]
</code></pre>
To replace forward slash,
<pre class="lang-none prettyprint-override"><code>console.log(word.replace(/\//g,''));
Result: [this,\ .is*a*test, '.and? only 'a test?]
</code></pre>
To replace all spaces,
<pre class="lang-none prettyprint-override"><code>console.log(word.replace(/ /g,'#'));
Result: [this,\#.is*a*test,####'.and?#/#only#/#####'a##test?]
</code></pre>
To replace dots,
<pre class="lang-none prettyprint-override"><code>console.log(word.replace(/\./g,'#'));
Result: [this,\ #is*a*test, '#and? / only / 'a test?]
</code></pre>

blocks|key|964111|text|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|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|964112|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>var myName = 'r//i//n//o//l////d';
var myValidName = myName.replace(new RegExp('\//', 'g'), ''); &gt; // rinold
console.log(myValidName);

var myPetName = 'manidog';
var renameManiToJack = myPetName.replace(new RegExp('mani', 'g'), 'jack'); &gt; // jackdog
</code></pre>

blocks|key|866566|text|这些是最常见和最易读的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|866567|var+str+=+"Test+abc+test+test+abc+test+test+test+abc+test+test+abc"|code-block|syntax|javascript|866568|方法1:|offset|length|style|BOLD|866569|str+=+str.replace(/abc/g,+"replaced+text");|866570|方法2:|866571|str+=+str.split("abc").join("replaced+text");|866572|方法3:|866573|str+=+str.replace(new+RegExp("abc",+"g"),+"replaced+text");|866574|方法4:|866575|while(str.includes("abc")){
+++str+=+str.replace("abc",+"replaced+text");
}|866576|输出：|866577|console.log(str);
//+Test+replaced+text+test+test+replaced+text+test+test+test+replaced+text+test+test+replaced+text|866578|entityMap^0|0|0|0|4|0|0|0|4|0|0|0|4|0|0|0|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@$I|19|J|1A|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1C|8|@$I|1D|J|1E|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1G|8|@$I|1H|J|1I|K|L]]|9|@]|A|$]]|$1|U|3|V|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1K|8|@$I|1L|J|1M|K|L]]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1N|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1O|8|@]|9|@]|A|$]]|$1|12|3|13|5|D|7|1P|8|@]|9|@]|A|$E|F]]|$1|14|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|15|$]]

These are the most common and readable methods.
<pre class="lang-js prettyprint-override"><code>var str = &quot;Test abc test test abc test test test abc test test abc&quot;
</code></pre>
Method 1:
<pre class="lang-js prettyprint-override"><code>str = str.replace(/abc/g, &quot;replaced text&quot;);
</code></pre>
Method 2:
<pre class="lang-js prettyprint-override"><code>str = str.split(&quot;abc&quot;).join(&quot;replaced text&quot;);
</code></pre>
Method 3:
<pre class="lang-js prettyprint-override"><code>str = str.replace(new RegExp(&quot;abc&quot;, &quot;g&quot;), &quot;replaced text&quot;);
</code></pre>
Method 4:
<pre class="lang-js prettyprint-override"><code>while(str.includes(&quot;abc&quot;)){
 str = str.replace(&quot;abc&quot;, &quot;replaced text&quot;);
}
</code></pre>
Output:
<pre class="lang-js prettyprint-override"><code>console.log(str);
// Test replaced text test test replaced text test test test replaced text test test replaced text
</code></pre>

blocks|key|866594|text|我使用拆分和连接或此函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|866595|function+replaceAll(text,+busca,+reemplaza)+{
++while+(text.toString().indexOf(busca)+!=+-1)
++++text+=+text.toString().replace(busca,+reemplaza);
++return+text;
}|code-block|syntax|javascript|866596|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I use split and join or this function:
<pre><code>function replaceAll(text, busca, reemplaza) {
 while (text.toString().indexOf(busca) != -1)
 text = text.toString().replace(busca, reemplaza);
 return text;
}
</code></pre>

blocks|key|866601|text|这应该能行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|866602|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;
}|code-block|syntax|javascript|866603|示例：|866604|Console.log("Steve+is+the+best+character+in+Minecraft".replaceAll("Steve",+"Alex"));|866605|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This should work.

<pre><code>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;
}
</code></pre>

Example:

<pre><code>Console.log("Steve is the best character in Minecraft".replaceAll("Steve", "Alex"));
</code></pre>

blocks|key|964791|text|在不使用任何正则表达式的情况下，最简单的方法是https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split和https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|964792|​|964793|var+str+=+"Test+abc+test+test+abc+test+test+test+abc+test+test+abc";
console.log(str.split('abc').join(''));|code-block|syntax|javascript|964794|964795|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split|1|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join^0|N|2L|0|39|2J|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]|$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|K|3|E|5|6|7|14|8|@]|9|@]|C|$]]|$1|L|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|M|$N|$5|O|P|Q|C|$R|S]]|T|$5|O|P|Q|C|$R|U]]]]

The simplest way to do this without using any regular expression is <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split" rel="nofollow noreferrer">split</a> and <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join" rel="nofollow noreferrer">join</a>, like the code here:
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var str = "Test abc test test abc test test test abc test test abc";
console.log(str.split('abc').join(''));</code></pre>
</div>
</div>

blocks|key|2392244|text|所有的答案都被接受了，你可以通过多种方式做到这一点。这样做的诀窍之一是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2392245|​|2392246|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);|code-block|syntax|javascript|2392247|2392248|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

All the answers are accepted, and you can do this by many ways. One of the trick to do this is this:
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const str = "Test abc test test abc test test test abc test test abc";

const compare = "abc";
arrayStr = str.split(" ");
arrayStr.forEach((element, index) =&gt; {
 if (element == compare) {
 arrayStr.splice(index, 1);
 }
});
const newString = arrayStr.join(" ");
console.log(newString);</code></pre>
</div>
</div>

blocks|key|2392271|text|若要替换一次，请使用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2392272|var+res+=+str.replace('abc',+"");|code-block|syntax|javascript|2392273|若要替换多次，请使用：|2392274|var+res+=+str.replace(/abc/g,+"");|2392275|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

For replacing a single time, use:
<pre><code>var res = str.replace('abc', &quot;&quot;);
</code></pre>
For replacing multiple times, use:
<pre><code>var res = str.replace(/abc/g, &quot;&quot;);
</code></pre>

blocks|key|866687|text|看看这个答案。也许它会有帮助，我在我的项目中使用了它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|866688|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+"|code-block|syntax|javascript|866689|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Check this answer. Maybe it will help, and I used it in my project.
<pre><code>function replaceAll(searchString, replaceString, str) {
 return str.split(searchString).join(replaceString);
}

replaceAll('abc', '',&quot;Test abc test test abc test test test abc test test abc&quot; ); // &quot;Test test test test test test test test &quot;
</code></pre>

blocks|key|964191|text|您可以不使用Regex来完成它，但是如果替换文本包含搜索文本，则需要小心。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|964192|例如：|964193|replaceAll("nihIaohi",+"hI",+"hIcIaO",+true)|code-block|syntax|javascript|964194|下面是replaceAll的适当变体，包括string-prototype：|964195|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+%7C%7C+false;
++++find+=+ignoreCase+?+find.toLowerCase()+:+find;

++++while+((
++++++++i+=+(ignoreCase+?+str.toLowerCase()+:+str).indexOf(
++++++++++++find,+i+>=+0+?+i+%2B+newToken.length+:+0
++++++++))+!==+-1
++++)
++++{
++++++++str+=+str.substring(0,+i)+%2B
++++++++++++newToken+%2B
++++++++++++str.substring(i+%2B+find.length);
++++}+//+Whend+

++++return+str;
}|964196|或者，如果您想拥有一个字符串原型函数：|964197|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+%7C%7C+false;
++++find+=+ignoreCase+?+find.toLowerCase()+:+find;

++++while+((
++++++++i+=+(ignoreCase+?+str.toLowerCase()+:+str).indexOf(
++++++++++++find,+i+>=+0+?+i+%2B+newToken.length+:+0
++++++++))+!==+-1
++++)
++++{
++++++++str+=+str.substring(0,+i)+%2B
++++++++++++newToken+%2B
++++++++++++str.substring(i+%2B+find.length);
++++}+//+Whend+

++++return+str;
};|964198|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

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

e.g. 

<pre><code>replaceAll("nihIaohi", "hI", "hIcIaO", true)
</code></pre>

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

<pre><code>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) &amp;&amp; (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 &gt;= 0 ? i + newToken.length : 0
 )) !== -1
 )
 {
 str = str.substring(0, i) +
 newToken +
 str.substring(i + find.length);
 } // Whend 

 return str;
}
</code></pre>

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

<pre><code>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) &amp;&amp; (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 &gt;= 0 ? i + newToken.length : 0
 )) !== -1
 )
 {
 str = str.substring(0, i) +
 newToken +
 str.substring(i + find.length);
 } // Whend 

 return str;
};
</code></pre>

blocks|key|866749|text|str+=+"Test+abc+test+test+abc+test+test+test+abc+test+test+abc"

str.split('+').join().replace(/abc/g,'').replace(/,/g,+'+')|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|866750|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>str = "Test abc test test abc test test test abc test test abc"

str.split(' ').join().replace(/abc/g,'').replace(/,/g, ' ')
</code></pre>

blocks|key|2392484|text|到2020年8月，有一个第四阶段提案到ECMAScript，它将replaceAll方法添加到String。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2392485|现在它在Chrome+85%2B、Edge+85%2B、Firefox+77%2B、Safari+13.1%2B中得到了支持。|BOLD|2392486|其用法与replace方法相同：|2392487|String.prototype.replaceAll(searchValue,+replaceValue)|code-block|syntax|javascript|2392488|下面是一个示例用法：|2392489|'Test+abc+test+test+abc+test.'.replaceAll('abc',+'foo');+//+->+'Test+foo+test+test+foo+test.'|2392490|它在大多数现代浏览器中是支持的，但是存在多填充：|2392491|核js|unordered-list-item|2392492|斯希姆|2392493|在V8引擎中，在一个实验标志--harmony-string-replaceall后面支持它。阅读更多关于V8网站的内容。|2392494|entityMap|0|LINK|mutability|MUTABLE|url|https://tc39.es/proposal-string-replaceall/|1|https://github.com/tc39/proposal-string-replaceall|2|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace|3|https://caniuse.com/#search=replaceAll|4|https://github.com/zloirock/core-js#stringreplaceall|5|https://github.com/es-shims/String.prototype.replaceAll|6|https://v8.dev/|7|https://v8.dev/features/string-replaceall^0|W|A|1B|6|C|6|0|W|A|1|0|4|18|0|4|7|4|7|2|0|0|0|0|2|8|3|0|0|3|4|0|0|3|5|0|E|R|1|2|6|1H|4|7|0^^$0|@$1|2|3|4|5|6|7|1O|8|@$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@$9|1T|A|1U|1|1V]|$9|1W|A|1X|1|1Y]]|E|$]]|$1|F|3|G|5|6|7|1Z|8|@$9|20|A|21|B|H]]|D|@]|E|$]]|$1|I|3|J|5|6|7|22|8|@$9|23|A|24|B|C]]|D|@$9|25|A|26|1|27]]|E|$]]|$1|K|3|L|5|M|7|28|8|@]|D|@]|E|$N|O]]|$1|P|3|Q|5|6|7|29|8|@]|D|@]|E|$]]|$1|R|3|S|5|M|7|2A|8|@]|D|@]|E|$N|O]]|$1|T|3|U|5|6|7|2B|8|@]|D|@$9|2C|A|2D|1|2E]]|E|$]]|$1|V|3|W|5|X|7|2F|8|@]|D|@$9|2G|A|2H|1|2I]]|E|$]]|$1|Y|3|Z|5|X|7|2J|8|@]|D|@$9|2K|A|2L|1|2M]]|E|$]]|$1|10|3|11|5|6|7|2N|8|@$9|2O|A|2P|B|C]]|D|@$9|2Q|A|2R|1|2S]|$9|2T|A|2U|1|2V]]|E|$]]|$1|12|3|-4|5|6|7|2W|8|@]|D|@]|E|$]]]|13|$14|$5|15|16|17|E|$18|19]]|1A|$5|15|16|17|E|$18|1B]]|1C|$5|15|16|17|E|$18|1D]]|1E|$5|15|16|17|E|$18|1F]]|1G|$5|15|16|17|E|$18|1H]]|1I|$5|15|16|17|E|$18|1J]]|1K|$5|15|16|17|E|$18|1L]]|1M|$5|15|16|17|E|$18|1N]]]]

As of August 2020 there is a <a href="https://tc39.es/proposal-string-replaceall/" rel="nofollow noreferrer">Stage 4 proposal</a> to ECMAScript that adds the <a href="https://github.com/tc39/proposal-string-replaceall" rel="nofollow noreferrer"><code>replaceAll</code></a> method to <code>String</code>.
It's now supported in Chrome 85+, Edge 85+, Firefox 77+, Safari 13.1+.
The usage is the same as the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace" rel="nofollow noreferrer"><code>replace</code></a> method:
<pre><code>String.prototype.replaceAll(searchValue, replaceValue)
</code></pre>
Here's an example usage:
<pre><code>'Test abc test test abc test.'.replaceAll('abc', 'foo'); // -&gt; 'Test foo test test foo test.'
</code></pre>
<hr />
It's supported in <a href="https://caniuse.com/#search=replaceAll" rel="nofollow noreferrer">most modern browsers</a>, but there exist polyfills:
<ul>
<li><a href="https://github.com/zloirock/core-js#stringreplaceall" rel="nofollow noreferrer">core-js</a></li>
<li><a href="https://github.com/es-shims/String.prototype.replaceAll" rel="nofollow noreferrer">es-shims</a></li>
</ul>
It is supported in the <a href="https://v8.dev/" rel="nofollow noreferrer">V8</a> engine behind an experimental flag <code>--harmony-string-replaceall</code>.
Read more on the <a href="https://v8.dev/features/string-replaceall" rel="nofollow noreferrer">V8 website</a>.

blocks|key|964920|text|看看这个。我相信它会对你有帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|964921|<!DOCTYPE+html>
<html>
<body>
Click+the+button+to+do+a+global+search+and+replace+for+"is"+in+a+string.
<button+onclick="myFunction()">Try+it</button>
<p+id="demo">
<script>
function+myFunction()+{
++var+str+=+'Is+this+"3"+dris+"3"?';
++var+allvar=+'"3"';
++var+patt1+=+new+RegExp(+allvar,+'g'+);
++document.getElementById("demo").innerHTML+=+str.replace(patt1,'"5"');
}
</script>
</body>
</html>|code-block|syntax|javascript|964922|这是JSFiddle链路。|offset|length|964923|entityMap|0|LINK|mutability|MUTABLE|url|https://jsfiddle.net/Wsmemon/23ykfjh8/41/^0|0|0|2|A|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Check this. I'm sure it will help you:

<pre><code>&lt;!DOCTYPE html&gt;
&lt;html&gt;
&lt;body&gt;
&lt;p&gt;Click the button to do a global search and replace for "is" in a string.&lt;/p&gt;
&lt;button onclick="myFunction()"&gt;Try it&lt;/button&gt;
&lt;p id="demo"&gt;&lt;/p&gt;
&lt;script&gt;
function myFunction() {
 var str = 'Is this "3" dris "3"?';
 var allvar= '"3"';
 var patt1 = new RegExp( allvar, 'g' );
 document.getElementById("demo").innerHTML = str.replace(patt1,'"5"');
}
&lt;/script&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>

Here is the <a href="https://jsfiddle.net/Wsmemon/23ykfjh8/41/" rel="nofollow noreferrer">JSFiddle link</a>.

blocks|key|2392613|text|在2019年11月，JavaScript，string.prototype.replaceAll()增加了一个新特性。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2392614|目前它只支持巴贝尔，但是将来它可以在所有的浏览器中实现。欲了解更多信息，请访问在这里读。|2392615|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Babel_(transcompiler))|1|https://v8.dev/features/string-replaceall^0|L|T|0|6|3|0|13|4|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@]|D|@$9|V|A|W|1|X]|$9|Y|A|Z|1|10]]|E|$]]|$1|H|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]]]

In November 2019, a new feature is added to the JavaScript, <code>string.prototype.replaceAll()</code>.
Currently it's only supported with <a href="https://en.wikipedia.org/wiki/Babel_(transcompiler)" rel="nofollow noreferrer">Babel</a>, but maybe in the future it can be implemented in all the browsers. For more information, <a href="https://v8.dev/features/string-replaceall" rel="nofollow noreferrer">read here</a>.

blocks|key|2392725|text|性能|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2392726|今天，27.12.2019我对所选的解决方案在macOS+v10.13.6+(High塞拉利昂)上执行测试。|offset|length|2392727|结论|style|BOLD|2392728|str.replace(/abc/g,+'');+(C)是一个很好的跨浏览器的快速解决方案。|unordered-list-item|CODE|2392729|基于split-join+(A，B)或replace+(C，D)的解决方案速度快|2392730|基于while+(E，F，G，H)的解决方案是慢的--通常是小字符串慢4倍，大约是3000倍(!)较长字符串较慢|2392731|递归解决方案(、RA、RB、)速度慢，不适用于长字符串。|2392732|我也创造了我自己的解决方案。现在看来，它是执行问题的最短的一个：|2392733|str.split`abc`.join``|code-block|syntax|javascript|2392734|​|2392735|str+=+"Test+abc+test+test+abc+test+test+test+abc+test+test+abc";
str+=+str.split`abc`.join``

console.log(str);|2392736|2392737|详细信息|2392738|这些测试是在Chrome+79.0、Safari+13.0.4和Firefox+71.0+(64位)上进行的。测试RA和RB使用递归。结果|2392739|2392740|📷|atomic|2392741|2392742|短字符串-55个字符|2392743|您可以在您的计算机这里上运行测试。铬的结果：|2392744|2392745|2392746|2392747|长字符串:+275,000个字符|2392748|、RA、和RB的递归解|2392749|RangeError:超过最大调用堆栈大小|blockquote|2392750|对于1万个字符，他们甚至会破坏Chrome|2392751|2392752|2392753|2392754|我尝试为其他解决方案执行1M字符的测试，但是E、F、G、H花费了太多时间，以至于浏览器要求我中断脚本，所以我将测试字符串缩小到275+K字符。您可以在您的计算机这里上运行测试。铬的测定结果|2392755|2392756|2392757|2392758|测试中使用的代码|2392759|2392760|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://stackoverflow.com/a/56989553/860099
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+%2B+newToken.length+:+0
++++++++))+!==+-1
++++)
++++{
++++++++str+=+str.substring(0,+i)+%2B
++++++++++++newToken+%2B
++++++++++++str.substring(i+%2B+find.length);
++++}
++++return+str;
}

//+src:+https://stackoverflow.com/a/22870785/860099
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://stackoverflow.com/a/26107132/860099
function+RB(str)+{
++var+find+=+'abc';
++var+replace+=+'';
++var+i+=+str.indexOf(find);
++if+(i+>+-1){
++++str+=+str.replace(find,+replace);
++++i+=+i+%2B+replace.length;
++++var+st2+=+str.substring(i);
++++if(st2.indexOf(find)+>+-1){
++++++str+=+str.substring(0,i)+%2B+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|2392761|<p+style="color:red">This+snippet+only+presents+codes+used+in+tests.+It+not+perform+test+itself!|2392762|2392763|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/MacOS_High_Sierra|1|IMAGE|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/3980fcd05a1577ad9c134cdcf725329f.png|imageAlt|2|https://jsperf.com/remove-substring-small/1|3|https://developer.qcloudimg.com/http-save/yehe-900000/167aa2acd5347b868554bf2d65c90593.png|4|https://developer.qcloudimg.com/http-save/yehe-900000/83115cf1a1193762b1855cf0183d9500.png|5|https://jsperf.com/remove-substring-big/1|6|https://developer.qcloudimg.com/http-save/yehe-900000/51d49bb2b8dd1b136e7e9b0e214c529c.png^0|0|N|E|0|0|0|2|0|0|O|Q|1|0|2|A|J|7|E|3|S|3|0|2|5|9|7|0|7|7|0|0|0|0|0|0|0|1L|2|1O|2|0|0|0|1|1|0|0|0|9|2|2|0|0|0|1|3|0|0|0|0|4|5|2|0|0|0|0|0|1|4|0|0|M|7|28|2|5|0|0|0|1|6|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|2Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|2Z|8|@]|9|@$D|30|E|31|1|32]]|A|$]]|$1|F|3|G|5|6|7|33|8|@$D|34|E|35|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|36|8|@$D|37|E|38|H|M]|$D|39|E|3A|H|I]]|9|@]|A|$]]|$1|N|3|O|5|L|7|3B|8|@$D|3C|E|3D|H|M]|$D|3E|E|3F|H|M]|$D|3G|E|3H|H|I]|$D|3I|E|3J|H|I]]|9|@]|A|$]]|$1|P|3|Q|5|L|7|3K|8|@$D|3L|E|3M|H|M]|$D|3N|E|3O|H|I]]|9|@]|A|$]]|$1|R|3|S|5|L|7|3P|8|@$D|3Q|E|3R|H|I]]|9|@]|A|$]]|$1|T|3|U|5|6|7|3S|8|@]|9|@]|A|$]]|$1|V|3|W|5|X|7|3T|8|@]|9|@]|A|$Y|Z]]|$1|10|3|11|5|6|7|3U|8|@]|9|@]|A|$]]|$1|12|3|13|5|X|7|3V|8|@]|9|@]|A|$Y|Z]]|$1|14|3|11|5|6|7|3W|8|@]|9|@]|A|$]]|$1|15|3|16|5|6|7|3X|8|@]|9|@]|A|$]]|$1|17|3|18|5|6|7|3Y|8|@$D|3Z|E|40|H|M]|$D|41|E|42|H|M]]|9|@]|A|$]]|$1|19|3|11|5|6|7|43|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|1C|7|44|8|@]|9|@$D|45|E|46|1|47]]|A|$]]|$1|1D|3|11|5|6|7|48|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|49|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|4A|8|@]|9|@$D|4B|E|4C|1|4D]]|A|$]]|$1|1I|3|11|5|6|7|4E|8|@]|9|@]|A|$]]|$1|1J|3|1B|5|1C|7|4F|8|@]|9|@$D|4G|E|4H|1|4I]]|A|$]]|$1|1K|3|11|5|6|7|4J|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|6|7|4K|8|@]|9|@]|A|$]]|$1|1N|3|1O|5|6|7|4L|8|@$D|4M|E|4N|H|I]|$D|4O|E|4P|H|I]]|9|@]|A|$]]|$1|1P|3|1Q|5|1R|7|4Q|8|@]|9|@]|A|$]]|$1|1S|3|1T|5|6|7|4R|8|@]|9|@]|A|$]]|$1|1U|3|11|5|6|7|4S|8|@]|9|@]|A|$]]|$1|1V|3|1B|5|1C|7|4T|8|@]|9|@$D|4U|E|4V|1|4W]]|A|$]]|$1|1W|3|11|5|6|7|4X|8|@]|9|@]|A|$]]|$1|1X|3|1Y|5|6|7|4Y|8|@$D|4Z|E|50|H|I]]|9|@$D|51|E|52|1|53]]|A|$]]|$1|1Z|3|11|5|6|7|54|8|@]|9|@]|A|$]]|$1|20|3|1B|5|1C|7|55|8|@]|9|@$D|56|E|57|1|58]]|A|$]]|$1|21|3|11|5|6|7|59|8|@]|9|@]|A|$]]|$1|22|3|23|5|6|7|5A|8|@]|9|@]|A|$]]|$1|24|3|11|5|6|7|5B|8|@]|9|@]|A|$]]|$1|25|3|26|5|X|7|5C|8|@]|9|@]|A|$Y|Z]]|$1|27|3|28|5|X|7|5D|8|@]|9|@]|A|$Y|Z]]|$1|29|3|11|5|6|7|5E|8|@]|9|@]|A|$]]|$1|2A|3|-4|5|6|7|5F|8|@]|9|@]|A|$]]]|2B|$2C|$5|2D|2E|2F|A|$2G|2H]]|2I|$5|2J|2E|2K|A|$2L|2M|2N|-4]]|2O|$5|2D|2E|2F|A|$2G|2P]]|2Q|$5|2J|2E|2K|A|$2L|2R|2N|-4]]|2S|$5|2J|2E|2K|A|$2L|2T|2N|-4]]|2U|$5|2D|2E|2F|A|$2G|2V]]|2W|$5|2J|2E|2K|A|$2L|2X|2N|-4]]]]

<h2>Performance</h2>
Today 27.12.2019 I perform tests on <a href="https://en.wikipedia.org/wiki/MacOS_High_Sierra" rel="noreferrer">macOS v10.13.6</a> (High Sierra) for the chosen solutions.
Conclusions
<ul>
<li>The <code>str.replace(/abc/g, '');</code> (C) is a good cross-browser fast solution for all strings.</li>
<li>Solutions based on <code>split-join</code> (A,B) or <code>replace</code> (C,D) are fast</li>
<li>Solutions based on <code>while</code> (E,F,G,H) are slow - usually ~4 times slower for small strings and about ~3000 times (!) slower for long strings</li>
<li>The recurrence solutions (RA,RB) are slow and do not work for long strings</li>
</ul>
I also create my own solution. It looks like currently it is the shortest one which does the question job:
<pre><code>str.split`abc`.join``
</code></pre>
<div class="snippet" data-lang="js" data-hide="true" data-console="true" data-babel="false">
<div class="snippet-code snippet-currently-hidden">
<pre class="snippet-code-js lang-js prettyprint-override"><code>str = "Test abc test test abc test test test abc test test abc";
str = str.split`abc`.join``

console.log(str);</code></pre>
</div>
</div>

<h2>Details</h2>
The tests were performed on Chrome 79.0, Safari 13.0.4 and Firefox 71.0 (64 bit). The tests <code>RA</code> and <code>RB</code> use recursion. Results
<a href="https://i.stack.imgur.com/si5UK.png" rel="noreferrer"><img src="https://i.stack.imgur.com/si5UK.png" alt="Enter image description here" /></a>
<h2>Short string - 55 characters</h2>
You can run tests on your machine <a href="https://jsperf.com/remove-substring-small/1" rel="noreferrer">HERE</a>. Results for Chrome:
<a href="https://i.stack.imgur.com/Ctf18.png" rel="noreferrer"><img src="https://i.stack.imgur.com/Ctf18.png" alt="Enter image description here" /></a>
<h2>Long string: 275 000 characters</h2>
The recursive solutions RA and RB gives
<blockquote>
RangeError: Maximum call stack size exceeded
</blockquote>
For 1M characters they even break Chrome
<a href="https://i.stack.imgur.com/dNkYp.png" rel="noreferrer"><img src="https://i.stack.imgur.com/dNkYp.png" alt="enter image description here" /></a>
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 <a href="https://jsperf.com/remove-substring-big/1" rel="noreferrer">HERE</a>. Results for Chrome
<a href="https://i.stack.imgur.com/0uEgk.png" rel="noreferrer"><img src="https://i.stack.imgur.com/0uEgk.png" alt="enter image description here" /></a>
Code used in tests
<div class="snippet" data-lang="js" data-hide="true" data-console="true" data-babel="false">
<div class="snippet-code snippet-currently-hidden">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var t="Test abc test test abc test test test abc test test abc"; // .repeat(5000)
var log = (version,result) =&gt; 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://stackoverflow.com/a/56989553/860099
function H(str)
{
 let i = -1
 let find = 'abc';
 let newToken = '';

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

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

// src: https://stackoverflow.com/a/22870785/860099
function RA(string, prevstring) {
 var omit = 'abc';
 var place = '';
 if (prevstring &amp;&amp; string === prevstring)
 return string;
 prevstring = string.replace(omit, place);
 return RA(prevstring, string)
}

// src: https://stackoverflow.com/a/26107132/860099
function RB(str) {
 var find = 'abc';
 var replace = '';
 var i = str.indexOf(find);
 if (i &gt; -1){
 str = str.replace(find, replace);
 i = i + replace.length;
 var st2 = str.substring(i);
 if(st2.indexOf(find) &gt; -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</code></pre>
<pre class="snippet-code-html lang-html prettyprint-override"><code>&lt;p style="color:red"&gt;This snippet only presents codes used in tests. It not perform test itself!&lt;p&gt;</code></pre>
</div>
</div>

blocks|key|867096|text|我们可以在替换中使用JavaScript方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|867097|var+result+=+yourString.replace('regexPattern',+"replaceString");|code-block|syntax|javascript|867098|​|867099|var+str+=+"Test+abc+test+test+abc+test+test+test+abc+test+test+abc";

var+expectedString+=+str.replace(/abc(\s%7C$)/g,+"");

console.log(expectedString);|867100|867101|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace^0|5|2|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|10|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|11|8|@]|9|@]|C|$G|H]]|$1|M|3|J|5|6|7|12|8|@]|9|@]|C|$]]|$1|N|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|O|$P|$5|Q|R|S|C|$T|U]]]]

We can use the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace" rel="nofollow noreferrer">replace</a> method in JavaScript:
<pre><code>var result = yourString.replace('regexPattern', &quot;replaceString&quot;);
</code></pre>
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var str = "Test abc test test abc test test test abc test test abc";

var expectedString = str.replace(/abc(\s|$)/g, "");

console.log(expectedString);</code></pre>
</div>
</div>

blocks|key|965035|text|我知道这不是最好的方法，但你可以试试：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|965036|var+annoyingString+=+"Test+abc+test+test+abc+test+test+test+abc+test+test+abc";

while+(annoyingString.includes("abc"))+{
++++annoyingString+=+annoyingString.replace("abc",+"")
}|code-block|syntax|javascript|965037|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I know this isn’t the best way to do this, but you can try this:
<pre><code>var annoyingString = &quot;Test abc test test abc test test test abc test test abc&quot;;

while (annoyingString.includes(&quot;abc&quot;)) {
 annoyingString = annoyingString.replace(&quot;abc&quot;, &quot;&quot;)
}
</code></pre>

blocks|key|867164|text|我在“库”部分中将下面的功能添加到此性能测试页面：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|867165|https://jsben.ch/LFfWA|offset|length|867166|function+_replace(t,+s,+r){
++++var+i+=+t.indexOf(s);
++++if+(i+==+-1)+return+t;
++++return+t.slice(0,+i)+%2B+r+%2B+_replace(t.slice(i+%2B+s.length,+t.length),+s,r);
}|code-block|syntax|javascript|867167|..and将此作为测试：|867168|var+replaced+=+_replace(testString,+'abc',+'123');|867169|。。对我来说，这个功能比拆分或正则表达式快34%25。这个想法/希望最终是将越来越小的字符串粘贴到堆栈上，然后通过展开堆栈来构建整个结果，从而减少对相同字符串数据的额外字符串复制和额外搜索，并希望优化CPU缓存的使用。|867170|部分想法是，如果字符串不是太大，它可能会在CPU缓存中结束；传递它并粘贴其中的部分将这些位放入缓存中，然后搜索可以完全使用CPU缓存的数据。现在，不管这是否真的是最终发生的事情，我确信完全依赖于JavaScript实现。|867171|这并不是尽可能快，但是如果没有可变的字符串，它就会尽可能快。JavaScript中的数组可能为每个元素都有一个指针，因此，涉及大量数组元素的解决方案不太可能像这样友好地使用CPU缓存。|867172|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|M|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@$D|13|E|14|1|15]]|A|$]]|$1|F|3|G|5|H|7|16|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|17|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|18|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|19|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1A|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1B|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|C]]]]

I added the function below to this performance test page in the &quot;library&quot; section:
<a href="https://jsben.ch/LFfWA" rel="nofollow noreferrer">https://jsben.ch/LFfWA</a>
<pre><code>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);
}
</code></pre>
..and put this in as the test:
<pre><code>var replaced = _replace(testString, 'abc', '123');
</code></pre>
.. 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.

blocks|key|964416|text|从v85开始，Chrome现在本地支持String.prototype.replaceAll。注意，这比所有其他建议的解决方案都要好，并且应该使用一次主要支持的解决方案。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|964417|特征状态：https://chromestatus.com/feature/6040389083463680|964418|​|964419|var+s+=+"hello+hello+world";
s+=+s.replaceAll("hello",+"");+//+s+is+now+"world"
console.log(s)|code-block|syntax|javascript|964420|964421|entityMap|0|LINK|mutability|MUTABLE|url|https://chromestatus.com/feature/6040389083463680^0|J|R|0|5|1D|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@$9|11|A|12|1|13]]|E|$]]|$1|H|3|I|5|6|7|14|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|15|8|@]|D|@]|E|$M|N]]|$1|O|3|I|5|6|7|16|8|@]|D|@]|E|$]]|$1|P|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|Q|$R|$5|S|T|U|E|$V|W]]]]

Starting from v85, Chrome now supports <code>String.prototype.replaceAll</code> natively. Note this outperform all other proposed solutions and should be used once majorly supported.
Feature status:
<a href="https://chromestatus.com/feature/6040389083463680" rel="nofollow noreferrer">https://chromestatus.com/feature/6040389083463680</a>
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var s = "hello hello world";
s = s.replaceAll("hello", ""); // s is now "world"
console.log(s)</code></pre>
</div>
</div>

blocks|key|867203|text|这里有一个非常简单的解决方案。可以将新方法分配给String对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|867204|String.prototype.replaceAll+=+function(search,+replace){
+++return+this.replace(new+RegExp(search,+'g'),+replace)
}

var+str+=+"Test+abc+test+test+abc+test+test+test+abc+test+test+abc";
str+=+str.replaceAll('abc',+'');

console.log(str)+//+->+Test++test+test++test+test+test++test+test|code-block|syntax|javascript|867205|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a very simple solution.
You can assign a new method to a String object
<pre><code>String.prototype.replaceAll = function(search, replace){
 return this.replace(new RegExp(search, 'g'), replace)
}

var str = &quot;Test abc test test abc test test test abc test test abc&quot;;
str = str.replaceAll('abc', '');

console.log(str) // -&gt; Test test test test test test test test
</code></pre>

blocks|key|964462|text|使用拆分和加入|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|964463|​|964464|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);|code-block|syntax|javascript|964465|964466|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join|1|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace^0|2|2|0|5|2|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]|$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|K|3|E|5|6|7|14|8|@]|9|@]|C|$]]|$1|L|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|M|$N|$5|O|P|Q|C|$R|S]]|T|$5|O|P|Q|C|$R|U]]]]

Use <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join" rel="nofollow noreferrer">split</a> and <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace" rel="nofollow noreferrer">join</a>:
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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);</code></pre>
</div>
</div>

blocks|key|964482|text|我建议为string类添加一个全局方法，方法是将它附加到原型链中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|964483|String.prototype.replaceAll+=+function(fromReplace,+toReplace,+{ignoreCasing}+=+{})+{+return+this.replace(new+RegExp(fromReplace,+ignoreCasing+?+'ig':+'g'),+toReplace);}|code-block|syntax|javascript|964484|它可以用来：|964485|'stringwithpattern'.replaceAll('pattern',+'new-pattern')|964486|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I would suggest adding a global method for the string class by appending it to the prototype chain.
<pre><code>String.prototype.replaceAll = function(fromReplace, toReplace, {ignoreCasing} = {}) { return this.replace(new RegExp(fromReplace, ignoreCasing ? 'ig': 'g'), toReplace);}
</code></pre>
And it can be used like:
<pre><code>'stringwithpattern'.replaceAll('pattern', 'new-pattern')
</code></pre>

blocks|key|867322|text|于2020年8月|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|867323|不再有正则表达式了|blockquote|867324|​|867325|const+str+=+"Test+abc+test+test+abc+test+test+test+abc+test+test+abc";
const+modifiedStr+=+str.replaceAll('abc',+'');
console.log(modifiedStr);|code-block|syntax|javascript|867326|867327|对象/字符串/替换所有|867328|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll^0|0|8|0|0|0|0|0|0|B|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$]]|$1|I|3|J|5|6|7|14|8|@]|D|@]|E|$]]|$1|K|3|L|5|M|7|15|8|@]|D|@]|E|$N|O]]|$1|P|3|J|5|6|7|16|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|17|8|@]|D|@$9|18|A|19|1|1A]]|E|$]]|$1|S|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

In August 2020
<blockquote>
No more regular expression stuff
</blockquote>
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const str = "Test abc test test abc test test test abc test test abc";
const modifiedStr = str.replaceAll('abc', '');
console.log(modifiedStr);</code></pre>
</div>
</div>

<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll" rel="nofollow noreferrer">https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll</a>

blocks|key|867374|text|该解决方案结合了以前的一些答案，并且更符合拟议的2020年8月标准解决方案。到2020年9月，这个解决方案对我来说仍然是可行的，因为在我使用的String.replaceAll二进制文件中没有可用的Node.js。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|867375|RegExp.escape是一个单独的需要处理的问题，但在这里很重要，因为官方提出的解决方案将自动避开string-based+find输入。如果没有String.replaceAll逻辑，此RegExp.escape填充将不会。|867376|我添加了一个不填充RegExp.Escape的答案，如果你不想那样做的话。|867377|如果将正则表达式传递给find，则必须将包含g作为标志。这个聚脂填充不会为您提供一个很好的TypeError，并且会给您带来一个非常糟糕的时间。|BOLD|867378|如果您需要精确的标准一致性，对于严格依赖标准实现的应用程序，那么我建议您每次使用巴贝尔或其他工具来获得“正确的答案”，而不是堆栈溢出。这样你就不会有任何惊喜了。|867379|代码：|867380|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(/[.*%2B\-?%5E${}()%7C[\]\\]/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-block|syntax|javascript|867381|编码，缩小：|867382|Object.prototype.hasOwnProperty.call(RegExp,"escape")%7C%7C(RegExp.escape=function(e){return+e.replace(/[.*%2B\-?%5E${}()%7C[\]\\]/g,"\\$&")}),Object.prototype.hasOwnProperty.call(String,"replaceAll")%7C%7C(String.prototype.replaceAll=function(e,t){return+this.replace("[object+RegExp]"==Object.prototype.toString.call(e)?e:new+RegExp(RegExp.escape(e),"g"),t)});|867383|示例：|867384|console.log(
++'t*.STVAL'
++++.replaceAll(
++++++new+RegExp(RegExp.escape('T*.ST'),+'ig'),
++++++'TEST'
++++)
);

console.log(
++'t*.STVAL'
++++.replaceAll(
++++++'t*.ST',
++++++'TEST'
++++);
);|867385|没有RegExp.Escape的代码|867386|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(/[.*%2B\-?%5E${}()%7C[\]\\]/g,+'\\$&'),+'g'),
++++++++++replace
++++++++);
++}
}|867387|没有RegExp.Escape的代码，缩小如下：|867388|Object.prototype.hasOwnProperty.call(String,"replaceAll")%7C%7C(String.prototype.replaceAll=function(e,t){return+this.replace("[object+RegExp]"==Object.prototype.toString.call(e)?e:new+RegExp(e.replace(/[.*%2B\-?%5E${}()%7C[\]\\]/g,"\\$&"),"g"),t)});|867389|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Polyfill_(programming)|1|https://en.wikipedia.org/wiki/Babel_(transcompiler)^0|1Z|H|0|0|D|1F|6|1S|4|23|H|2O|D|0|9|D|0|B|4|M|1|H|3|U|4|0|0|14|3|1|0|0|0|0|0|0|0|2|D|0|0|2|D|0|0^^$0|@$1|2|3|4|5|6|7|1L|8|@$9|1M|A|1N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1O|8|@$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1Z|8|@$9|20|A|21|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|22|8|@$9|23|A|24|B|C]|$9|25|A|26|B|C]|$9|27|A|28|B|L]]|D|@$9|29|A|2A|1|2B]]|E|$]]|$1|M|3|N|5|6|7|2C|8|@]|D|@$9|2D|A|2E|1|2F]]|E|$]]|$1|O|3|P|5|6|7|2G|8|@]|D|@]|E|$]]|$1|Q|3|R|5|S|7|2H|8|@]|D|@]|E|$T|U]]|$1|V|3|W|5|6|7|2I|8|@]|D|@]|E|$]]|$1|X|3|Y|5|S|7|2J|8|@]|D|@]|E|$T|U]]|$1|Z|3|10|5|6|7|2K|8|@]|D|@]|E|$]]|$1|11|3|12|5|S|7|2L|8|@]|D|@]|E|$T|U]]|$1|13|3|14|5|6|7|2M|8|@$9|2N|A|2O|B|C]]|D|@]|E|$]]|$1|15|3|16|5|S|7|2P|8|@]|D|@]|E|$T|U]]|$1|17|3|18|5|6|7|2Q|8|@$9|2R|A|2S|B|C]]|D|@]|E|$]]|$1|19|3|1A|5|S|7|2T|8|@]|D|@]|E|$T|U]]|$1|1B|3|-4|5|6|7|2U|8|@]|D|@]|E|$]]]|1C|$1D|$5|1E|1F|1G|E|$1H|1I]]|1J|$5|1E|1F|1G|E|$1H|1K]]]]

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 <code>String.replaceAll</code> is not available in the Node.js binary I am using.
<hr />
<code>RegExp.escape</code> is a separate issue to deal with, but it is important here, because the official proposed solution will automatically escape <code>string</code>-based <code>find</code> input. This <code>String.replaceAll</code> polyfill would not without the <code>RegExp.escape</code> logic.
I have added an answer which doesn't polyfill <code>RegExp.Escape</code>, in the case that you don't want that.
<hr />
If you pass a regular expression to <code>find</code>, you must include <code>g</code> as a flag. This <a href="https://en.wikipedia.org/wiki/Polyfill_(programming)" rel="nofollow noreferrer">polyfill</a> 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 <a href="https://en.wikipedia.org/wiki/Babel_(transcompiler)" rel="nofollow noreferrer">Babel</a> or some other tool to get you the 'right answer' every time instead of Stack Overflow. That way you won't have any surprises.
<hr />
Code:
<pre><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, '\\$&amp;'); // $&amp; 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: &quot;replaceAll must be called with a global RegExp&quot; 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 &quot;special replacement patterns&quot; when &quot;Specifying a string as a parameter&quot; for replace
 // Does not conform to &quot;Specifying a function as a parameter&quot; for replace
 return this.replace(
 Object.prototype.toString.call(find) == '[object RegExp]' ?
 find :
 new RegExp(RegExp.escape(find), 'g'),
 replace
 );
 }
}
</code></pre>
Code, Minified:
<pre><code>Object.prototype.hasOwnProperty.call(RegExp,&quot;escape&quot;)||(RegExp.escape=function(e){return e.replace(/[.*+\-?^${}()|[\]\\]/g,&quot;\\$&amp;&quot;)}),Object.prototype.hasOwnProperty.call(String,&quot;replaceAll&quot;)||(String.prototype.replaceAll=function(e,t){return this.replace(&quot;[object RegExp]&quot;==Object.prototype.toString.call(e)?e:new RegExp(RegExp.escape(e),&quot;g&quot;),t)});
</code></pre>
<hr />
Example:
<pre><code>console.log(
 't*.STVAL'
 .replaceAll(
 new RegExp(RegExp.escape('T*.ST'), 'ig'),
 'TEST'
 )
);

console.log(
 't*.STVAL'
 .replaceAll(
 't*.ST',
 'TEST'
 );
);
</code></pre>
<hr />
Code without <code>RegExp.Escape</code>:
<pre><code>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: &quot;replaceAll must be called with a global RegExp&quot; 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 &quot;special replacement patterns&quot; when &quot;Specifying a string as a parameter&quot; for replace
 // Does not conform to &quot;Specifying a function as a parameter&quot; for replace
 return this.replace(
 Object.prototype.toString.call(find) == '[object RegExp]' ?
 find :
 new RegExp(find.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&amp;'), 'g'),
 replace
 );
 }
}
</code></pre>
Code without <code>RegExp.Escape</code>, Minified:
<pre><code>Object.prototype.hasOwnProperty.call(String,&quot;replaceAll&quot;)||(String.prototype.replaceAll=function(e,t){return this.replace(&quot;[object RegExp]&quot;==Object.prototype.toString.call(e)?e:new RegExp(e.replace(/[.*+\-?^${}()|[\]\\]/g,&quot;\\$&amp;&quot;),&quot;g&quot;),t)});
</code></pre>

blocks|key|2393083|text|有一种方法可以使用新的replaceAll()方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2393084|但您需要使用最先进的浏览器或JavaScript运行时环境。|2393085|您可以在这里中检查浏览器的兼容性。|2393086|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll^0|B|C|0|0|4|2|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|V|8|@]|D|@$9|W|A|X|1|Y]]|E|$]]|$1|J|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]]]

There is a way to use the new <code>replaceAll()</code> method.
But you need to use a cutting-edge browser or a JavaScript run time environment.
You can check the browser compatibility in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll" rel="nofollow noreferrer">here</a>.

blocks|key|867450|text|JavaScript提供了一种将字符串的一部分替换为另一个字符串的直接方法，还有一些技巧可以帮助您做到这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|867451|若要替换所有出现的事件，可以在replace()或replaceAll方法中使用JavaScript。|offset|length|style|CODE|867452|replace()+method+-要替换使用此方法的所有元素，请使用正则表达式作为模式，查找匹配的字符串，然后用新字符串替换它。请考虑在其中使用/g标志。|ordered-list-item|867453|​|867454|const+str+=+"To+do+or+not+to+do";
const+pattern+=+/do/g;
const+replaceBy+=+"Code";
console.log(str.replace(pattern,+replaceBy));|code-block|syntax|javascript|867455|867456|replaceAll()+method+-要替换使用此方法的所有元素，可以使用字符串或正则表达式作为模式来查找匹配的字符串，然后用新的字符串替换它。我们必须在/g方法中使用带有正则表达式的replaceAll标志。|867457|867458|const+str+=+"To+do+or+not+to+do";
const+pattern+=+"do";
const+replaceBy+=+"Code";
console.log(str.replaceAll(pattern,+replaceBy));

const+pattern2+=+/do/g;
console.log(str.replaceAll(pattern2,+replaceBy));|867459|867460|交替方法:通过使用拆分和连接方法|BOLD|867461|使用新字符串作为分隔符，在要替换的字符串处拆分字符串并将其加入。看这个例子。|867462|867463|const+str+=+"To+do+or+not+to+do";
const+newStr+=+str.split("do").join("Code");
console.log(newStr);|867464|867465|entityMap^0|0|F|9|P|A|0|0|G|21|2|0|0|0|0|0|J|27|2|0|0|0|0|0|G|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1A|8|@$D|1B|E|1C|F|G]|$D|1D|E|1E|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|1F|8|@$D|1G|E|1H|F|G]|$D|1I|E|1J|F|G]]|9|@]|A|$]]|$1|K|3|L|5|6|7|1K|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|1L|8|@]|9|@]|A|$P|Q]]|$1|R|3|L|5|6|7|1M|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|1N|8|@$D|1O|E|1P|F|G]|$D|1Q|E|1R|F|G]]|9|@]|A|$]]|$1|U|3|L|5|6|7|1S|8|@]|9|@]|A|$]]|$1|V|3|W|5|O|7|1T|8|@]|9|@]|A|$P|Q]]|$1|X|3|L|5|6|7|1U|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1V|8|@$D|1W|E|1X|F|10]]|9|@]|A|$]]|$1|11|3|12|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|13|3|L|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|14|3|15|5|O|7|20|8|@]|9|@]|A|$P|Q]]|$1|16|3|L|5|6|7|21|8|@]|9|@]|A|$]]|$1|17|3|-4|5|6|7|22|8|@]|9|@]|A|$]]]|18|$]]

JavaScript provides a direct way to replace a part of a string with another string and there are some tricks also by which you can do this.
To replace all the occurrences you can use <code>replace()</code> or <code>replaceAll</code> method in JavaScript.
<ol>
<li><code>replace() method</code> - To replace all elements using this method use a regular expression as a pattern to find the matching string and then replace it with a new string. Please consider using the <code>/g</code> flag with it.</li>
</ol>
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const str = "To do or not to do";
const pattern = /do/g;
const replaceBy = "Code";
console.log(str.replace(pattern, replaceBy));</code></pre>
</div>
</div>

<ol start="2">
<li><code>replaceAll() method</code> - To replace all elements using this method, use either a string or regular expression as a pattern to find the matching string and then replace it with a new string. We must use the <code>/g</code> flag with a regular expression in the replaceAll method.</li>
</ol>
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const str = "To do or not to do";
const pattern = "do";
const replaceBy = "Code";
console.log(str.replaceAll(pattern, replaceBy));

const pattern2 = /do/g;
console.log(str.replaceAll(pattern2, replaceBy));</code></pre>
</div>
</div>

Alternate method: By using split and join method
Split the string at what you want to replace and join by using the new string as a separator. See the example.
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const str = "To do or not to do";
const newStr = str.split("do").join("Code");
console.log(newStr);</code></pre>
</div>
</div>

blocks|key|965223|text|//+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);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|965224|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>// Try this way

const str = &quot;Test abc test test abc test test test abc test test abc&quot;;
const result = str.split('abc').join('');
console.log(result);
</code></pre>

blocks|key|867482|text|使用正则表达式i标志表示大小写不敏感的|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|867483|console.log('App+started'.replace(/a/g,+''))+//+Result:+"App+strted"
console.log('App+started'.replace(/a/gi,+''))+//+Result:+"pp+strted"|code-block|syntax|javascript|867484|entityMap^0|7|1|C|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

With the regular expression i flag for case insensitive
<pre><code>console.log('App started'.replace(/a/g, '')) // Result: &quot;App strted&quot;
console.log('App started'.replace(/a/gi, '')) // Result: &quot;pp strted&quot;
</code></pre>

blocks|key|964564|text|经过几次试验和许多失败后，我发现在浏览器兼容性和易用性方面，下面的功能似乎是最好的全方位功能。这是我找到的唯一适用于旧浏览器的解决方案。(是的，即使旧浏览器被劝阻和过时，一些遗留应用程序仍然大量使用奥莱浏览器(例如旧的Visual+Basic+6应用程序或带有窗体的Excel+.xlsm宏)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|964565|总之，这是一个简单的函数。|964566|function+replaceAll(str,+match,+replacement){
+++return+str.split(match).join(replacement);
}|code-block|syntax|javascript|964567|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/OLE_Automation|1|https://en.wikipedia.org/wiki/Visual_Basic#Timeline|2|https://en.wikipedia.org/wiki/Microsoft_Excel^0|2R|2|0|31|E|1|3P|5|2|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]|$A|10|B|11|1|12]|$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|17|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|18|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]|U|$5|N|O|P|C|$Q|V]]]]

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 <a href="https://en.wikipedia.org/wiki/OLE_Automation" rel="nofollow noreferrer">OLE</a> browsers (such as old <a href="https://en.wikipedia.org/wiki/Visual_Basic#Timeline" rel="nofollow noreferrer">Visual Basic 6</a> applications or <a href="https://en.wikipedia.org/wiki/Microsoft_Excel" rel="nofollow noreferrer">Excel</a> .xlsm macros with forms.)
Anyway, here's the simple function.
<pre><code>function replaceAll(str, match, replacement){
 return str.split(match).join(replacement);
}
</code></pre>

blocks|key|867532|text|重复，直到你把它们全部替换掉：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|867533|const+regex+=+/%5E>.*/im;
while+(regex.test(cadena))+{
++++cadena+=+cadena.replace(regex,+'*');
}|code-block|syntax|javascript|867534|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Repeat until you have replaced them all:
<pre><code>const regex = /^&gt;.*/im;
while (regex.test(cadena)) {
 cadena = cadena.replace(regex, '*');
}
</code></pre>

blocks|key|964592|text|String.prototype.replaceAll+-+ECMAScript+2021|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|964593|新的String.prototype.replaceAll()方法返回一个新字符串，所有匹配的模式都被替换。模式可以是字符串，也可以是RegExp，替换可以是字符串，也可以是要为每个匹配调用的函数。|964594|​|964595|const+message+=+'dog+barks+meow+meow';
const+messageFormatted+=+message.replaceAll('meow',+'woof')

console.log(messageFormatted);|code-block|syntax|javascript|964596|964597|entityMap^0|0|R|U|F|0|R|0|2|T|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|Z|8|@$9|10|A|11|B|D]]|E|@]|F|$]]|$1|I|3|J|5|6|7|12|8|@]|E|@]|F|$]]|$1|K|3|L|5|M|7|13|8|@]|E|@]|F|$N|O]]|$1|P|3|J|5|6|7|14|8|@]|E|@]|F|$]]|$1|Q|3|-4|5|6|7|15|8|@]|E|@]|F|$]]]|R|$]]

<code>String.prototype.replaceAll</code> - ECMAScript 2021
The new <code>String.prototype.replaceAll()</code> method returns a new string with all matches of a pattern replaced by a replacement. The pattern can be either a string or a RegExp, and the replacement can be either a string or a function to be called for each match.
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const message = 'dog barks meow meow';
const messageFormatted = message.replaceAll('meow', 'woof')

console.log(messageFormatted);</code></pre>
</div>
</div>

blocks|key|2393256|text|我读过这个问题和答案，但我没有找到合适的解决办法。虽然答案非常有用，但我决定从头开始创建自己的解决方案。这种替换的问题是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2393257|通常，仅仅找到一个与大小写匹配的字符串是不够的。例如，对于搜索结果，我需要将其替换为相同的情况。|unordered-list-item|offset|length|style|BOLD|2393258|如果我处理innerHTML，我可以很容易地损坏HTML标记(例如，hr出现在href属性中)。|2393259|对于许多用例来说，replaceAll()方法太新鲜了，而且它并不能解决所有问题。|2393260|因此，我编写了一些函数来突出显示表中的搜索结果，其中表格数据单元格中可能有链接，还有其他HTML标记。而且这些链接是要保留的，所以innerText是不够的。|2393261|我决定为每个有相同问题的人提供解决方案。当然，您不仅可以将其用于表，还可以用于任何元素。以下是代码：|2393262|/*+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">',+'');
++++}
++}
}

/*+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+%2B+1))+!=+-1)+{
++++if+(insideTag(i,+srcStr))+continue;
++++srcStr+=+srcStr.slice(0,+i)+%2B+before+%2B+srcStr.slice(i,+i%2Bflen)+%2B+after+%2B+srcStr.slice(i%2Bflen);
++++lowStr+=+srcStr.toLowerCase();
++++i+%2B=+before.length+%2B+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%2B%2B)+{
++++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);
}|code-block|syntax|javascript|2393263|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll^0|0|11|A|0|Y|2|13|4|0|9|C|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|14|8|@$E|15|F|16|G|H]]|9|@]|A|$]]|$1|I|3|J|5|D|7|17|8|@$E|18|F|19|G|H]|$E|1A|F|1B|G|H]]|9|@]|A|$]]|$1|K|3|L|5|D|7|1C|8|@]|9|@$E|1D|F|1E|1|1F]]|A|$]]|$1|M|3|N|5|6|7|1G|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1H|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1I|8|@]|9|@]|A|$T|U]]|$1|V|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|W|$X|$5|Y|Z|10|A|$11|12]]]]

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:
<ul>
<li>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.</li>
<li>If I deal with innerHTML, I can easily damage HTML tags (e.g., an occurrence of hr in the href attribute).</li>
<li>The <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll" rel="nofollow noreferrer">replaceAll()</a> method is too fresh for many use cases, and it doesn't solve all the issues.</li>
</ul>
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:
<pre><code>/* Iterate over table data cells to insert a highlight tag */
function highlightSearchResults(textFilter) {
 textFilter = textFilter.toLowerCase().replace('&lt;', '&amp;lt;').replace('&gt;', '&amp;gt;');
 let tds;
 tb = document.getElementById('sometable'); //root element where to search
 if (tb) {
 tds = tb.getElementsByTagName(&quot;td&quot;); //sub-elements where to make replacements
 }
 if (textFilter &amp;&amp; tds) {
 for (td of tds) {
 //specify your span class or whatever you need before and after
 td.innerHTML = insertCaseInsensitive(td.innerHTML, textFilter, '&lt;span class=&quot;highlight&quot;&gt;', '&lt;/span&gt;');
 }
 }
}

/* 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 &lt; s.length; i++) {
 if (s[i] == &quot;&lt;&quot;) {
 break;
 }
 if (s[i] == &quot;&gt;&quot;) {
 ahead = true;
 break;
 }
 }
 for (let i = si; i &gt;= 0; i--) {
 if (s[i] == &quot;&gt;&quot;) {
 break;
 }
 if (s[i] == &quot;&lt;&quot;) {
 back = true;
 break;
 }
 }
 return (ahead &amp;&amp; back);
}
</code></pre>

blocks|key|867645|text|当然，在2021中，正确的答案是：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|867646|String.prototype.replaceAll()|867647|​|867648|console.log(
++'Change+this+and+this+for+me'.replaceAll('this','that')+//+Normal+case
);
console.log(
++'aaaaaa'.replaceAll('aa','a')+//+Challenged+case
);|code-block|syntax|javascript|867649|867650|如果您不想处理替换()+%2B+RegExp。|867651|，但如果浏览器是从2020年以前开始的呢？|867652|在这种情况下，我们需要聚脂填充+(强迫旧的浏览器支持新特性)(我认为几年后是必要的)。我在答案上找不到完全正确的方法。因此，我建议这个函数，将定义为一个多填充。|867653|我建议的replaceAll填充选项：|CODE|867654|replaceAll填充(带有全局标志错误)(更有原则的版本)|867655|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(/[.%5E$*%2B?()[{%7C\\]/g,+"\\$&"),+"g"),+//+Replace+all+reserved+characters+with+'\'+then+make+a+global+'g'+RegExp
++++++++++++++++replace);+//+passing+second+argument
++++++++}
++++});
}|867656|replaceAll填充(其本身缺少全局标志)(我的首选)-+为什么？|867657|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]+%2B+'g')+//+If+not,+make+a+global+clone+from+the+RegEx
++++++++++++++++++++:+RegExp(String(search).replace(/[.%5E$*%2B?()[{%7C\\]/g,+"\\$&"),+"g"),+//+Replace+all+reserved+characters+with+'\'+then+make+a+global+'g'+RegExp
++++++++++++++++replace);+//+passing+second+argument
++++++++}
++++});
}|867658|缩小(我的第一偏好)：|867659|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]%2B'g'):RegExp(String(search).replace(/[.%5E$*%2B?()[{%7C\\]/g,"\\$&"),"g"),replace)}})}|867660|试一试：|867661|867662|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]%2B'g'):RegExp(String(search).replace(/[.%5E$*%2B?()[{%7C\\]/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%2B/g,'***')
);+//+Here+is+some+numbers+***+***+***+and+need+to+be+replaced.

console.log(
++'Remove+numbers+under+233:+236+++229++711+++200+++5'.replaceAll(/\d%2B/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|867663|867664|浏览器支持：|867665|Internet+Explorer+9和后来(基于Internet+Explorer+11)。|unordered-list-item|867666|所有其他浏览器(2012年后)。|867667|如果第一个参数输入为：、undefined、Object、Function、Date、.、RegExp、Number、String、.|867668|参考：https://tc39.es/ecma262/#sec-string.prototype.replaceall+%2B+https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/RegExp#syntax|867669|重要注意事项:正如一些专业人士提到的那样，许多在答案中建议的递归函数都会返回错误的结果。(用上述片段的被质疑案例来尝试它们。)也许一些棘手的方法，如.split('searchValue').join('replaceValue')或一些管理良好的函数，也会得到同样的结果，但性能肯定比native+replaceAll()+/+polyfill+replaceAll()+/+replace()+%2B+RegExp低得多。|867670|其他填土分配方法|867671|天真，但支持甚至更旧的浏览器(最好避免)|867672|例如，我们也可以通过不使用IE7%2B和使用我以前天真的赋值方法来支持Object.defineProperty()：|867673|if+(!String.prototype.replaceAll)+{
++++String.prototype.replaceAll+=+function(search,+replace)+{+//+<--+Naive+method+for+assignment
++++++++//+...+(Polyfill+code+Here)
++++}
}|867674|对于IE7%2B上的基本用途，它应该工作得很好。|867675|但是作为这里+@sebastian-simon解释了，这可以在更高级的使用情况下产生次要的问题。例如：|867676|for+(var+k+in+'hi')+console.log(k);
//+0
//+1
//+replaceAll++<--+?|867677|完全可信赖，但重|867678|事实上，我建议的方案有点乐观。就像我们信任环境(浏览器和Node.js)一样，它肯定是在2012-2021年左右。这也是一个标准的/著名的，所以它不需要任何特殊的考虑。|867679|但是，可能会出现更旧的浏览器或一些意想不到的问题，而polyfills仍然可以支持和解决更多可能的环境问题。因此，如果我们需要最大限度的支持，我们可以使用如下的多填充库：|867680|https://polyfill.io/|867681|专为replaceAll服务|867682|<script+src="https://polyfill.io/v3/polyfill.min.js?features=String.prototype.replaceAll"></script>|867683|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll|1|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace|2|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp|3|https://w3ctag.github.io/polyfills/|4|https://github.com/tc39/proposal-string-replaceall/issues/16|5|https://en.wikipedia.org/wiki/Internet_Explorer_9|6|https://en.wikipedia.org/wiki/Internet_Explorer_11#Internet_Explorer_11|7|https://tc39.es/ecma262/#sec-string.prototype.replaceall|8|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/RegExp#syntax|9|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty|10|https://stackoverflow.com/a/46491279/7514010|11|https://en.wikipedia.org/wiki/Node.js|12^0|4|4|0|0|T|0|0|0|0|0|7|4|1|E|6|2|0|0|L|0|B|4|3|0|4|A|0|0|A|0|0|0|A|V|4|4|0|0|0|0|0|0|0|0|0|0|J|5|P|K|6|0|0|B|1K|C|9|M|6|T|8|12|4|19|6|1G|6|1N|6|0|0|4J|3|1K|7|1Q|2T|8|0|0|5V|22|16|3Z|J|4L|L|59|I|0|0|8|0|0|K|0|0|1L|X|N|9|0|0|0|M|0|0|1F|4|2|A|0|0|0|8|0|0|2C|S|7|B|0|0|2D|0|0|K|0|K|C|0|0|E|0|0^^$0|@$1|2|3|4|5|6|7|3E|8|@$9|3F|A|3G|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|3H|8|@]|D|@$9|3I|A|3J|1|3K]]|E|$]]|$1|H|3|I|5|6|7|3L|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|3M|8|@]|D|@]|E|$M|N]]|$1|O|3|I|5|6|7|3N|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|3O|8|@]|D|@$9|3P|A|3Q|1|3R]|$9|3S|A|3T|1|3U]]|E|$]]|$1|R|3|S|5|6|7|3V|8|@$9|3W|A|3X|B|C]]|D|@]|E|$]]|$1|T|3|U|5|6|7|3Y|8|@]|D|@$9|3Z|A|40|1|41]]|E|$]]|$1|V|3|W|5|6|7|42|8|@$9|43|A|44|B|X]]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|45|8|@$9|46|A|47|B|X]]|D|@]|E|$]]|$1|10|3|11|5|L|7|48|8|@]|D|@]|E|$M|N]]|$1|12|3|13|5|6|7|49|8|@$9|4A|A|4B|B|X]]|D|@$9|4C|A|4D|1|4E]]|E|$]]|$1|14|3|15|5|L|7|4F|8|@]|D|@]|E|$M|N]]|$1|16|3|17|5|6|7|4G|8|@]|D|@]|E|$]]|$1|18|3|19|5|L|7|4H|8|@]|D|@]|E|$M|N]]|$1|1A|3|1B|5|6|7|4I|8|@]|D|@]|E|$]]|$1|1C|3|I|5|6|7|4J|8|@]|D|@]|E|$]]|$1|1D|3|1E|5|L|7|4K|8|@]|D|@]|E|$M|N]]|$1|1F|3|I|5|6|7|4L|8|@]|D|@]|E|$]]|$1|1G|3|1H|5|6|7|4M|8|@]|D|@]|E|$]]|$1|1I|3|1J|5|1K|7|4N|8|@]|D|@$9|4O|A|4P|1|4Q]|$9|4R|A|4S|1|4T]]|E|$]]|$1|1L|3|1M|5|1K|7|4U|8|@]|D|@]|E|$]]|$1|1N|3|1O|5|6|7|4V|8|@$9|4W|A|4X|B|C]|$9|4Y|A|4Z|B|X]|$9|50|A|51|B|X]|$9|52|A|53|B|X]|$9|54|A|55|B|X]|$9|56|A|57|B|X]|$9|58|A|59|B|X]|$9|5A|A|5B|B|X]]|D|@]|E|$]]|$1|1P|3|1Q|5|6|7|5C|8|@$9|5D|A|5E|B|C]]|D|@$9|5F|A|5G|1|5H]|$9|5I|A|5J|1|5K]]|E|$]]|$1|1R|3|1S|5|6|7|5L|8|@$9|5M|A|5N|B|C]|$9|5O|A|5P|B|X]|$9|5Q|A|5R|B|X]|$9|5S|A|5T|B|X]|$9|5U|A|5V|B|X]]|D|@]|E|$]]|$1|1T|3|1U|5|6|7|5W|8|@$9|5X|A|5Y|B|C]]|D|@]|E|$]]|$1|1V|3|1W|5|6|7|5Z|8|@$9|60|A|61|B|C]]|D|@]|E|$]]|$1|1X|3|1Y|5|6|7|62|8|@$9|63|A|64|B|C]]|D|@$9|65|A|66|1|67]]|E|$]]|$1|1Z|3|20|5|L|7|68|8|@]|D|@]|E|$M|N]]|$1|21|3|22|5|6|7|69|8|@$9|6A|A|6B|B|C]]|D|@]|E|$]]|$1|23|3|24|5|6|7|6C|8|@$9|6D|A|6E|B|C]]|D|@$9|6F|A|6G|1|6H]]|E|$]]|$1|25|3|26|5|L|7|6I|8|@]|D|@]|E|$M|N]]|$1|27|3|28|5|6|7|6J|8|@$9|6K|A|6L|B|C]]|D|@]|E|$]]|$1|29|3|2A|5|6|7|6M|8|@$9|6N|A|6O|B|C]]|D|@$9|6P|A|6Q|1|6R]]|E|$]]|$1|2B|3|2C|5|6|7|6S|8|@$9|6T|A|6U|B|C]]|D|@]|E|$]]|$1|2D|3|2E|5|6|7|6V|8|@$9|6W|A|6X|B|C]]|D|@$9|6Y|A|6Z|1|70]]|E|$]]|$1|2F|3|2G|5|6|7|71|8|@$9|72|A|73|B|C]]|D|@]|E|$]]|$1|2H|3|2I|5|L|7|74|8|@]|D|@]|E|$M|N]]|$1|2J|3|-4|5|6|7|75|8|@]|D|@]|E|$]]]|2K|$2L|$5|2M|2N|2O|E|$2P|2Q]]|2R|$5|2M|2N|2O|E|$2P|2S]]|2T|$5|2M|2N|2O|E|$2P|2U]]|2V|$5|2M|2N|2O|E|$2P|2W]]|2X|$5|2M|2N|2O|E|$2P|2Y]]|2Z|$5|2M|2N|2O|E|$2P|30]]|31|$5|2M|2N|2O|E|$2P|32]]|33|$5|2M|2N|2O|E|$2P|34]]|35|$5|2M|2N|2O|E|$2P|36]]|37|$5|2M|2N|2O|E|$2P|38]]|39|$5|2M|2N|2O|E|$2P|3A]]|3B|$5|2M|2N|2O|E|$2P|3C]]|3D|$5|2M|2N|2O|E|$2P|2E]]]]

Of course in 2021 the right answer is:
<h3><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll" rel="nofollow noreferrer">String.prototype.replaceAll()</a></h3>
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>console.log(
 'Change this and this for me'.replaceAll('this','that') // Normal case
);
console.log(
 'aaaaaa'.replaceAll('aa','a') // Challenged case
);</code></pre>
</div>
</div>

If you don't want to deal with <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace" rel="nofollow noreferrer">replace()</a> + <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp" rel="nofollow noreferrer">RegExp</a>.
But what if the browser is from before 2020?
In this case we need <a href="https://w3ctag.github.io/polyfills/" rel="nofollow noreferrer">polyfill</a> (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.
<h4>My suggested options for <code>replaceAll</code> polyfill:</h4>
<h5><code>replaceAll</code> polyfill (with global-flag error) (more principled version)</h5>
<pre class="lang-js prettyprint-override"><code>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 &amp; 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, &quot;\\$&amp;&quot;), &quot;g&quot;), // Replace all reserved characters with '\' then make a global 'g' RegExp
 replace); // passing second argument
 }
 });
}
</code></pre>
<h5><code>replaceAll</code> polyfill (With handling global-flag missing by itself) (my first preference) - <a href="https://github.com/tc39/proposal-string-replaceall/issues/16" rel="nofollow noreferrer">Why?</a></h5>
<pre class="lang-js prettyprint-override"><code>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 &amp; 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, &quot;\\$&amp;&quot;), &quot;g&quot;), // Replace all reserved characters with '\' then make a global 'g' RegExp
 replace); // passing second argument
 }
 });
}
</code></pre>
<h6>Minified (my first preference):</h6>
<pre class="lang-js prettyprint-override"><code>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,&quot;\\$&amp;&quot;),&quot;g&quot;),replace)}})}
</code></pre>
<h5>Try it:</h5>
<div class="snippet" data-lang="js" data-hide="true" data-console="true" data-babel="false">
<div class="snippet-code snippet-currently-hidden">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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,"\\$&amp;"),"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) &lt; 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 &gt; 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 &lt; 2020:
// xyz xyz
// Browsers &gt; 2020
// TypeError: String.prototype.replaceAll called with a non-global RegExp</code></pre>
</div>
</div>

<h6>Browser support:</h6>
<ul>
<li><a href="https://en.wikipedia.org/wiki/Internet_Explorer_9" rel="nofollow noreferrer">Internet Explorer 9</a> and later (rested on <a href="https://en.wikipedia.org/wiki/Internet_Explorer_11#Internet_Explorer_11" rel="nofollow noreferrer">Internet Explorer 11</a>).</li>
<li>All other browsers (after 2012).</li>
</ul>
The result is the same as the native replaceAll in case of the first argument input is:
<code>null</code>, <code>undefined</code>, <code>Object</code>, <code>Function</code>, <code>Date</code>, ... , <code>RegExp</code>, <code>Number</code>, <code>String</code>, ...
Ref: <a href="https://tc39.es/ecma262/#sec-string.prototype.replaceall" rel="nofollow noreferrer">22.1.3.19 String.prototype.replaceAll ( searchValue, replaceValue)</a>
+ <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/RegExp#syntax" rel="nofollow noreferrer">RegExp Syntax</a>
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 <code>.split('searchValue').join('replaceValue')</code> or some well managed functions give same result, but definitely with much lower performance than <code>native replaceAll()</code> / <code>polyfill replaceAll()</code> / <code>replace() + RegExp</code>
<hr />
<h4>Other methods of polyfill assignment</h4>
<h5>Naive, but supports even older browsers (be better to avoid)</h5>
For example, we can support IE7+ too, by not using <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty" rel="nofollow noreferrer">Object.defineProperty()</a> and using my old naive assignment method:
<pre class="lang-js prettyprint-override"><code>if (!String.prototype.replaceAll) {
 String.prototype.replaceAll = function(search, replace) { // &lt;-- Naive method for assignment
 // ... (Polyfill code Here)
 }
}
</code></pre>
And it should work well for basic uses on IE7+. 
But as <a href="https://stackoverflow.com/a/46491279/7514010">here</a> @sebastian-simon explained about, that can make secondary problems in case of more advanced uses. E.g.:
<pre class="lang-js prettyprint-override"><code>for (var k in 'hi') console.log(k);
// 0
// 1
// replaceAll &lt;-- ?
</code></pre>
<h5>Fully trustable, but heavy</h5>
In fact, my suggested option is a little optimistic. Like we trusted the environment (browser and <a href="https://en.wikipedia.org/wiki/Node.js" rel="nofollow noreferrer">Node.js</a>), 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:
<a href="https://polyfill.io/" rel="nofollow noreferrer">https://polyfill.io/</a>
Specially for replaceAll:
<pre class="lang-html prettyprint-override"><code>&lt;script src=&quot;https://polyfill.io/v3/polyfill.min.js?features=String.prototype.replaceAll&quot;&gt;&lt;/script&gt;
</code></pre>

Given a string:
<pre><code>s = &quot;Test abc test test abc test test test abc test test abc&quot;;
</code></pre>
This seems to only remove the first occurrence of <code>abc</code> in the string above:
<pre><code>s = s.replace('abc', '');
</code></pre>
How do I replace all occurrences of it?

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

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

给出一个字符串：s = "Test abc test test abc test test test abc test test abc";这似乎只删除了上面字符串中第一个出现的abc：s = s.replace('abc', '');我如何替换它的所有事件？

问如何替换JavaScript中出现的所有字符串？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何替换JavaScript中出现的所有字符串？EN