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


我有这个字符串:

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

做

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

似乎只删除了上面字符串中第一个出现的abc。我该如何替换所有出现的情况呢?

相关讨论

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

回应评论:

1
2
3
4
var find = 'abc';
var re = new RegExp(find, 'g');

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

对于点击Upvote的评论，您可以进一步简化它:

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

注意:正则表达式包含特殊的(元)字符，因此盲目地在上面的find函数中传递参数而不进行预处理以转义这些字符是很危险的。Mozilla开发人员网络的JavaScript正则表达式指南介绍了这方面的内容，其中提供了以下实用函数:

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

因此，为了使上面的replaceAll()函数更安全，如果还包含escapeRegExp，可以将其修改为:

1
2
3
function replaceAll(str, find, replace) {
    return str.replace(new RegExp(escapeRegExp(find), 'g'), replace);
}
相关讨论

为了完整起见，我开始考虑应该使用哪种方法来做这件事。按照本页其他答案的建议，基本上有两种方法可以做到这一点。

注意:通常不推荐使用JavaScript扩展内置原型。我在字符串原型上提供扩展只是为了说明，展示了在String内置原型上假想标准方法的不同实现。

基于正则表达式的实现

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

分割和连接(函数)实现

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

由于不太了解正则表达式如何在幕后高效地工作，我过去倾向于使用split和join实现，而不考虑性能。当我想知道哪一种方法更有效时，我就以此为借口去寻找答案。

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

请查看运行这两个实现的基准测试。

正如@ThomasLeduc和其他人在下面的评论中指出的，如果search包含在正则表达式中保留为特殊字符的某些字符，那么基于正则表达式的实现可能会出现问题。该实现假定调用者将事先转义字符串，或者只传递正则表达式(MDN)中表中没有字符的字符串。

MDN还提供了一个转义字符串的实现。如果这也被标准化为RegExp.escape(str)就好了，但是遗憾的是，它并不存在:

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

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

相关讨论

注意:在实际代码中不要使用这个。

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

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

一般的模式是

1
str.split(search).join(replacement)

在某些情况下，这比使用replaceAll和正则表达式要快，但在现代浏览器中似乎不再是这样了。因此，这实际上只应该作为一种快速技巧来使用，以避免需要转义正则表达式，而不是在实际代码中。

相关讨论

使用正则表达式与g标志集将替换所有:

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

也看到

相关讨论

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

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

编辑

如果你的find包含特殊字符，那么你需要转义它们:

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

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

相关讨论

更新:

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

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

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

1
2
3
4
'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的唯一方法。想灵活，想分裂!

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

或者，防止替换单词部分——这也是经过批准的答案!您可以使用正则表达式来解决这个问题，我承认，正则表达式稍微复杂一些，而且作为一个结果，也稍微慢一些:

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

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

1
2
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"。(不是一个词的一部分)，像这样:

1
2
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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
'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
相关讨论

匹配一个全局正则表达式:

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

或者从这里尝试replaceAll函数:

扩展内置对象的有用JavaScript方法有哪些?

1
2
3
4
str = str.replaceAll('abc', ''); OR

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

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

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

如。

1
2
var output ="test this".replaceAll('this', 'that');  //output is 'test that'.
output = output.replaceAll('that', 'this'); //output is 'test this'
相关讨论

假设你想用"x"替换所有的"abc":

1
2
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

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

相关讨论

使用正则表达式:

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

替换单引号:

1
2
3
4
5
6
function JavaScriptEncode(text){
    text = text.replace(/'/g,''')
    // More encode here if required

    return text;
}
相关讨论

在JavaScript中使用RegExp可以为您完成这项工作，只需做如下操作，不要忘记后面的/g代表全局:

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

如果你考虑重用，创建一个函数来为你做这件事，但这并不推荐，因为它只有一行函数，但如果你大量使用这个，你可以这样写:

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

然后在你的代码中反复使用它，如下所示:

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

但是，正如我前面提到的，它不会对要写的行或性能产生很大的影响，只有缓存函数才可能对长字符串产生更快的性能影响，如果您想重用，这也是一个很好的干代码实践。

