Question

我有这个字符串：

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

否则

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

似乎只删除上面字符串中第一次出现的abc。如何替换所有次出现？

Answer 1

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 Developer Network的JavaScript Guide on Regular Expressions涵盖了这一点，它们提供了以下实用功能：

function escapeRegExp(str) {
    return str.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
}

因此，为了使replaceAll()函数更安全，如果您还包含escapeRegExp，则可将其修改为以下内容：

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

Answer 2

为了完整起见，我开始考虑使用哪种方法来完成此操作。根据本页其他答案的建议，基本上有两种方法可以做到这一点。

注意：通常，建议不要在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计算机上，基于正则表达式的实施是最快的，拆分和加入实施的速度慢了53％。这意味着正则表达式的速度是我使用的lorem ipsum输入的两倍。

查看运行这两个实现的benchmark。

正如@ThomasLeduc及其他人在下面的评论中所指出的，如果search包含保留为special characters in regular expressions的某些字符，则基于正则表达式的实现可能会出现问题。该实现假定调用者将事先转义字符串，或者仅传递 Regular Expressions （MDN）中表中没有字符的字符串。

MDN还提供了一种逃避字符串的实现。如果它也被标准化为RegExp.escape(str)，那将会很好，但唉，它不存在：

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

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

Answer 3

注意：请勿在实际代码中使用此功能。

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

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

一般模式是

str.split(search).join(replacement)

在某些情况下，这比使用replaceAll和正则表达式更快，但在现代浏览器中似乎不再是这种情况。所以，这应该只是作为一个快速的黑客来避免需要逃避正则表达式，而不是真正的代码。

Answer 4

使用设置了g标志的正则表达式将替换所有：

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

See here also

Answer 5

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

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/

Answer 6

的更新 的

更新时间有点晚，但由于我偶然发现了这个问题，并注意到我以前的答案并不是我满意的答案。由于问题涉及替换单个单词，所以没有人想到使用单词边界（\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 replace " ' " with " '' "

@Mike，检查我给出的答案... 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" ??
确实糟糕，这可能不是你想要的。那是什么？恕我直言，一个只有条件地取代'猫'的正则表达式。（即不是单词的一部分），如下：

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

Answer 7

与全局正则表达式匹配：

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

Answer 8

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

或者从这里尝试replaceAll函数：

What are useful JavaScript methods that extends built-in objects?

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

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

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

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

E.g。

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

Answer 9

假设您要将所有'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

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

Answer 10

使用正则表达式：

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

Answer 11

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

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

方法01：

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

方法-02：

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

方法03：

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

方法04：

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

Answer 12

更换单引号：

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

    return text;
}

Answer 13

在 JavaScript 中使用RegExp可以为您完成这项工作，只需执行以下操作，不要忘记/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', '');

但正如我前面提到的，它不会在要写入的行或性能方面产生巨大的差异，只有缓存函数可能会对长字符串产生更快的性能，如果你想要的话，也可以很好地实现干代码重用。

Answer 14

//循环直到数字出现为0.或者只是复制/粘贴

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

Answer 15

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

Revised jsperf

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

几乎两次与分割和连接方法一样快。

正如此处的评论中指出的那样，如果您的omit变量包含place，则此功能无效，例如：replaceAll("string", "s", "ss")，因为它始终能够替换另一个这个词。

我的递归替换上还有另一个带有变体的jsperf更快（http://jsperf.com/replace-all-vs-split-join/12）！

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

Answer 16

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

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

Answer 17

如果您要查找的内容已经在字符串中，并且您没有方便的regex escaper，则可以使用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'));

Answer 18

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

Answer 19

我喜欢这种方法（它看起来更清洁）：

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

Answer 20

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

http://jsfiddle.net/ANHR9/

Answer 21

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

Answer 22

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

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

Answer 23

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

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

Answer 24

虽然人们已经提到使用正则表达式但是如果你想要替换文本而不管文本的情况如何，那么更好的方法。像大写或小写。使用以下语法

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

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

您可以参考详细示例here。

Answer 25

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

例如：

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

完成后，您仍然会测试abc＆＃39;！

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

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

