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

最新推荐文章于 2021-10-14 10:32:46 发布

asdfgh0077

最新推荐文章于 2021-10-14 10:32:46 发布

阅读量273

点赞数

文章标签： javascript string replace

原文链接：https://stackoom.com/question/4noF/如何替换所有出现的字符串

版权

我有这个字符串：

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

正在做：

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

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

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

#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开发人员网络的JavaScript正则表达式指南中对此进行了介绍，该指南提供了以下实用程序功能：

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

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

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

#2楼

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'

#3楼

使用正则表达式：

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

#4楼

注意：请勿在真实代码中使用此代码。

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

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

一般模式是

str.split(search).join(replacement)

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

#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/

#6楼

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

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

#7楼

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

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

#8楼

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

#9楼

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

注意：通常，通常不建议在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
}

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

#10楼

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

http://jsfiddle.net/ANHR9/

#11楼

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

修改过的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中具有最快的性能。

#12楼

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

#13楼

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

例如：

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，'，'），但是在某个时候，正则表达式变得复杂且缓慢，以至于无法循环播放。]

#14楼

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

#15楼

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

#16楼

替换单引号：

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

    return text;
}

#17楼

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

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

#18楼

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

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

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

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

#19楼

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

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

#20楼

在JavaScript中使用RegExp可以为您完成这项工作，只需简单地执行以下代码，不要忘记/g之后对于global的突出表现：

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代码的良好实践。

#21楼

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

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

#22楼

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

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

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

#24楼

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

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

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

#25楼

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

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

#26楼

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

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

#27楼

要更换一次，请使用：

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

要多次更换，请使用：

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

#28楼

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

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

也见这里

#29楼

与全局正则表达式匹配：

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

#30楼

更新：

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

asdfgh0077

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
如何替换所有出现的字符串？

我有这个字符串： "Test abc test test abc test test test abc test test abc" 正在做： str = str.replace('ab
复制链接

扫一扫