Método más rápido para reemplazar todas las instancias de un carácter en una cadena

Prueba este 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);
} 

Es muy rápido, y funcionará para TODAS estas condiciones que muchos otros fallan en:

"x".replaceAll("x", "xyz");
// xyz

"x".replaceAll("", "xyz");
// xyzxxyz

"aA".replaceAll("a", "b", true);
// bb

"Hello???".replaceAll("?", "!");
// Hello!!!

Hazme saber si puedes romperlo, o tienes algo mejor, pero asegúrate de que pueda pasar estas 4 pruebas.

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

NewString ahora es 'Thas as a strang'

También puedes probar:

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

Puedes usar lo siguiente:

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

O

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

Esto va a reemplazar todos los caracteres que no son letra o números ('_'). Simplemente cambie el valor de subrayado para lo que quiera reemplazarlo.

Solo pensando en ello a partir de un problema de velocidad Creo que el ejemplo sensible a mayúsculas y minúsculas proporcionado en el enlace anterior sería, con mucho, la solución más rápida.

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 sería "Esta es una prueba del sistema de transmisión de emergencia."

Creo que la verdadera respuesta es que depende completamente de cómo se vean tus entradas. Creé un JsFiddle para probar un montón de estos y un par de los míos contra varias entradas. No importa cómo mire los resultados, no veo un ganador claro.

• La expresión regular no fue la más rápida en ninguno de los casos de prueba, pero tampoco estuvo mal.
• El enfoque de división/unión parece más rápido para reemplazos escasos.

• Este que escribí parece más rápido para pequeñas entradas y denso reemplazos:

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

Lo que es más rápido no lo sé, pero sé lo que es más legible: lo que es más corto y simple. Incluso si es un poco más lento que otra solución que vale la pena utilizar.

Así que use:

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

Y disfrutar de un buen código en lugar de más rápido (bien... 1/100000 seg. no es una diferencia) y feo. ;)

Use un objeto Regex como este

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

Reemplazará todas las ocurrencias de " en '.

Utilice el replace() método del objeto String.

Como se mencionó en la respuesta seleccionada, la bandera /g debe usarse en la expresión regular, para reemplazar todas las instancias de la subcadena en la cadena.

Probé varias de estas sugerencias después de darme cuenta de que una implementación que había escrito de esto probablemente hace cerca de 10 años en realidad no funcionaba completamente (error de producción desagradable en un sistema olvidado hace mucho tiempo, ¿no es siempre así?!)... lo que noté es que los que probé (no los probé todos) tenían el mismo problema que los míos, es decir, no reemplazarían CADA ocurrencia, solo la primera, al menos para mi caso de prueba de obtener "prueba"....txt "hasta" prueba.txt "reemplazando".." con "."... tal vez me perdí tan regex situación? Pero estoy divagando...

Por lo tanto, reescribí mi implementación de la siguiente manera. Es bastante simple, aunque sospecho que no es el más rápido, pero tampoco creo que la diferencia importe con los motores JS modernos, a menos que estés haciendo esto dentro de un bucle apretado, por supuesto, pero ese es siempre el caso para cualquier cosa...

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;

}

¡Espero que eso ayude a alguien!

// 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 añadiendo usuario de respuesta extra.correo.sustitúyase (/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