//循环它，直到数字出现为0。或者简单的复制/粘贴

1
2
3
4
5
6
7
8
    function replaceAll(find, replace, str)
    {
      while( str.indexOf(find) > -1)
      {
        str = str.replace(find, replace);
      }
      return str;
    }
相关讨论

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

修订jsperf

1
2
3
4
5
6
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日更新:在最近发布的Chrome 59中，RegExp的性能似乎是最快的。

相关讨论

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

比上面的答案对我更有效。因此，new RegExp("abc", 'g')创建一个RegExp，它匹配文本("abc")的所有发生情况('g'标志)。第二部分是在您的示例中替换为空字符串("")的内容。str是字符串，我们必须重写它，因为replace(...)只返回结果，而不是重写。在某些情况下，您可能需要使用它。

相关讨论

如果你想找到的东西已经在一个字符串中，而你手边没有一个正则表达式转义器，你可以使用join/split:

1
2
3
4
5
6
7
    function replaceMulti(haystack, needle, replacement)
    {
        return haystack.split(needle).join(replacement);
    }

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

1
2
3
4
5
6
7
8
9
10
11
12
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;
}
相关讨论

我喜欢这个方法(看起来干净一点):

1
text = text.replace(new RegExp("cat","g"),"dog");
相关讨论

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

http://jsfiddle.net/ANHR9/

相关讨论

1
2
3
4
while (str.indexOf('abc') !== -1)
{
    str = str.replace('abc', '');
}
相关讨论

如果字符串包含类似abccc的模式，可以使用以下命令:

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

前面的答案太复杂了。就像这样使用替换函数:

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

例子:

1
2
3
4
5
var str ="Test abc test test abc test test test abc test test abc";

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

console.log(res);

相关讨论

虽然人们已经提到了regex的使用，但是如果想替换文本，无论文本的情况如何，都有更好的方法。比如大写或小写。使用下面的语法

1
2
3
4
//Consider below example
originalString.replace(/stringToBeReplaced/gi, '');

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

您可以参考这里的详细示例。

相关讨论

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

例如:

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

完成后，您仍然会有"test abc"!

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

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

但是每循环替换两次。也许(冒着被否决的风险)可以组合成一种更高效但可读性更差的形式:

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

这在查找重复字符串时特别有用。例如，如果我们有"a…b"，并且希望删除所有重复的逗号。[在这种情况下，可以使用.replace(/，+/g，'，')，但是在某个时候，regex会变得非常复杂，并且运行速度足够慢，可以进行循环。]

相关讨论

下面的功能适合我:

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

现在这样调用函数:

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

只需复制并粘贴此代码到浏览器控制台以进行测试。

只需添加/g

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

来

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

/g意味着全球

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

1
2
3
4
5
6
7
8
9
10
/**
 * 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);
};

这些是最常见和可读的方法。

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

Method-01:

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

Method-02:

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

Method-03:

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

Method-04:

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

输出:

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

我用p来存储之前递归替换的结果:

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

它将替换字符串s中的所有出现，直到有可能:

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

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

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

大多数人这样做可能是为了编码URL。要编码URL，不仅要考虑空格，还要使用encodeURI正确地转换整个字符串。

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

得到:

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

我用一行简单的代码就解决了这个问题。

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

检查jsfiddle https://jsfiddle.net/pot6whnx/1/上的示例

我的实现，非常不言自明

1
2
3
4
5
6
7
function replaceAll(string, token, newtoken) {
    if(token!=newtoken)
    while(string.indexOf(token) > -1) {
        string = string.replace(token, newtoken);
    }
    return string;
}
相关讨论

要替换所有字符，请尝试以下代码:

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

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

1
2
3
4
5
6
7
8
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('"', '\"');   /*it will replace" to \"*/

我使用Ajax，并且需要以JSON格式发送参数。然后我的方法是这样的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 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 + '
<hr><p>就与主要答案相关的表现而言，这些是一些在线测试。</P><p>虽然下面是一些使用<wyn>console.time()</wyn>的性能测试(它们在您自己的控制台中工作得最好，但是在代码片段中看到的时间非常短)</P><p>[cc lang="javascript"]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循环解决方案是最慢的。

