it-swarm.dev

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

我有这个字符串:

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

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

似乎只删除上面字符串中第一次出现abc。如何更换 全部 出现?

3564
Click Upvote

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

注意:通常,不建议在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和join实现的速度慢了53%。这意味着正则表达式的速度是我使用的lorem ipsum输入的两倍。

看看这个 benchmark 相互运行这两个实现。


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

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

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

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

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

回应评论:

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

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

为了回应 点击Upvote 的评论,您可以进一步简化:

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

注意: 正则表达式包含特殊(元)字符,因此在上面的find函数中盲目传递参数而不预先处理它以逃避这些字符是危险的。这包含在 Mozilla开发人员网络 s 正则表达式的JavaScript指南 中,它们提供以下实用程序功能:

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

因此,为了使replaceAll()函数更安全,如果还包含escapeRegExp,则可以修改为以下函数:

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

注意:请勿在实际代码中使用它。

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

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

一般模式是

str.split(search).join(replacement)

在某些情况下,这比使用replaceAll和正则表达式更快,但在现代浏览器中似乎不再是这种情况。因此,这应该只是用作快速入侵,以避免需要转义正则表达式,而不是真正的代码。

1244
Matthew Crumley

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

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

在这里看到

553
Adam A

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

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/

93
jesal

更新:

这是一个更新有点迟,但因为我偶然发现了这个问题,并注意到我之前的答案不是我很满意的。由于问题涉及替换单个Word,所以没有人想到使用Word边界(\b

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

这是一个简单的正则表达式,可以避免在大多数情况下替换部分单词。但是,破折号-仍被视为Word边界。因此在这种情况下可以使用条件来避免替换像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不是替换多次出现的替换的唯一方法,远非它。思考灵活,思考分裂!

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

或者,为了防止替换Word部分 - 批准的答案也会这样做!您可以使用正则表达式来解决这个问题,我承认,这些正则表达式稍微复杂一些,并且作为结果,也有点慢:

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

哎呀,这可能不是你想要的。那是什么?恕我直言,一个只有条件地取代'猫'的正则表达式。 (即不是Word的一部分),如下所示:

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的例子。在这种情况下,它大大简化了表达式提供了更大的灵活性,例如替换正确的大写或者一次性替换catcats

'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
76
Elias Van Ootegem

匹配全局正则表达式:

anotherString = someString.replace(/cat/g, 'dog');
57
scronide
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'
39
SolutionYogi

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

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

34
Emilio Grisolía

使用正则表达式:

str.replace(/abc/g, '');
32
Donnie DeBoer

替换单引号:

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

    return text;
}
30
Chris Rosete

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

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
29
Adnan Toky

//循环直到数字出现为0. OR简单地复制/粘贴

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

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

修改了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"),因为它总是能够替换另一个出现的Word。

在我的递归替换上还有另一个带有变体的jsperf甚至更快( http://jsperf.com/replace-all-vs-split-join/12 )!

  • 2017年7月27日更新:看起来RegExp现在拥有最近发布的Chrome 59中最快的性能。
22
Cole Lawrence
str = str.replace(new RegExp("abc", 'g'), "");

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

22
csomakk

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
Alireza

如果您要查找的内容已经在字符串中,并且您没有方便的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'));

18
rakslice
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;
}
16
Tim Rivoli

我喜欢这种方法(它看起来更干净):

text = text.replace(new RegExp("cat","g"), "dog"); 
14
Owen
var str = "ff ff f f a de def";
str = str.replace(/f/g,'');
alert(str);

http://jsfiddle.net/ANHR9/

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

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

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

以前的答案太复杂了。只需使用这样的替换功能:

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

11
Black

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

例如:

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

完成后,你仍然会'测试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,','),但在某些时候,正则表达式变得复杂而且足够缓慢而不是循环。

9
SamGoody

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

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

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

你可以参考详细的例子 这里

9
Cheezy Code

以下功能适用于我:

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

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

7
Sandeep Gantait

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

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

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

7
Reza Fahmi

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

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

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

7
Riajul Islam

我使用 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'
6
Termininja

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

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

要得到:

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

在与主要答案相关的性能方面 这些是一些在线测试

虽然以下是使用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循环解决方案也是最慢的。

4
Ferie

我的实施,非常自我解释

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

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

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

在我的应用程序中,我使用了一个最强大的自定义函数,甚至在更简单的情况下包装split/join解决方案,它在Chrome 60Firefox 54JSBEN.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'香蕉是远远超过多佛的采摘果实'
2'香蕉是一种多产的水果收获多尔'
3'香蕉是收获的果实'
4'bnn s rp frt hrvstd nr th rvr'
5'香蕉作为rapa fraat harvastad naar tha ravar'
6'bununu是你的ripo frait hurvostod nour tho rivor'
7假
8错误
9'BANANA IS在河附近收获的RIPE水果'
10'BANANA IS收获的水果水果 

3
Paulo Buchsbaum

这可以使用Regex实现。几个可能对某人有帮助的组合,

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

要替换​​特定的Word,

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?]
3
prime
function replaceAll(str, find, replace) {
    var $r="";
    while($r!=str){ 
        $r = str;
        str = str.replace(find, replace);
    }
    return str;
}
3
theWalker

这是带原型的工作代码:

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

对于 唯一 可替换值

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

2
TheAivis

方法1

尝试实现正则表达式

“测试abc测试测试abc测试测试测试abc测试测试abc”.replace(/\abc/g,'');

方法2

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

“测试abc测试测试abc测试测试测试abc测试测试abc”.split(“abc”)。join(“”)

2
ashish

如果您使用库是一个选项,那么您将获得与库函数一起使用的测试和社区支持的好处。例如, string.js library有一个replaceAll()函数可以执行您要查找的内容:

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

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

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

在字符串全局搜索和替换  

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

2
KARTHIKEYAN.A

我只想根据上一版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)
1
Andrés

这可以使用正则表达式和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);
};
1
C. Morgan

替换一次性使用:

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

如需多次更换,请使用:

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

这应该工作。

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"));
1
jessie tessie

没有使用任何正则表达式的最简单的方法是拆分和连接像这里的代码:

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

检查这个答案可能会有所帮助,我在我的项目中使用过。

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 "
0
Raghavendra S

试试这个:

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

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

    return str;
};
0
Antonio Mirarchi
 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
0
Rinold

所有答案都被接受,你可以通过多种方式做到这一点。这样做的诀窍之一就是这个。

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);
0
Nouman Dilshad

最简单的解决方案 

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(" ")

0
Brijesh Kumar

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

  • String.indexOf() function是找n 匹配指数位置。
  • String.includes() method确定是否可以在另一个字符串中找到一个字符串,并根据需要返回true或false。
  • String.substring() function是获取String的部分(precedingexceding)。在这些部分之间添加了替换String以生成最终返回String。

以下功能允许使用任何角色。[。_____。]
其中as 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.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**.**

0
Yash