替换字符串中字符的所有实例的最快方法

2020/09/22 14:41 · javascript ·  · 0评论

用JavaScript替换字符串中所有字符串/字符实例的最快方法是什么?A while,- for循环,正则表达式?

最简单的方法是使用带有gflag 的正则表达式替换所有实例:

str.replace(/foo/g, "bar")

这将替换所有出现的foobar字符串中str如果只有一个字符串,则可以将其转换为RegExp对象,如下所示:

var pattern = "foobar",
    re = new RegExp(pattern, "g");

尝试以下replaceAll: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!!!

让我知道您是否可以打破它,或者您有更好的东西,但是请确保它可以通过这四个测试。

var mystring = 'This is a string';
var newString = mystring.replace(/i/g, "a");

newString现在是'Thas as strang'

Also you can try:

string.split('foo').join('bar');

您可以使用以下内容:

newStr = str.replace(/[^a-z0-9]/gi, '_');

要么

newStr = str.replace(/[^a-zA-Z0-9]/g, '_');

这会将所有不是字母或数字的字符替换为('_')。只需更改下划线值即可替换任何要替换的内容。

我只是从速度问题考虑一下,我相信上面链接中提供的区分大小写的示例将是迄今为止最快的解决方案。

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将是“这是对紧急广播系统的测试”。

我认为真正的答案是,这完全取决于您输入的内容。我创建了一个JsFiddle来尝试其中的一些以及我自己的一些反对各种输入的方法。无论我如何看待结果,都看不到明确的赢家。

  • RegExp并不是在所有测试用例中都最快的,但是也不错。
  • 对于稀疏替换,拆分/合并方法似乎最快。
  • 我写的这篇文章似乎对于小投入和密集替换来说最快:

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

像这样使用Regex对象

var regex = new RegExp('"', 'g');
str = str.replace(regex, '\'');

它将取代所有发生"'

我不知道最快的是什么,但是我知道最可读的是-最短和最简单的东西。即使它比其他解决方案慢一点,也值得使用。

因此使用:

 "string".replace("a", "b");
 "string".replace(/abc?/g, "def");

享受更好的代码而不是更快(好吧... 1/100000秒没什么区别)和丑陋的代码。;)

在意识到我大概在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;

}

希望能对某人有所帮助!

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

我只是编写了一个基准测试并测试了前三个答案。看来,对于短字符串(<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)。

我的结果(在同一台PC上):

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)

Chrome on Galaxy Note 4

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)

使用对象replace()方法String

如所选答案中所述,/ g标志应在正则表达式中使用,以便替换字符串中子字符串的所有实例。

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

演示

本文地址:http://javascript.askforanswer.com/tihuanzifuchuanzhongzifudesuoyoushilidezuikuaifangfa.html
文章标签: ,   ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!