Pregunta ¿Cómo se usa una variable en una expresión regular?


Me gustaría crear un método String.replaceAll () en JavaScript y estoy pensando que el uso de un RegEx sería la forma más rápida de hacerlo. Sin embargo, no puedo entender cómo pasar una variable a un RegEx. Puedo hacer esto ya que reemplazará todas las instancias de "B" con "A".

"ABABAB".replace(/B/g, "A");

Pero quiero hacer algo como esto:

String.prototype.replaceAll = function(replaceThis, withThis) {
    this.replace(/replaceThis/g, withThis);
};

Pero obviamente esto solo reemplazará el texto "replaceThis" ... entonces, ¿cómo paso esta variable a mi cadena RegEx?


980
2018-01-30 00:11


origen


Respuestas:


En lugar de usar el /regex/g sintaxis, puedes construir un nuevo RegExp objeto:

var replace = "regex";
var re = new RegExp(replace,"g");

Puede crear dinámicamente objetos regex de esta manera. Entonces harás:

"mystring".replace(re, "newstring");

1379
2018-01-30 00:15



Como mencionó Eric Wendelin, puedes hacer algo como esto:

str1 = "pattern"
var re = new RegExp(str1, "g");
"pattern matching .".replace(re, "regex");

Esto rinde "regex matching .". Sin embargo, fallará si str1 es ".". Esperarías que el resultado sea "pattern matching regex", reemplazando el período con "regex", pero resultará ser ...

regexregexregexregexregexregexregexregexregexregexregexregexregexregexregexregexregexregex

Esto se debe a que, aunque "." es un String, en el constructor RegExp se sigue interpretando como una expresión regular, es decir, cualquier carácter que no sea salto de línea, es decir, todos los caracteres de la cadena. Para este propósito, la siguiente función puede ser útil:

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

Entonces puedes hacer:

str1 = "."
var re = new RegExp(RegExp.quote(str1), "g");
"pattern matching .".replace(re, "regex");

flexible "pattern matching regex".


167
2018-01-30 01:02



"ABABAB".replace(/B/g, "A");

Como siempre: no use expresiones regulares a menos que sea necesario. Para una cadena de reemplazo simple, el modismo es:

'ABABAB'.split('B').join('A')

Entonces no tiene que preocuparse por los problemas de cotización mencionados en la respuesta de Gracenotes.


83
2018-02-01 03:43



Para cualquiera que quiera usar variables con el partido método, esto funcionó para mí

var alpha = 'fig';
'food fight'.match(alpha + 'ht')[0]; // fight

27
2017-11-28 15:32



Esta:

var txt=new RegExp(pattern,attributes);

es equivalente a esto:

var txt=/pattern/attributes;

Ver http://www.w3schools.com/jsref/jsref_obj_regexp.asp.


20
2018-01-30 00:19



this.replace( new RegExp( replaceThis, 'g' ), withThis );

14
2018-01-30 00:16



String.prototype.replaceAll = function (replaceThis, withThis) {
   var re = new RegExp(replaceThis,"g"); 
   return this.replace(re, withThis);
};
var aa = "abab54..aba".replaceAll("\\.", "v");

Prueba con esto herramienta 


9
2018-02-01 09:14



Desea construir dinámicamente la expresión regular y para esto la solución correcta es usar el new RegExp(string) constructor. Para que el constructor trate caracteres especiales literalmente, debes escapar de ellos. Hay una función incorporada en widget de autocompletar jQuery UI llamado $.ui.autocomplete.escapeRegex:

[...] puede hacer uso del built-in    $.ui.autocomplete.escapeRegex función. Tomará una sola cadena   argumento y escape todos los caracteres regex, haciendo que el resultado sea seguro para   pasar a new RegExp().

Si está utilizando la interfaz de usuario de jQuery, puede usar esa función o copiar su definición de la fuente:

function escapeRegex(value) {
    return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
}

Y úsalo así:

"[z-a][z-a][z-a]".replace(new RegExp(escapeRegex("[z-a]"), "g"), "[a-z]");
//            escapeRegex("[z-a]")       -> "\[z\-a\]"
// new RegExp(escapeRegex("[z-a]"), "g") -> /\[z\-a\]/g
// end result                            -> "[a-z][a-z][a-z]"

7
2017-09-14 19:55



Si bien puede crear RegExp dinámicamente creado (según las otras respuestas a esta pregunta), me haré eco de mi comentario de un publicación similar: La forma funcional de String.replace () es extremadamente útil y en muchos casos reduce la necesidad de objetos RegExp creados dinámicamente. (lo cual es un poco molesto porque tienes que expresar la entrada al constructor RegExp como una cadena en lugar de usar el formato literal barras / [A-Z] + / regexp)


3
2018-01-30 01:02



Aquí hay otra implementación de replaceAll:

    String.prototype.replaceAll = function (stringToFind, stringToReplace) {
        if ( stringToFind == stringToReplace) return this;
        var temp = this;
        var index = temp.indexOf(stringToFind);
        while (index != -1) {
            temp = temp.replace(stringToFind, stringToReplace);
            index = temp.indexOf(stringToFind);
        }
        return temp;
    };

3
2018-05-08 10:30



Para satisfacer mi necesidad de insertar una variable / alias / función en una expresión regular, esto es lo que se me ocurrió:

oldre = /xx\(""\)/;
function newre(e){
    return RegExp(e.toString().replace(/\//g,"").replace(/xx/g, yy), "g")
};

String.prototype.replaceAll = this.replace(newre(oldre), "withThis");

donde 'oldre' es la expresión regular original que quiero insertar una variable, 'xx' es el marcador de posición para esa variable / alias / función, y 'yy' es el nombre real de la variable, alias o función.


3
2018-06-05 04:22