在没有正则表达式的情况下替换所有我在哪里可以使用 G

Question

So I have the following:

var token = '[token]';
var tokenValue = 'elephant';
var string = 'i have a beautiful [token] and i sold my [token]';
string = string.replace(token, tokenValue);

The above will only replace the first [token] and leave the second on alone.

If I were to use regex I could use it like

string = string.replace(/[token]/g, tokenValue);

And this would replace all my [tokens]

However I don't know how to do this without the use of //

Answer 1

I have found split/join satisfactory enough for most of my cases. A real-life example:

myText.split("\n").join('<br>');

Answer 2

Why not replace the token every time it appears with a do while loop?

var index = 0;
do {
    string = string.replace(token, tokenValue);
} while((index = string.indexOf(token, index + 1)) > -1);

Answer 3

string = string.replace(new RegExp("\\[token\\]","g"), tokenValue);

Answer 4

Caution with the accepted answer, the replaceWith string can contain the inToReplace string, in which case there will be an infinite loop...

Here a better version:

function replaceSubstring(inSource, inToReplace, inReplaceWith)
{
    var outString = [];
    var repLen = inToReplace.length;

    while (true)
    {
        var idx = inSource.indexOf(inToReplace);
        if (idx == -1)
        {
            outString.push(inSource);
            break;
        }

        outString.push(inSource.substring(0, idx))
        outString.push(inReplaceWith);

        inSource = inSource.substring(idx + repLen);
    }

    return outString.join("");
}

Answer 5

you can get the first occurance using indexOf:

var index=str.indexOf(token);

and then have a function like this to replace it

String.prototype.replaceAt=function(index, tokenvalue) {
      return this.substr(0, index) + character + this.substr(index+character.length);
   }

Answer 6

"[.token.*] nonsense and [.token.*] more nonsense".replace("[.token.*]", "some", "g");

Will produce:

"some nonsense and some more nonsense"

Answer 7

I realized that the answer from @TheBestGuest won't work for the following example as you will end up in an endless loop:

var stringSample= 'CIC'; 
var index = 0; 
do { stringSample = stringSample.replace('C', 'CC'); } 
while((index = stringSample.indexOf('C', index + 1)) > -1);

So here is my proposition for replaceAll method written in TypeScript:

 let matchString = 'CIC'; let searchValueString= 'C'; let replacementString ='CC'; matchString = matchString.split(searchValueString).join(replacementString); console.log(matchString);

Answer 8

Unfortunately since Javascript's string replace() function doesn't let you start from a particular index, and there is no way to do in-place modifications to strings it is really hard to do this as efficiently as you could in saner languages.

• .split().join() isn't a good solution because it involves the creation of a load of strings (although I suspect V8 does some dark magic to optimise this).
• Calling replace() in a loop is a terrible solution because replace starts its search from the beginning of the string every time. This is going to lead to O(N^2) behaviour! It also has issues with infinite loops as noted in the answers here.
• A regex is probably the best solution if your replacement string is a compile time constant, but if it isn't then you can't really use it. You should absolutely not try and convert an arbitrary string into a regex by escaping things.

One reasonable approach is to build up a new string with the appropriate replacements:

function replaceAll(input: string, from: string, to: string): string {
  const fromLen = from.length;
  let output = "";
  let pos = 0;
  for (;;) {
    let matchPos = input.indexOf(from, pos);
    if (matchPos === -1) {
      output += input.slice(pos);
      break;
    }
    output += input.slice(pos, matchPos);
    output += to;
    pos = matchPos + fromLen;
  }
  return output;
}

I benchmarked this against all the other solutions (except calling replace() in a loop which is going to be terrible) and it came out slightly faster than a regex, and about twice as fast as split / join .

Edit: This is almost the same method as Stefan Steiger's answer which I totally missed for some reason. However his answer still uses .join() for some reason which makes it 4 times slower than mine.