这在查找重复字符串时特别有用例如，如果我们有一个,,, b＆＃39;我们希望删除所有重复的逗号 [在这种情况下，人们可以做.replace（/，+ / g，＆＃39;，＆＃39;），但在某些时候，正则表达式变得复杂而且足够缓慢而不是循环。]

Answer 26

我已经通过简单的代码行解决了这个问题。

str.replace(/Current string/g, "Replaced string");

在jsfiddle https://jsfiddle.net/pot6whnx/1/上查看示例

Answer 27

以下功能对我有用：

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

现在调用这样的函数：

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

只需在浏览器控制台中将此代码复制并粘贴到TEST。

Answer 28

只需添加/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表示全局

Answer 29

您可以使用以下方法

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

Answer 30

我使用 p 来存储上一次递归替换的结果：

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

它将替换字符串 s 中的所有匹配项，直到可能：

replaceAll('abbbbb', 'ab', 'a') → 'abbbb' → 'abbb' → 'abb' → 'ab' → 'a'

为了避免无限循环，我会检查替换 r 是否包含匹配 m ：

replaceAll('abbbbb', 'a', 'ab') → 'abbbbb'

Answer 31

在不使用任何正则表达式的情况下，最简单的方法是在此处拆分并加入类似的代码：

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

Answer 32

大多数人都可能这样做来编码URL。要对URL进行编码，您不仅应考虑空格，还应使用encodeURI正确转换整个字符串。

encodeURI("http://www.google.com/a file with spaces.html")

得到：

http://www.google.com/a%20file%20with%20spaces.html

Answer 33

要替换所有类型的字符，请尝试以下代码：

Suppose we have need to send " and \ in my string, then we will convert it " to \" and \ to \\

所以这种方法可以解决这个问题。

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

var message = $('#message').val();
             message = message.replaceAll('\\', '\\\\'); /*it will replace \ to \\ */
             message = message.replaceAll('"', '\\"');   /*it will replace " to \\"*/

