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

我有这个字符串：

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

正在做：

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

似乎只删除了abc上面字符串中的第一个匹配项。

如何替换所有出现的内容？

注意：不要在对性能有要求的代码中使用此代码。

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

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

一般模式是

str.split(search).join(replacement)

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

基准测试：https：//jsperf.com/replace-all-vs-split-join

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

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

回应评论：

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

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

为了响应Click Upvote的评论，您可以进一步简化它：

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

注意：正则表达式包含特殊的（元）字符，因此很危险地在find上面的函数中盲目传递参数而不进行预处理以转义这些字符。Mozilla开发人员网络的正则表达式JavaScript指南中对此进行了介绍，该指南提供了以下实用程序功能（自最初编写此答案以来，该功能至少更改了两次，因此请确保检查MDN站点是否有潜在更新）：

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

因此，为了使上述replaceAll()功能更安全，如果还包括以下内容，则可以将其修改为以下内容escapeRegExp：

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

为了完整起见，我必须考虑应该使用哪种方法来执行此操作。基本上有两种方法可以执行此操作，如本页其他答案所建议。

注意：通常，通常不建议在JavaScript中扩展内置原型。我仅作为说明目的在String原型上提供扩展，显示了String内置原型上假设的标准方法的不同实现。

基于正则表达式的实现

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

拆分和联接（功能）实施

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

在效率方面，对正则表达式如何在幕后工作不了解太多，我过去倾向于不考虑性能而倾向于拆分和加入实现。当我确实想知道哪种效率更高，效率更高时，我以它为借口进行查找。

在我的Chrome Windows 8计算机上，基于正则表达式的实现是最快的，而split and join实现的速度要慢53％。意味着正则表达式的速度是我使用的lorem ipsum输入的两倍。

检验此基准测试，相互对照运行这两个实现。

如@ThomasLeduc和其他人在下面的注释中所指出的，如果search包含某些在正则表达式中保留为特殊字符的字符，则基于正则表达式的实现可能会有问题。该实现假定调用者将预先转义字符串，或仅传递不包含正则表达式（MDN）表中字符的字符串。

MDN还提供了一种实现来转义我们的字符串。如果这也被标准化为RegExp.escape(str)，那就很好了，但是，它不存在：

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

我们可以escapeRegExp在String.prototype.replaceAll实现中调用，但是，我不确定这会对性能有多大的影响（甚至对于不需要转义的字符串（例如所有字母数字字符串）也可能有影响）。

使用带有g标志集的正则表达式将替换所有：

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

也见这里

这是一个基于已接受答案的字符串原型函数：

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

小提琴：http：//jsfiddle.net/cdbzL/

更新：

更新有点晚了，但是由于我偶然发现了这个问题，并且注意到我以前的回答不是我满意的答案。由于问题涉及替换单个单词，所以没人想到要使用单词边界（\b），这真是令人难以置信

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

这是一个简单的正则表达式，在大多数情况下避免替换部分单词。但是，破折号-仍被视为单词边界。因此在这种情况下可以使用条件语句来避免替换字符串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"

基本上，此问题与此处的问题相同： Javascript将“'”替换为“”

@Mike，请检查我在此处给出的答案... regexp并不是替换subsrting的多次出现的唯一方法，远非如此。想灵活，想分裂！

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

糟糕，这可能不是您想要的。那是什么 恕我直言，正则表达式只能有条件地替换“ 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"

我的猜测是，这可以满足您的需求。当然，它不是完全可靠的，但足以让您入门。我建议您在这些页面上阅读更多内容。实践证明，这对于完善此表达方式以满足您的特定需求很有用。

http://www.javascriptkit.com/jsref/regexp.shtml

http://www.regular-expressions.info

最后添加：

鉴于这个问题仍然有很多观点，我想我可以添加一个.replace与回调函数一起使用的示例。在这种情况下，它极大地简化表达，并提供了更大的灵活性，如大小写正确的更换或更换两个cat和cats一个去：

'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

与全局正则表达式匹配：

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

要更换一次，请使用：

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

要多次更换，请使用：

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

这些是最常见且易读的方法。

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

方法1：

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

方法2：

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

方法3：

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

方法4：

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

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

或者从这里尝试replaceAll函数：

有什么有用的JavaScript方法可以扩展内置对象？

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

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

编辑：有关replaceAll可用性的说明

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

例如

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

使用RegExp中的JavaScript可以为你做这项工作，只是简单的做一些类似下面的代码，别忘了/g之后，突出了全球：

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

