本文共 10066 字，大约阅读时间需要 33 分钟。
我有这个字符串：
"Test abc test test abc test test test abc test test abc"
正在做：
str = str.('abc', ''); 似乎只删除上面字符串中的abc第一次出现。
如何替换所有出现的内容？
str = str.replace(/abc/g, '');
回应评论：
var find = 'abc';var re = new RegExp(find, 'g');str = str.replace(re, '');
为了响应的评论，您可以进一步简化它：
function replaceAll(str, find, replace) { return str.replace(new RegExp(find, 'g'), replace);} 注意：正则表达式包含特殊的（元）字符，因此危险地在上面的find函数中盲目传递参数，而无需对其进行预处理以转义那些字符。 的对此进行了介绍，该提供了以下实用程序功能：
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);} str = str.replace(/abc/g, '');
或者从这里尝试replaceAll函数：
str = str.replaceAll('abc', ''); ORvar search = 'abc';str = str.replaceAll(search, ''); 编辑：有关replaceAll可用性的说明
'replaceAll'方法已添加到的原型中。 这意味着它将适用于所有字符串对象/文字。
例如
var output = "test this".replaceAll('this', 'that'); //output is 'test that'.output = output.replaceAll('that', 'this'); //output is 'test this' 使用正则表达式：
str.replace(/abc/g, '');
注意：请勿在真实代码中使用此代码。
作为简单文字字符串的正则表达式的替代方法，您可以使用
str = "Test abc test test abc test...".split("abc").join(""); 一般模式是
str.split(search).join(replacement)
在某些情况下，这过去比使用replaceAll和正则表达式要快，但是在现代浏览器中，情况似乎不再如此。 因此，这实际上仅应用作一种快速技巧，以避免需要转义正则表达式，而不是真实代码。
这是一个基于已接受答案的字符串原型函数：
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);}; 小提琴： ：
我喜欢这种方法（看起来更干净）：
text = text.replace(new RegExp("cat","g"), "dog"); //循环播放，直到出现的次数变为0。或者简单地复制/粘贴
function replaceAll(find, replace, str) { while( str.indexOf(find) > -1) { str = str.replace(find, replace); } return str; } 如果要查找的内容已经在字符串中，并且您没有方便的正则表达式转义符，则可以使用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')); 为了完整起见，我必须考虑应该使用哪种方法来执行此操作。 基本上有两种方法可以执行此操作，如本页其他答案所建议。
注意：通常，通常不建议在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 ，但是，我不确定这会对性能产生多大的影响（甚至对于不需要转义的字符串（如所有字母数字字符串）也可能会影响性能）。
var str = "ff ff f f a de def";str = str.replace(/f/g,'');alert(str);
这是不使用正则表达式的最快版本。
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，它的变体甚至更快（ ）！
while (str.indexOf('abc') !== -1){ str = str.replace('abc', '');} 如果您试图确保所查找的字符串即使在替换后也不存在，则需要使用循环。
例如：
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，'，'），但是在某个时候，正则表达式变得复杂且缓慢，以至于无法循环播放。]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;} 只需添加/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表示全局
替换单引号：
function JavaScriptEncode(text){ text = text.replace(/'/g,''') // More encode here if required return text;} 您可以简单地使用以下方法
/** * 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);}; 尽管人们提到了正则表达式的用法，但是如果您想替换文本而不考虑大小写，则有更好的方法。 像大写或小写。 使用以下语法
//Consider below exampleoriginalString.replace(/stringToBeReplaced/gi, '');//Output will be all the occurrences removed irrespective of casing.
您可以在参考详细示例。
假设您要将所有的“ 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 我试图考虑比修改字符串原型更简单的事情。
在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代码的良好实践。
如果字符串包含类似abccc模式，则可以使用以下命令：
str.replace(/abc(\s|$)/g, "")
str = str.replace(new RegExp("abc", 'g'), ""); 对我来说比上述答案更好。 因此， new RegExp("abc", 'g')创建了一个RegExp，该RegExp与文本（ "abc" ）的所有出现情况（ 'g'标志）匹配。 第二部分是要替换的内容，在您的情况下为空字符串（ "" ）。 str是字符串，我们必须覆盖它，因为replace(...)仅返回结果，而不是覆盖。 在某些情况下，您可能想要使用它。
先前的答案太复杂了。 只需使用以下替换功能：
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);
我已经通过简单的代码行解决了这个问题。
str.replace(/Current string/g, "Replaced string");
在jsfiddle上查看示例
这些是最常见且易读的方法。
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
在不使用任何正则表达式的情况下，最简单的方法是在此处拆分并加入类似代码的代码：
var str="Test abc test test abc test test test abc test test abc";str.split('abc').join('') 要更换一次，请使用：
var res = str.replace('abc', ""); 要多次更换，请使用：
var res = str.replace(/abc/g, "");
使用设置了g标志的正则表达式将替换所有：
someString = 'the cat looks like a cat';anotherString = someString.replace(/cat/g, 'dog');// anotherString now contains "the dog looks like a dog"
与全局正则表达式匹配：
anotherString = someString.replace(/cat/g, 'dog');
更新：
更新有点晚了，但是由于我偶然发现了这个问题，并且注意到我以前的回答不是我满意的答案。 由于问题涉及替换单个单词，所以没有人想到使用单词边界（ \\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"
基本上，此问题与此处的问题相同：
@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"
我的猜测是，这可以满足您的需求。 当然，它不是完全可靠的，但足以让您入门。 我建议您在这些页面上阅读更多内容。 实践证明，这对于完善此表达方式以满足您的特定需求很有用。
最后添加：
鉴于这个问题仍然有很多观点，我想我可以添加一个与回调函数一起使用的.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 转载地址：http://mudnb.baihongyu.com/