solo - expresiones regulares javascript ejemplos

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

Question

¿Cuál es la forma más rápida de reemplazar todas las instancias de una cadena / carácter en una cadena en JavaScript? ¿Un while , un for loop, una expresión regular?

Answer 1

@Gumbo agregando respuesta extra - 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

Answer 2

Creo que la respuesta real es que depende completamente de cómo se vean tus entradas. JsFiddle un JsFiddle para probar un montón de estos y un par de mis propios contra varios insumos. No importa cómo mire los resultados, no veo un ganador claro.

• RegExp no fue el más rápido en ninguno de los casos de prueba, pero tampoco fue malo.
• El enfoque de división / unión parece más rápido para los reemplazos dispersos.

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

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

Answer 3

Intenté varias de estas sugerencias después de darme cuenta de que una implementación que había escrito probablemente hace cerca de 10 años no funcionó completamente (error de producción desagradable en un sistema olvidado hace mucho tiempo, ¿no es así?) ... lo que noté es que los que probé (no los probé a todos) tenían el mismo problema que el mío, es decir, no reemplazarían TODOS los casos, solo el primero, al menos para mi caso de prueba de obteniendo "test .... txt" hasta "test.txt" reemplazando ".." con "." ... tal vez me perdí la situación de expresión regular? Pero yo divago...

Así que, 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é haciendo esto dentro de un circuito cerrado, por supuesto, pero ese siempre es 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 ayude a alguien!

Answer 4

Lo más fácil sería usar una expresión regular con el indicador g para reemplazar todas las instancias:

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

Esto reemplazará todas las apariciones de foo con bar en la cadena de caracteres. Si solo tienes una cadena, puedes convertirla en un objeto RegExp como este:

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

Answer 5

No sé qué es lo más rápido, pero sé qué es lo más legible: lo más corto y lo más simple. Incluso si es un poco más lento que otras soluciones, vale la pena usarlo.

Así que use:

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

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

Answer 6

Pensándolo bien en un problema de velocidad, creo que el ejemplo que distingue entre mayúsculas y minúsculas en el enlace anterior sería 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".

Answer 7

Pruebe esto 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 muchas otras fallan:

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

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

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

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

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

Answer 8

Puedes usar lo siguiente:

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

o

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

Esto reemplazará todos los caracteres que no son letras o números a (''_''). Simplemente cambia el valor de subrayado para lo que quieras reemplazarlo.

Answer 9

También puedes probar:

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

Answer 10

Usar objeto Regex como este

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

Reemplazará toda aparición de " en '' .

Answer 11

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

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

Answer 12

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

Answer 13

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

newString ahora es ''Thas as strang''