Самый быстрый метод для замены всех экземпляров символа в строке

Какой самый быстрый способ заменить все экземпляры строки / символа в строке в JavaScript? while, forпетля, регулярное выражение?

Источник

13 ответов

Решение

Проще всего было бы использовать регулярное выражение с g флаг для замены всех экземпляров:

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

Это заменит все случаи foo с bar в строке str, Если у вас есть только строка, вы можете преобразовать ее в объект RegExp следующим образом:

var pattern = "foobar",
    re = new RegExp(pattern, "g");
Источник

Попробуйте это заменить все: http://dumpsite.com/forum/index.php?topic=4.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 теста.

Источник 
var mystring = 'This is a string';
var newString = mystring.replace(/i/g, "a");

newString теперь "Это как странка"

Источник

Также вы можете попробовать:

string.split('foo').join('bar');
Источник

Вы можете использовать следующее:

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

или же

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

Это заменит все символы, которые не являются буквой или цифрой ('_'). Просто измените значение подчеркивания на то, что вы хотите заменить.

Источник

Используйте объект Regex, как это

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

Это заменит все возникновение " в ',

Источник

Я думаю, что реальный ответ заключается в том, что это полностью зависит от того, как выглядят ваши материалы. Я создал JsFiddle, чтобы опробовать кучу таких и несколько своих на разных входах. Независимо от того, как я смотрю на результаты, я не вижу явного победителя.

  • RegExp не был самым быстрым ни в одном из тестовых случаев, но он также не был плохим.
  • Подход Split/Join кажется наиболее быстрым для редких замен.

  • Этот, который я написал, кажется самым быстрым для небольших входов и плотных замен:

    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;
}
Источник

Если подумать об этом из-за проблемы со скоростью, я считаю, что чувствительный к регистру пример, приведенный в ссылке выше, был бы самым быстрым решением.

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 будет "Это тест системы аварийного вещания".

Источник

Я только что написал тест и проверил первые 3 ответа. Кажется, что для коротких строк (<500 символов)
третий по количеству голосов ответ быстрее, чем второй по количеству голосов.

Для длинных строк (добавьте в тестовую строку ".repeat(300)") быстрее будет ответ 1, за которым следуют второй и третий.

Примечание:

Вышесказанное верно для браузеров, использующих движок v8 (хром / хром и т. Д.).
С firefox (движком SpiderMonkey) результаты совсем другие.
Проверьте сами!! Firefox с третьим решением кажется
более чем в 4,5 раза быстрее, чем Chrome с первым решением... сумасшедший: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>

Тест будет длиться 10 с (+2 с) после нажатия кнопки.

Мои результаты (на том же компьютере):

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 на 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)
Источник

Что самое быстрое, я не знаю, но я знаю, что самое читаемое - что самое короткое и простое. Даже если это немного медленнее, чем другое решение, его стоит использовать.

Так что используйте:

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

И наслаждайтесь хорошим кодом вместо более быстрого (ну... 1/100000 сек. - не разница) и безобразного.;)

Источник

Использовать replace() метод String объект.

Как уже упоминалось в выбранном ответе, в регулярном выражении должен использоваться флаг /g, чтобы заменить все вхождения подстроки в строке.

Источник

Я попробовал некоторые из этих предложений после того, как понял, что реализация, о которой я писал, вероятно, около 10 лет назад, на самом деле не работала полностью (неприятная ошибка в работе системы, о которой давно забыли, не так ли?!)... я заметил, что те, которые я пробовал (я не пробовал их все), имели ту же проблему, что и моя, то есть они не заменяли КАЖДЫЙ случай, только первый, по крайней мере, для моего тестового примера получить "test....txt" до "test.txt", заменив ".." на "."... может быть, я пропустил так regex ситуацию? Но я отвлекся...

Итак, я переписал мою реализацию следующим образом. Это чертовски просто, хотя я подозреваю, что это не самое быстрое, но я также не думаю, что разница будет иметь значение с современными двигателями 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;
};
Источник

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

DEMO

Источник
Другие вопросы по тегам