我使用的是Ajax，我需要以JSON格式发送参数。然后我的方法看起来像这样：

 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":"' + source + '","messageID":"' + messageID + '","toProfileID":"' + toProfileID + '","userProfileID":"' + userProfileID + '","message":"' + message + '"}',
             dataType: "json",
             success: function (data) {
                 loadMessageAfterSend(toProfileID, userProfileID);
                 $("#<%=PanelMessageDelete.ClientID%>").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(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'), 'g'), replace);
 };

Answer 34

性能

今天27.12.2019我在MacOs HighSierra 10.13.6上针对所选解决方案进行测试

结论

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个字符

您可以在计算机HERE上运行测试。铬的结果

长字符串：275 000个字符

递归解决方案 RA 和 RB 给出

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

对于100万个字符，它们甚至会破坏镀铬

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

测试中使用的代码

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>

Answer 35

我的实施，非常自我解释

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

Answer 36

这可以使用正则表达式来实现。很少有可以帮助某人的组合，

var word = "this,\\ .is*a*test,    '.and? / only /     'a \ test?";
var stri = "This      is    a test         and only a        test";

要替换所有非字母字符，

console.log(word.replace(/([^a-z])/g,' ').replace(/ +/g, ' ')); 
Result: [this is a test and only a test]

要用一个空格替换多个连续空格，

console.log(stri.replace(/  +/g,' ')); 
Result: [This is a test and only a test]

要替换所有*个字符，

console.log(word.replace(/\*/g,'')); 
Result: [this,\ .isatest,    '.and? / only /     'a  test?]

替换问号（？）

console.log(word.replace(/\?/g,'#')); 
Result: [this,\ .is*a*test,    '.and# / only /     'a  test#]

要替换引号，

console.log(word.replace(/'/g,'#'));  
Result: [this,\ .is*a*test,    #.and? / only /     #a  test?]

要替换所有的'字符，

console.log(word.replace(/,/g,'')); 
Result: [this\ .is*a*test    '.and? / only /     'a  test?]

要替换特定单词，

console.log(word.replace(/test/g,'')); 
Result: [this,\ .is*a*,    '.and? / only /     'a  ?]

要替换反斜杠，

console.log(word.replace(/\\/g,''));  
Result: [this, .is*a*test,    '.and? / only /     'a  test?]

要替换正斜杠，

console.log(word.replace(/\//g,''));  
Result: [this,\ .is*a*test,    '.and?  only      'a  test?]

要替换所有空格，

console.log(word.replace(/ /g,'#'));  
Result: [this,\#.is*a*test,####'.and?#/#only#/#####'a##test?]

要替换点，

console.log(word.replace(/\./g,'#')); 
Result: [this,\ #is*a*test,    '#and? / only /     'a  test?]

Answer 37

这是非常简单的解决方案。您可以为String对象分配一个新方法

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

Answer 38

与主要答案these are some online tests相关的表现。

以下是使用console.time()进行的一些性能测试（它们在您自己的控制台中效果最好，但是在代码段中看到的时间很短）

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

值得注意的是，如果多次运行它们，即使RegExp解决方案似乎平均速度最快，而while循环解决方案最慢，结果也总是不同的。

Answer 39

方法1

尝试实现正则表达式

“测试abc测试测试abc测试测试测试abc测试测试abc” .replace（/ \ abc / g，''）;

方法2

拆分并加入。用abc分割并加入空白

“测试abc测试测试abc测试测试测试abc测试测试abc” .split（“ abc”）。join（“”）

Answer 40

以下是原型的工作代码：

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

Answer 41

在我的应用程序中，我使用了一个功能最强大的自定义函数，甚至在更简单的情况下包装split/join解决方案，Chrome 60和{Firefox 54更快一点。 {1}}（JSBEN.CH）比其他解决方案。我的电脑运行Windows 7 64 bits。

优点是这个自定义函数可以使用字符串或字符同时处理许多替换，这可能是某些应用程序的快捷方式。

与上述split/join解决方案类似，下面的解决方案对转义字符没有问题，与正则表达式方法不同。

  function replaceAll(s,find,repl,caseOff,byChar){
  if (arguments.length<2)  return false; 
  var destDel = ! repl;       // if destDel delete all keys from target
  var isString = !! byChar;   // if byChar, replace set of characters 
  if (typeof find !==typeof repl && ! destDel)  return false; 
  if (isString  &&  (typeof find!=="string"))   return false; 

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

  if ((! isString)  &&  ( ! Array.isArray(find) ||
          ( ! Array.isArray(repl) && ! destDel)   ))  return false;

     // if destOne replace all strings/characters by just one element
  var destOne = destDel ? false : (repl.length===1);   

     // Generally source and destination should have the same size
  if (! destOne && ! destDel && find.length!==repl.length)  return false    

  var prox,sUp,findUp,i,done;   
  if (caseOff)  {    // case insensitive    
       // Working with uppercase keys and target 
    sUp = s.toUpperCase();   
    if (isString)
       findUp = find.toUpperCase()   
    else
       findUp = find.map(function(el){  return el.toUpperCase();});    

  } else  {         // case sensitive
     sUp = s;
     findUp =find.slice();  // clone array/string
  }  

  done = new Array(find.length);  // size: number of keys
  done.fill(null);              

  var pos = 0;       // initial position in target s
  var r = "";   // initial result
  var aux, winner;
  while (pos < s.length)  {       // Scanning the target
     prox  = Number.MAX_SAFE_INTEGER;
     winner = -1;  // no winner at start
     for (i=0;i<findUp.length;i++)   // find next occurence for each string
       if (done[i]!==-1) {    // key still alive
             // Never search for the word/char or is over?
         if (done[i]===null || done[i]<pos)  { 
           aux = sUp.indexOf(findUp[i],pos);
           done[i]=aux;  // Save the next occurrence
         } else
           aux = done[i]   // restore the position of last search
         if (aux<prox && aux!==-1) {   // if next occurrence is minimum
           winner = i;     // save it  
           prox = aux;
         }  
       }  // not done

      if (winner===-1) {   // No matches forward
         r += s.slice(pos);   
         break;
      } // no winner

      // found the character or string key in the target

      i = winner;  // restore the winner
      r += s.slice(pos,prox);   // update piece before the match

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

  }  // loop
  return r;  // return the resulting string
}

文档如下

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

 Parameters    
 ==========    

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

  if "find" is a string, it is a simple replacement for      
    all "find" occurrences in "s" by string "repl"    

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


  if "repl" is empty all "find" occurrences in "s" will be deleted.   
  if "repl" has only one character or element,    
      all occurrences in "s" will be replaced for that one.   

  "caseOff" is true if replacement is case insensitive     
       (default is FALSE)

  "byChar" is true when replacement is based on set of characters.    
  Default is false   

  if "byChar", it will be replaced in "s" all characters in "find"   
  set of characters for corresponding character in  "repl"
  set of characters   

 Return   
 ======   
  the function returns the new string after the replacement.

公平地说，我在没有参数测试的情况下运行了benchmark。

这是我的测试集，使用Node.js

function l() { return console.log.apply(null, arguments); }

var k=0;
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"],["do","fa"]));  //1
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"],["do"]));  //2
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"]));  //3
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
     "aeiou","","",true));  //4
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      "aeiou","a","",true));  //5
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      "aeiou","uoiea","",true));  //6
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      "aeiou","uoi","",true));  //7
l(++k,replaceAll("banana is a ripe fruit harvested near the river",
      ["ri","nea"],["do","fa","leg"]));  //8
l(++k,replaceAll("BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER",
      ["ri","nea"],["do","fa"]));  //9
l(++k,replaceAll("BANANA IS A RIPE FRUIT HARVESTED NEAR THE RIVER",
      ["ri","nea"],["do","fa"],true)); //10
return;

结果：

1＆＃39;香蕉是一种远在多佛收获的浓液果实   2＆＃39;香蕉是多佛收获的一种水果。＆＃39;
  3＆＃39;香蕉是收获的pe果实   4＆＃39; bnn s rp frt hrvstd nr th r rr＆＃39;
  5＆＃39;香蕉作为rapa fraat harvastad naar tha ravar＆＃39;
  6＆＃39; bununu是你的ripo frait hurvostod nour tho thiv rivor＆＃39;
  7假
  8假
  9＆＃39;香蕉是在河流附近收获的一种果子水果＆＃39;
  10＆＃39;香蕉是一种收获的水果。

Answer 42

此解决方案结合了一些先前的答案，并与提议的2020年8月标准解决方案更好地相符。对于我来说，该解决方案在2020年9月仍然可行，因为我正在使用的String.replaceAll二进制文件中没有node。

RegExp.escape是一个单独的问题，但在这里很重要，因为官方提出的解决方案将自动转义基于string的{{1}}输入。这种find的polyfill不会没有String.replaceAll逻辑。

在您不希望添加答案的情况下，我没有添加答案{。

如果将RegExp.escape传递给RegExp.Escape，则您必须包含RegExp作为标志。这种polyfill不会为您提供不错的TypeError，并且会给您带来严重的麻烦。

如果需要严格的标准一致性，对于严格依赖标准实现的应用程序，我建议每次使用find或其他工具来获得“正确答案”，而不是SO dot com。。这样一来，您就不会感到惊讶。

代码：

最小化的代码：

babel

示例：

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

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

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

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

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

不含RegExp.Escape的代码，已最小化：

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

Answer 43

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

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

Answer 44

现在有一个proposal用于将String.prototype.replaceAll集成到正式规范中。最终，开发人员将不必为replaceAll提出自己的实现-相反，现代Javascript引擎将对其提供本机支持。

该提案处于第3阶段，means规范管理者对将其集成到标准中充满信心，并且：

该解决方案是完整的，没有实施经验，大量使用和外部反馈，就无法进行进一步的工作。

我们很有可能很快就会看到它可以在V8和其他浏览器中使用。

以下是实施细节：

根据当前的TC39共识，在所有情况下，String.prototype.replaceAll的行为与String.prototype.replace相同，对于以下两种情况，除外：


如果searchValue是一个字符串，则String.prototype.replace仅替换一次出现的searchValue，而String.prototype.replaceAll替换一次出现的{em>所有 {1}}（就好像使用了searchValue或已正确地转义的全局正则表达式一样。）

如果.split(searchValue).join(replaceValue)是非全局正则表达式，则searchValue替换单个匹配项，而String.prototype.replace引发异常。这样做是为了避免缺少全局标志（这意味着“不要全部替换”）和要调用的方法的名称（强烈建议“全部替换”）之间固有的混淆。


值得注意的是，如果String.prototype.replaceAll是全局正则表达式，则String.prototype.replaceAll的行为就像String.prototype.replace。

您可以看到符合规范的polyfill here。

Answer 45

当前ECMAScript中有一个Stage 3 proposal，它向String中添加了replaceAll方法。

用法与replace方法相同：

String.prototype.replaceAll(searchValue, replaceValue)

这是一个示例用法：

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

（截至2019年） ECMAScript中尚未包含它，但存在polyfill：

V8引擎中的实验性标记--harmony-string-replaceall后面支持它。
进一步了解V8 website。

Answer 46

2019年11月，JavaScript string.prototype.replaceAll()中添加了一个新功能，目前仅babel.JS支持该功能，但也许将来可以在所有浏览器中实现。有关更多信息，请参见ar https://v8.dev/features/string-replaceall

Answer 47

我使用split and join或此功能

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

Answer 48

在字符串第一个元素中搜索并替换

＆＃13;

var str = '[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var i = str.replace('"[','[').replace(']"',']');
console.log(i,'//first element search and replace')

＆＃13;

在字符串全局搜索和替换

＆＃13;

var str = '[{"id":1,"name":"karthikeyan.a","type":"developer"}]'
var j = str.replace(/\"\[/g,'[').replace(/\]\"/g,']');
console.log(j,'//global search and replace')

＆＃13;

Answer 49

如果您使用库是一个选项，那么您将获得与库函数一起使用的测试和社区支持的好处。例如，string.js库有一个replaceAll（）函数可以执行您正在寻找的内容：

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

Answer 50

唯一可替换值

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

Answer 51

我只想根据上一版JavaScript的一些功能特性分享我的解决方案：

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

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

  console.warn(result)

Answer 52

2020年8月

没有更多的正则表达式了

const str = "Test abc test test abc test test test abc test test abc";
const modifiedStr = str.replaceAll('abc', '');
console.log(modifiedStr);

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll

Answer 53

我们可以在JavaScript中使用replace方法：

var result = yourString.replace('regexPattern', "replaceString");

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

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

console.log(expectedString);

Answer 54

我知道这不是执行此操作的最佳方法，但是您可以尝试以下操作：

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

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

Answer 55

选中此选项，我确定它会帮助您：

<!DOCTYPE html>
<html>
<body>
<p>Click the button to do a global search and replace for "is" in a string.</p>
<button onclick="myFunction()">Try it</button>
<p id="demo"></p>
<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>

这里是jsfiddle link

Answer 56

使用拆分和合并

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

Answer 57

这应该有效。

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

示例：

Console.log("Steve is the best character in minecraft".replaceAll("Steve" ,"Alex"));

Answer 58

 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

Answer 59

最简单的解决方案-

let str = "Test abc test test abc test test test abc test test abc";

str = str.split(" ");
str = str.filter((ele, key)=> ele!=="abc")
str = str.join(" ")

Or Simply -

str = str.split(" ").filter((ele, key) => ele != "abc").join(" ")

Answer 60

最佳解决方案，为了替换任何字符，我们使用这些 indexOf(), includes(), substring() 函数用当前字符串中的matched String替换provided String。

String.indexOf()功能是查找第n 个匹配索引的位置。
String.includes()方法确定是否可以在另一个字符串中找到一个字符串，并根据需要返回true或false。
String.substring()函数用于获取String（preceding，exceding）的部分。在这些部分之间添加了替换字符串，以生成最终的返回字符串。

以下功能允许使用任何字符。
其中RegExp不允许使用某些特殊字符，例如**，而某些字符需要转义，例如$。

String.prototype.replaceAllMatches = function(obj) { // Obj format: { 'matchkey' : 'replaceStr' }
    var retStr = this;
    for (var x in obj) {
        //var matchArray = retStr.match(new RegExp(x, 'ig'));
        //for (var i = 0; i < matchArray.length; i++) {
        var prevIndex = retStr.indexOf(x); // matchkey = '*', replaceStr = '$*' While loop never ends.
        while (retStr.includes(x)) {
            retStr = retStr.replaceMatch(x, obj[x], 0);
            var replaceIndex = retStr.indexOf(x);
            if( replaceIndex <  prevIndex + (obj[x]).length) {
                break;
            } else {
                prevIndex = replaceIndex;
            }
        }
    }
    return retStr;
};
String.prototype.replaceMatch = function(matchkey, replaceStr, matchIndex) {
    var retStr = this, repeatedIndex = 0;
    //var matchArray = retStr.match(new RegExp(matchkey, 'ig'));
    //for (var x = 0; x < matchArray.length; x++) {
    for (var x = 0; (matchkey != null) && (retStr.indexOf(matchkey) > -1); x++) {
        if (repeatedIndex == 0 && x == 0) {
            repeatedIndex = retStr.indexOf(matchkey);
        } else { // matchIndex > 0
            repeatedIndex = retStr.indexOf(matchkey, repeatedIndex + 1);
        }
        if (x == matchIndex) {
            retStr = retStr.substring(0, repeatedIndex) + replaceStr + retStr.substring(repeatedIndex + (matchkey.length));
            matchkey = null; // To break the loop.
        }
    }
    return retStr;
};

我们还可以使用正则表达式对象将文本与模式匹配。以下是将正则表达式对象用作对象的函数。

使用无效的正则表达式模式（例如'**'）时，会出现SyntaxError。

String.replace()函数用于将指定的String替换为给定的String。
String.match()函数用于查找String重复多少次。
RegExp.prototype.test方法执行搜索以查找正则表达式与指定字符串之间的匹配项。返回true或false。

String.prototype.replaceAllRegexMatches = function(obj) { // Obj format: { 'matchkey' : 'replaceStr' }
    var retStr = this;
    for (var x in obj) {
        retStr = retStr.replace(new RegExp(x, 'ig'), obj[x]);
    }
    return retStr;
};

请注意，正则表达式不带引号。

使用上述功能的示例：

var str = "yash yas $dfdas.**";
console.log('String : ', str);

// No need to escape any special Character
console.log('Index Matched replace : ', str.replaceMatch('as', '*', 2) );
console.log('Index Matched replace : ', str.replaceMatch('y', '~', 1) );
console.log('All Matched replace : ', str.replaceAllMatches({'as' : '**', 'y':'Y', '$':'-'}));
console.log('All Matched replace : ', str.replaceAllMatches({'**' : '~~', '$':'&$&', '&':'%', '~':'>'}));

// You need to escape some special Characters
console.log('REGEX All Matched replace : ', str.replaceAllRegexMatches({'as' : '**', 'y':'Y', '\\$':'-'}));

结果：

String :  yash yas $dfdas.**
Index Matched replace :  yash yas $dfd*.**
Index Matched replace :  yash ~as $dfdas.**

All Matched replace :  Y**h Y** -dfd**.**
All Matched replace :  yash yas %$%dfdas.>>

REGEX All Matched replace :  Y**h Y** -dfd**.**

Answer 61

这可以使用正则表达式和标志g来解决，这意味着在找到第一个匹配后不会停止。真的，正则表达式是生命储蓄者！

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

Answer 62

使用正则表达式 i 标志不区分大小写

console.log('App started'.replace(/a/g, '')) // App strted
console.log('App started'.replace(/a/gi, '')) // pp strted

Answer 63

您可以在没有正则表达式的情况下执行此操作，但是如果替换文本包含搜索文本，则需要小心。

例如

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

这是replaceAll的合适变体，包括字符串原型：

function replaceAll(str, find, newToken, ignoreCase)
{
    let i = -1;

    if (!str)
    {
        // Instead of throwing, act as COALESCE if find == null/empty and str == null
        if ((str == null) && (find == null))
            return newToken;

        return str;
    }

    if (!find) // sanity check 
        return str;

    ignoreCase = ignoreCase || false;
    find = ignoreCase ? find.toLowerCase() : find;

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

    return str;
}

或者，如果您要具有字符串原型功能：

String.prototype.replaceAll = function (find, replace) {
    let str = this;

    let i = -1;

    if (!str)
    {
        // Instead of throwing, act as COALESCE if find == null/empty and str == null
        if ((str == null) && (find == null))
            return newToken;

        return str;
    }

    if (!find) // sanity check 
        return str;

    ignoreCase = ignoreCase || false;
    find = ignoreCase ? find.toLowerCase() : find;

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

    return str;
};

Answer 64

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

Answer 65

来自 JavaScript String Replace Using replace() Method With regex：JavaScript 提供了一种用另一个字符串替换字符串的一部分的直接方法，您还可以通过一些技巧来做到这一点。

要替换所有出现的内容，您可以在 JavaScript 中使用 replace() 或 replaceAll 方法。

replace() method - 要使用此方法替换所有元素，请使用正则表达式作为模式来查找匹配的字符串，然后将其替换为新字符串。请考虑使用 /g 标志。

const str = "To do or not to do";
const pattern = /do/g;
const replaceBy = "Code";
console.log(str.replace(pattern, replaceBy));

replaceAll() method - 要使用此方法替换所有元素，请使用字符串或正则表达式作为模式来查找匹配的字符串，然后将其替换为新字符串。我们必须在 replaceAll 方法中使用带有正则表达式的 /g 标志。

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

替代方法：使用拆分和连接方法

将字符串拆分为要替换的字符串，并使用新字符串作为分隔符进行连接。请参阅示例。

const str = "To do or not to do";
const newStr = str.split("do").join("Code");
console.log(newStr);

Answer 66

有一种方法可以使用新的 replaceAll() 方法。

但您需要使用尖端浏览器或 JavaScript 运行时环境。

您可以在 language spec 中检查浏览器兼容性。

Answer 67

试试这个：

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

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

    return str;
};

Answer 68

我建议将字符串类附加到原型链中，从而为字符串类添加一个全局方法。

String.prototype.replaceAll = function(fromReplace, toReplace, {ignoreCasing} = {}) { return this.replace(new RegExp(fromReplace, ignoreCasing ? 'ig': 'g'), toReplace);}

它可以像

一样使用

'stringwithpattern'.replaceAll('pattern','new-pattern')

Answer 69

从v85开始，Chrome现在原生支持String.prototype.replaceAll。请注意，它的性能优于所有其他建议的解决方案，并且应在获得主要支持后使用。

功能状态： https://chromestatus.com/feature/6040389083463680

str s = "hello hello world";
s = s.replaceAll("hello", ""); // s is now "world"

Answer 70

我在“性能”部分的“性能”测试页面中添加了以下功能：

https://jsben.ch/LFfWA

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

..并将其作为测试：

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

..并且该函数对我来说比split或regex快34％。这个想法/希望最终是将越来越少的字符串片段粘贴到堆栈上，然后通过展开堆栈来构建整个结果，从而通过相同的字符串数据最小化多余的字符串副本和额外的搜索，并有望优化CPU的使用缓存。

部分想法是，如果字符串不太大，则可能会出现在CPU缓存中；传递并粘贴部分会将这些位放入高速缓存，然后搜索可以完全使用CPU高速缓存的数据进行操作。现在，无论这是否真的发生了，我确定完全取决于js实现。

这不是最快的速度，但是它是我在没有可变字符串的情况下可以管理的最快速度。 JavaScript中的数组可能每个元素都有一个指针，因此，涉及很多数组元素的解决方案不太像CPU缓存友好。

Answer 71

所有答案都被接受，您可以通过多种方式来执行此操作。做到这一点的技巧之一就是这个。

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

Answer 72

要更换一次，请使用：

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

要多次更换，请使用：

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

Answer 73

选中此答案可能会有所帮助，并且我已在我的项目中使用

。

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 "

Answer 74

您可以尝试这样：

示例数据：

var text = "heloo,hai,hei"

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

或

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

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

75 个答案:

基于正则表达式的实现

拆分和加入（功能）实施

See here also

性能

详细信息

短字符串-55个字符

长字符串：275 000个字符