在JavaScript中替换字符串中所有字符串/字符实例的最快方法是什么？一个while，一个for - 循环，一个正则表达式？
答案 0 :(得分：977)
最简单的方法是使用带有g标志的正则表达式来替换所有实例：
str.replace(/foo/g, "bar")
这将在字符串foo中将所有bar替换为str。如果您只有一个字符串，则可以将其转换为RegExp对象，如下所示：
var pattern = "foobar",
re = new RegExp(pattern, "g");
答案 1 :(得分：130)
试试这个替换所有： http://dumpsite.com/forum/index.php?topic=4.msg8#msg8
String.prototype.replaceAll = function(str1, str2, ignore)
{
return this.replace(new RegExp(str1.replace(/([\/\,\!\\\^\$\{\}\[\]\(\)\.\*\+\?\|\<\>\-\&])/g,"\\$&"),(ignore?"gi":"g")),(typeof(str2)=="string")?str2.replace(/\$/g,"$$$$"):str2);
}
速度非常快，适用于所有这些条件 许多其他人失败了：
"x".replaceAll("x", "xyz");
// xyz
"x".replaceAll("", "xyz");
// xyzxxyz
"aA".replaceAll("a", "b", true);
// bb
"Hello???".replaceAll("?", "!");
// Hello!!!
如果你能破坏它，或者你有更好的东西，请告诉我，但要确保它可以通过这4项测试。
答案 2 :(得分：79)
var mystring = 'This is a string';
var newString = mystring.replace(/i/g, "a");
newString现在是'Thas as strang'
答案 3 :(得分：34)
你也可以尝试：
string.split('foo').join('bar');
答案 4 :(得分：11)
从速度问题考虑它我相信上面链接中提供的区分大小写示例是迄今为止最快的解决方案。
var token = "\r\n";
var newToken = " ";
var oldStr = "This is a test\r\nof the emergency broadcasting\r\nsystem.";
newStr = oldStr.split(token).join(newToken);
newStr会 “这是对紧急广播系统的测试。”
答案 5 :(得分：9)
您可以使用以下内容：
newStr = str.replace(/[^a-z0-9]/gi, '_');
或
newStr = str.replace(/[^a-zA-Z0-9]/g, '_');
这将取代所有非字母或数字的字符（'_'）。只需更改下划线值即可替换它。
答案 6 :(得分：9)
我认为真正的答案是它完全取决于你的输入是什么样的。我创建了一个JsFiddle来尝试一堆这些以及我自己的几个输入。无论我如何看待结果，我都看不到明显的赢家。
我写的这个对于小输入和密集来说似乎最快 替换：
function replaceAllOneCharAtATime(inSource, inToReplace, inReplaceWith) {
var output="";
var firstReplaceCompareCharacter = inToReplace.charAt(0);
var sourceLength = inSource.length;
var replaceLengthMinusOne = inToReplace.length - 1;
for(var i = 0; i < sourceLength; i++){
var currentCharacter = inSource.charAt(i);
var compareIndex = i;
var replaceIndex = 0;
var sourceCompareCharacter = currentCharacter;
var replaceCompareCharacter = firstReplaceCompareCharacter;
while(true){
if(sourceCompareCharacter != replaceCompareCharacter){
output += currentCharacter;
break;
}
if(replaceIndex >= replaceLengthMinusOne) {
i+=replaceLengthMinusOne;
output += inReplaceWith;
//was a match
break;
}
compareIndex++; replaceIndex++;
if(i >= sourceLength){
// not a match
break;
}
sourceCompareCharacter = inSource.charAt(compareIndex)
replaceCompareCharacter = inToReplace.charAt(replaceIndex);
}
replaceCompareCharacter += currentCharacter;
}
return output;
}
答案 7 :(得分：7)
像这样使用Regex对象
var regex = new RegExp('"', 'g');
str = str.replace(regex, '\'');
它会将所有"替换为'。
答案 8 :(得分：6)
使用String对象的replace()方法。
如所选答案中所述，应在正则表达式中使用/ g标志，以替换字符串中子字符串的所有实例。
答案 9 :(得分：5)
我不知道的最快的是什么，但我知道什么是最可读的 - 什么是最短最简单的。即使它比其他解决方案稍慢，也值得使用。
所以使用：
"string".replace("a", "b");
"string".replace(/abc?/g, "def");
享受优质代码而不是更快（嗯...... 1/100000秒没有区别）和丑陋的代码。 ;）
答案 10 :(得分：5)
我意识到我可能在接近10年之前编写的这个实现实际上并没有完全发挥作用（在一个长期被遗忘的系统中讨厌的生产错误，并不总是那样），我尝试了一些这些建议。 ？！）...我注意到的是我尝试的那些（我没有全部尝试过）与我的问题有同样的问题，也就是说，它们不会取代每一次，只有第一次，至少对我而言通过用“。”替换“..”将“test .... txt”降为“test.txt”的测试用例......也许我错过了正则表达式的情况？但我离题了......
所以，我按如下方式重写了我的实现。这很简单，虽然我怀疑不是最快，但我也不认为这种差异会影响现代JS引擎，除非你在紧密的循环中做到这一点，但事情总是如此......
function replaceSubstring(inSource, inToReplace, inReplaceWith) {
var outString = inSource;
while (true) {
var idx = outString.indexOf(inToReplace);
if (idx == -1) {
break;
}
outString = outString.substring(0, idx) + inReplaceWith +
outString.substring(idx + inToReplace.length);
}
return outString;
}
希望能帮助别人！
答案 11 :(得分：2)
// Find, Replace, Case
// i.e "Test to see if this works? (Yes|No)".replaceAll('(Yes|No)', 'Yes!');
// i.e.2 "Test to see if this works? (Yes|No)".replaceAll('(yes|no)', 'Yes!', true);
String.prototype.replaceAll = function(_f, _r, _c){
var o = this.toString();
var r = '';
var s = o;
var b = 0;
var e = -1;
if(_c){ _f = _f.toLowerCase(); s = o.toLowerCase(); }
while((e=s.indexOf(_f)) > -1)
{
r += o.substring(b, b+e) + _r;
s = s.substring(e+_f.length, s.length);
b += e+_f.length;
}
// Add Leftover
if(s.length>0){ r+=o.substring(o.length-s.length, o.length); }
// Return New String
return r;
};
答案 12 :(得分：1)
我刚刚编写了一个基准测试并测试了前三个答案。
似乎对于短字符串（<500个字符）
投票次数第二多的答案比投票次数第二多的答案要快。
对于长字符串（将“ .repeat（300）”添加到测试字符串中）来说，答案1的速度更快，其次是第二和第三。
注意：
以上内容适用于使用v8引擎（铬/铬等）的浏览器。
使用firefox（SpiderMonkey引擎）的结果完全不同
自己检查！！ 带有第三种解决方案的Firefox似乎是
第一个解决方案的速度比Chrome快4.5倍...疯狂：D
function log(data) {
document.getElementById("log").textContent += data + "\n";
}
benchmark = (() => {
time_function = function(ms, f, num) {
var z;
var t = new Date().getTime();
for (z = 0;
((new Date().getTime() - t) < ms); z++) f(num);
return (z / ms)
} // returns how many times the function was run in "ms" milliseconds.
function benchmark() {
function compare(a, b) {
if (a[1] > b[1]) {
return -1;
}
if (a[1] < b[1]) {
return 1;
}
return 0;
}
// functions
function replace1(s) {
s.replace(/foo/g, "bar")
}
String.prototype.replaceAll2 = function(_f, _r){
var o = this.toString();
var r = '';
var s = o;
var b = 0;
var e = -1;
// if(_c){ _f = _f.toLowerCase(); s = o.toLowerCase(); }
while((e=s.indexOf(_f)) > -1)
{
r += o.substring(b, b+e) + _r;
s = s.substring(e+_f.length, s.length);
b += e+_f.length;
}
// Add Leftover
if(s.length>0){ r+=o.substring(o.length-s.length, o.length); }
// Return New String
return r;
};
String.prototype.replaceAll = function(str1, str2, ignore) {
return this.replace(new RegExp(str1.replace(/([\/\,\!\\\^\$\{\}\[\]\(\)\.\*\+\?\|\<\>\-\&])/g, "\\$&"), (ignore ? "gi" : "g")), (typeof(str2) == "string") ? str2.replace(/\$/g, "$$$$") : str2);
}
function replace2(s) {
s.replaceAll("foo", "bar")
}
function replace3(s) {
s.split('foo').join('bar');
}
function replace4(s) {
s.replaceAll2("foo", "bar")
}
funcs = [
[replace1, 0],
[replace2, 0],
[replace3, 0],
[replace4, 0]
];
funcs.forEach((ff) => {
console.log("Benchmarking: " + ff[0].name);
ff[1] = time_function(2500, ff[0], "foOfoobarBaR barbarfoobarf00".repeat(10));
console.log("Score: " + ff[1]);
})
return funcs.sort(compare);
}
return benchmark;
})()
log("Starting benchmark...\n");
res = benchmark();
console.log("Winner: " + res[0][0].name + " !!!");
count = 1;
res.forEach((r) => {
log((count++) + ". " + r[0].name + " score: " + Math.floor(10000 * r[1] / res[0][1]) / 100 + ((count == 2) ? "% *winner*" : "% speed of winner.") + " (" + Math.round(r[1] * 100) / 100 + ")");
});
log("\nWinner code:\n");
log(res[0][0].toString());<textarea rows="50" cols="80" style="font-size: 16; resize:none; border: none;" id="log"></textarea>
单击按钮后，测试将运行10s（+ 2s）。
我的结果（在同一台电脑上）：
Chrome/Linux Ubuntu 64:
1. replace1 score: 100% *winner* (766.18)
2. replace4 score: 99.07% speed of winner. (759.11)
3. replace3 score: 68.36% speed of winner. (523.83)
4. replace2 score: 59.35% speed of winner. (454.78)
Firefox/Linux Ubuntu 64
1. replace3 score: 100% *winner* (3480.1)
2. replace1 score: 13.06% speed of winner. (454.83)
3. replace4 score: 9.4% speed of winner. (327.42)
4. replace2 score: 4.81% speed of winner. (167.46)
很好吃吗？
随意添加更多测试结果
Chrome/Windows 10
1. replace1 score: 100% *winner* (742.49)
2. replace4 score: 85.58% speed of winner. (635.44)
3. replace2 score: 54.42% speed of winner. (404.08)
4. replace3 score: 50.06% speed of winner. (371.73)
Firefox/Windows 10
1. replace3 score: 100% *winner* (2645.18)
2. replace1 score: 30.77% speed of winner. (814.18)
3. replace4 score: 22.3% speed of winner. (589.97)
4. replace2 score: 12.51% speed of winner. (331.13)
Edge/Windows 10
1. replace1 score: 100% *winner* (1251.24)
2. replace2 score: 46.63% speed of winner. (583.47)
3. replace3 score: 44.42% speed of winner. (555.92)
4. replace4 score: 20% speed of winner. (250.28)
Galaxy Note 4上的Chrome
1. replace4 score: 100% *winner* (99.82)
2. replace1 score: 91.04% speed of winner. (90.88)
3. replace3 score: 70.27% speed of winner. (70.15)
4. replace2 score: 38.25% speed of winner. (38.18)
答案 13 :(得分：-1)
@Gumbo添加了额外的答案-user.email.replace（/ foo / gi，“ bar”）;
/foo/g - Refers to the all string to replace matching the case sensitive
/foo/gi - Refers to the without case sensitive and replace all For Eg: (Foo, foo, FoO, fOO)