但是，正如我前面提到的，它在写入的行数或性能上不会有很大的不同，只有缓存该函数才能在长字符串上实现更快的性能，并且如果要重用也可以作为DRY代码的良好实践。

假设您要将所有的“ abc”替换为“ x”：

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

我试图考虑比修改字符串原型更简单的事情。

使用正则表达式：

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

替换单引号：

function JavaScriptEncode(text){
    text = text.replace(/'/g,''')
    // More encode here if required

    return text;
}

//循环播放，直到出现的次数变为0。或者简单地复制/粘贴

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

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

对我来说比上述答案更好。因此new RegExp("abc", 'g')创建一个RegExp，它匹配'g'文本（"abc"）的所有出现（标志）。第二部分是要替换的内容，在您的情况下为空字符串（""）。 str是字符串，我们必须覆盖它，因为它replace(...)只是返回结果，而不是覆盖。在某些情况下，您可能想要使用它。

这是不使用正则表达式的最快版本。

修改过的jsperf

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

它的速度几乎是split and join方法的两倍。

如此处的注释中所指出的，如果您的omit变量包含place，如：中的，这将不起作用replaceAll("string", "s", "ss")，因为它始终可以替换该单词的另一个出现位置。

我的递归替换中还有另一个jsperf，它的变体运行得更快（http://jsperf.com/replace-all-vs-split-join/12）！

• 2017年7月27日更新：看起来RegExp现在在最近发布的Chrome 59中具有最快的性能。

性能

今天27.12.2019我将在macOS v10.13.6（High Sierra）上针对所选解决方案执行测试。

结论

• 在str.replace(/abc/g, '');（c ^）是所有串良好的跨浏览器的快速的解决方案。
• 基于split-join（A，B）或replace（C，D）的解决方案速度很快
• 基于while（E，F，G，H）的解决方案很慢-小字符串通常慢4倍，长字符串通常慢3000倍（！）
• 递归解决方案（RA，RB）很慢，不适用于长字符串

我还创建了自己的解决方案。看起来目前是执行问题工作的最短的一种：

str.split`abc`.join``

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

console.log(str);

细节

测试是在Chrome 79.0，Safari 13.0.4和Firefox 71.0（64位）上进行的。测试RA并RB使用递归。结果

短字符串-55个字符

您可以在此处在计算机上运行测试。Chrome的结果：

长字符串：275 000个字符

递归解RA和RB给出

RangeError：超出最大调用堆栈大小

对于100万个字符，他们甚至破坏了Chrome

我尝试对其他解决方案的1M个字符执行测试，但是E，F，G，H花费了很多时间，浏览器要求我中断脚本，因此我将测试字符串缩小为275K个字符。您可以在此处在计算机上运行测试。Chrome的搜索结果

测试中使用的代码

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 + 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 && 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 + replace.length;
    var st2 = str.substring(i);
    if(st2.indexOf(find) > -1){
      str = str.substring(0,i) + RB(st2, find, replace);
    }
  }
  return str;
}




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

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

如果要查找的内容已经在字符串中，并且您没有方便的正则表达式转义符，则可以使用join / split：

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

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

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

我喜欢这种方法（看起来更干净）：

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

不使用任何正则表达式的最简单方法是拆分和合并，如下所示：

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

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

http://jsfiddle.net/ANHR9/

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

如果字符串包含类似的模式abccc，则可以使用：

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

先前的答案太复杂了。只需使用以下替换功能：

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

例：

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

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

console.log(res);

如果您试图确保所寻找的字符串即使在替换后也不存在，则需要使用循环。

例如：

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

完成后，您仍将拥有“ test abc”！

解决此问题的最简单的循环是：

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

但这在每个循环中都要运行两次替换。也许（有被否决的危险）可以组合起来使用，效率更高但可读性更差：

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

当寻找重复的字符串时，这可能特别有用。
例如，如果我们有'a ,,, b'，我们希望删除所有重复的逗号。
[在那种情况下，可以执行.replace（/，+ / g，'，'），但是在某个时候，正则表达式变得复杂且缓慢，以至于无法循环。

尽管人们提到了正则表达式的用法，但是如果您想替换文本而不考虑大小写，则有更好的方法。像大写或小写。使用以下语法

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

//Output will be all the occurrences removed irrespective of casing.

您可以在此处参考详细示例。

您可以简单地使用以下方法

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

只需添加 /g

document.body.innerHTML = document.body.innerHTML.replace('hello', 'hi');

至

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

/g 意味着全球