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

我的JavaScript代码中有以下字符串：

"Test abc test test abc test test test abc test test abc"

做：

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

似乎只删除上面字符串中第一个出现的

abc

---

如何替换它的所有出现项？

使用带有

g

标志集的正则表达式将替换所有：

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

---

匹配全局正则表达式：

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

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

---

自2020年8月起：用于ECMAScript 2021语言规范定义的

---

对于旧版/旧版浏览器：

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

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

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

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

str=str.replace（/abc/g'）；

针对评论：

var find='abc'；
var re=新的RegExp（查找“g”）；
str=str.replace（re.）；

对于的评论，您可以进一步简化：

函数replaceAll（str、find、replace）{
返回str.replace（新的RegExp（查找'g'），replace）；
}

注意：正则表达式包含特殊（元）字符，因此，在上面的

find

函数中盲目传递参数而不进行预处理以转义这些字符是危险的。在的中介绍了这一点，其中他们提供了以下实用程序功能（自最初编写此答案以来，该功能已更改至少两次，因此请确保检查MDN站点以了解可能的更新）：

函数escapeRegExp（字符串）{
返回字符串。replace（/[.*+\-？^${}（）\[\]\\]/g，\\$&'）；/$&表示整个匹配字符串
}

因此，为了使上面的

replaceAll（）

函数更安全，如果还包括

escapeRegExp

，则可以将其修改为以下内容：

函数replaceAll（str、find、replace）{
return str.replace（新的RegExp（escapeRegExp（find），'g'），replace）；
}
str=str.replace（/abc/g'）；

或者尝试以下建议的
replaceAll
方法：

str=str.replaceAll（'abc'，''）；

或：

var搜索='abc'；
str=str.replaceAll（搜索“”）；

编辑：关于
replaceAll
可用性的澄清

replaceAll
方法被添加到
String
的原型中。这意味着它将可用于所有字符串对象/文字

例如：

var output=“testthis”.replaceAll（'this'、'that'）；//输出为“testthat”。
output=output.replaceAll（'that'，'this'）；//输出为“测试此”
使用正则表达式：

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

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

更新：在最流行浏览器的最新版本中，您可以使用
如图所示：

let result=“1 abc 2 abc 3.replaceAll”（“abc”，“xyz”）；
//`result`是“1xyz2xyz3”

但是，首先检查或其他兼容性表，以确保您针对的浏览器已经添加了对它的支持


有关节点和与旧浏览器/非当前浏览器的兼容性：

注意：不要在性能关键代码中使用以下解决方案。

作为简单文字字符串正则表达式的替代方法，您可以使用

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

一般的模式是

str.split(search).join(replacement)

在某些情况下，这比使用
replaceAll
和正则表达式更快，但在现代浏览器中似乎不再如此

基准：

结论：如果您有一个性能关键的用例（例如处理数百个字符串），请使用Regexp方法。但是对于大多数典型的用例来说，不必担心特殊字符是很值得的。
更新：

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

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

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

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

更新有点晚了，但因为我刚刚偶然发现了这个问题，并注意到我以前的答案不是我满意的。因为这个问题涉及到替换单个单词，所以没有人想到使用单词边界（
\b
）

这是一个简单的正则表达式，在大多数情况下避免替换部分单词。但是，破折号
-
仍然被视为单词边界。因此，在这种情况下，可以使用条件句来避免替换字符串，如
cool cat
：

'a cat is not a cool-cat'.replace(/\bcat\b/gi,'dog');//wrong
//"a dog is not a cool-dog" -- nips
'a cat is not a cool-cat'.replace(/(?:\b([^-]))cat(?:\b([^-]))/gi,'$1dog$2');
//"a dog is not a cool-cat"


基本上，这个问题和这里的问题是一样的：

@迈克，检查一下我给你的答案。。。regexp不是替换多次出现的子字符串的唯一方法，远远不是。想灵活，想分裂

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

或者，为了防止替换单词部分，批准的答案也可以！您可以使用正则表达式来解决这个问题，我承认，正则表达式有点复杂，结果也有点慢：

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

但是，使用此字符串上的/cat/g表达式，输出与接受的答案相同：

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

哦，事实上，这可能不是你想要的。那是什么呢？IMHO，一个只有条件地替换“cat”的正则表达式。（不是一个词的一部分）如：

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

我猜，这符合你的需要。当然，它不是完全可靠的，但它应该足以让你开始。我建议在这些页面上多读一些。这将有助于完善此表达式以满足您的特定需求




最终添加：

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

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

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

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

考虑到这个问题仍然有很多视图，我想我可以添加一个使用回调函数的
.replace
示例。在这种情况下，它极大地简化了表达式，并提供了更大的灵活性，例如使用正确的大写字母替换，或者一次性替换
cat
和
cat
：

'Two cats are not 1 Cat! They\'re just cool-cats, you caterpillar'
   .replace(/(^|.\b)(cat)(s?\b.|$)/gi,function(all,char1,cat,char2)
    {
       //check 1st, capitalize if required
       var replacement = (cat.charAt(0) === 'C' ? 'D' : 'd') + 'og';
       if (char1 === ' ' && char2 === 's')
       {//replace plurals, too
           cat = replacement + 's';
       }
       else
       {//do not replace if dashes are matched
           cat = char1 === '-' || char2 === '-' ? cat : replacement;
       }
       return char1 + cat + char2;//return replacement string
    });
//returns:
//Two dogs are not 1 Dog! They're just cool-cats, you caterpillar

下面是一个基于公认答案的字符串原型函数：

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

编辑

如果您的
find
将包含特殊字符，则需要对其进行转义：

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

小提琴：
我喜欢这种方法（看起来有点干净）：

循环，直到出现次数为0，如下所示：

String.prototype.replaceAll = String.prototype.replaceAll || function(string, replaced) {
  return this.replace(new RegExp(string, 'g'), replaced);
};

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

函数replaceAll（查找、替换、str）{
while（str.indexOf（find）>-1）{
str=str.replace（查找，替换）；
}
返回str；
}
如果您要查找的是alr
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

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

String.prototype.replaceAll = String.prototype.replaceAll || function(string, replaced) {
  return this.replace(new RegExp(string, 'g'), replaced);
};

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

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

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

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

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

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

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

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

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

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

var res = str.replace('abc', "");

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

String.prototype.replaceAll(searchValue, replaceValue)

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

str.split`abc`.join``