下面是原型的工作代码:

1
2
3
4
String.prototype.replaceAll = function(find, replace) {
    var str = this;
    return str.replace(new RegExp(find.replace(/([.*+?^=!:${}()|\[\]\/\\])/g,"\\$1"), 'g'), replace);
};
1
2
3
4
5
6
7
8
function replaceAll(str, find, replace) {
    var $r="";
    while($r!=str){
        $r = str;
        str = str.replace(find, replace);
    }
    return str;
}
相关讨论

这可以使用Regex实现。很少有组合可以帮助某人，

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

要替换所有非alpha字符，

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

将多个连续空间替换为一个空间，

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

要替换所有*字符，

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

替换问号(?)

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

要替换引号，

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

要替换所有的字符，

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

要替换一个特定的单词，

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

代替反斜杠,

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

要替换正斜杠，

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

要替换所有空格，

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

来代替点,

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

在我的应用程序中，我使用的自定义函数是最强大的，甚至在更简单的情况下包装split/join解决方案，它在Chrome 60和Firefox 54 (JSBEN.CH)比其他解决方案更快。我的计算机运行Windows 7 64 bits。

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
  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 &amp;&amp; ! destDel)  return false;
  if (isString  &amp;&amp;  (typeof find!=="string"))   return false;

  if (! isString &amp;&amp;  (typeof find==="string"))  {
    return s.split(find).join(destDel?"":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 ="";   // 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 &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
}

文档如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
           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.

公平地说，我运行基准测试时没有进行参数测试。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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 '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'

相关讨论

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var str = '[{"id":1,"name":"karthikeyan.a","type":"developer
<hr><p>方法1</P><p>尝试实现正则表达式</P><p>测试abc测试abc测试abc测试abc测试abc测试abc替换(abc /  / g"、");</P><p>方法2</P><p>分裂和加入。用abc分割，用空格连接</P><p>测试abc测试abc测试abc测试abc测试abc测试abc加入("")</P><hr><p>对于唯一的可替换值</P><p>[cc lang="javascript"]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);

相关讨论

如果使用库是您的一种选择，那么您将从库函数附带的测试和社区支持中获益。例如，string.js库中有一个replaceAll()函数，它执行您正在寻找的功能:

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

这可以使用正则表达式和标志g来解决，这意味着在找到第一个匹配项后不会停止。真的，正则表达式是救命恩人!

1
2
3
4
5
6
7
8
9
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);
};

我只是想分享我的解决方案，基于一些最新版本的JavaScript的功能特点:

1
2
3
4
5
6
   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)

Try this:

1
2
3
4
5
6
7
8
9
String.prototype.replaceAll = function (sfind, sreplace) {
    var str = this;

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

    return str;
};
相关讨论

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

函数的作用是查找nth匹配索引位置。方法确定是否可以在另一个字符串中找到一个字符串，并根据需要返回true或false。函数的作用是获取字符串的各个部分(preceding，exceding)。在这些部分之间添加替换字符串以生成最终的返回字符串。

下面的函数允许使用任何字符。其中as RegExp不允许某些特殊字符(如**)，而某些字符(如$)需要转义。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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) &amp;&amp; (retStr.indexOf(matchkey) > -1); x++) {
        if (repeatedIndex == 0 &amp;&amp; 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。

函数的作用是:用给定的字符串替换指定的字符串。函数的作用是查找字符串重复了多少次。方法执行搜索正则表达式和指定字符串之间的匹配。返回true或false。

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

Note that regular expressions are written without quotes.

使用上述功能的例子:

1
2
3
4
5
6
7
8
9
10
11
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({'**' : '~~', '$':'&amp;$&amp;', '&amp;':'%', '~':'>'}));

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

结果:

1
2
3
4
5
6
7
8
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**.**

简单的解决方案,

1
2
3
4
5
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("")

1
Or Simply -

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

1
2
3
4
5
6
 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

你可以这样试试:

示例数据:

var text ="heloo,hai,hei"

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

或

1
2
3
text.forEach(function(value){
  hasil = hasil.replace(',','')
})```
相关讨论