替换字符串中的所有匹配项，并避免RegExp转义

Question

Is that possible, without a loss of performance, to replace all occurrences of a substring with another string, and completely avoid using RegExp along the way? Ie remove RegExp out of equation, just to make sure there is no RegExp magic happening when you forget to properly escape something like + .

'1+1 2+2'.replace('+', '-') -> only first "+" is replaced
'1+1 2+2'.replace(/\+/g, '-') -> undesired regexp complexities

UPDATE 1

This does not solve the escape problem:

String.prototype.replaceAll= function(search, replace) {
    return this.replace(new RegExp(search, "g"), replace);
}

UPDATE 2

Doing programmatic unescape is a performance hit:

RegExp.quote = function(str) {
    return (str+'').replace(/[.?*+^$[\]\\(){}|-]/g, "\\$&");
};

Answer 1

Alternatively, based on Florian Margaine's code and test case:

    window.replaceQuick = function(subject, search, replace) {
      var index = -1, offset = 0;
      var result = '';
      while ((index = subject.indexOf(search, offset)) !== -1) {
        result += subject.substring(offset, index) + replace;
        offset = index + search.length;
      }
      return result + search.substring(offset);
    }

Since I'm doing partial extractions it should get a better performance.

http://jsperf.com/replaceall-regex-or-not/3

Answer 2

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

This works. However, is it more performant that using a regex? Let's try it.

Here is the regex function I benchmarked against:

function replaceAllRegex(str, search, replace) {
    return str.replace(new RegExp(search.replace(/[.?*+^$[\]\\(){}|-]/g, "\\$&"), 'g'), replace);
}

According to jsperf , the non-regex versions does ~8k ops/sec, while the regex version does ~123k ops/sec. When automatically escaping the characters.

You should review your view of "escaping is a performance hit".

If what you want is performance, then use the regex version.

PS: Roel's version can be faster than regex.