Combinando expresiones regulares en Javascript

Question

¿Es posible combinar expresiones regulares en javascript.

Para ex:

var lower = /[a-z]/; 
var upper = /[A-Z]/; 
var alpha = upper|lower;//Is this possible? 

es decir. ¿Puedo asignar expresiones regulares a las variables y combinar estas variables utilizando caracteres de coincidencia de patrones como que hacemos en las expresiones regulares

Answer 1

La respuesta es sí! Debe inicializar la variable en la clase RegExp:

var lower = new RegExp(/--RegexCode--/); 
var upper = new RegExp(/--RegexCode--/); 

por lo tanto, regex puede crearse dinámicamente. Después de la creación:

"sampleString".replace(/--whatever it should do--/); 

Entonces puede combinarlos normalmente, sí.

var finalRe = new RegExp(lower.source + "|" + upper.source); 

Answer 2

Si las expresiones regulares no se conocen de antemano,

var one = /[a-z]/; 
var two = /[A-Z]/; 

var one_or_two = new RegExp("(" + one.source + ")|(" + two.source + ")") 

Answer 3

alpha = new RegExp(lower.source + "|" + upper.source); 
console.log(alpha); 
// /[a-z]|[A-Z]/ 

Answer 4

Si esto es algo que sólo tiene que hacer una o dos veces, me quedo con hacerlo en función de cada caso, según lo sugerido por otras respuestas.

Si necesita hacer mucho, sin embargo, un par de funciones auxiliares pueden mejorar la legibilidad. Por ejemplo:

var lower = /[a-z]/, 
    upper = /[A-Z]/, 
    digit = /[0-9]/; 

// All of these are equivalent, and will evaluate to /(?:a-z)|(?:A-Z)|(?:0-9)/ 
var anum1 = RegExp.any(lower, upper, digit), 
    anum2 = lower.or(upper).or(digit), 
    anum3 = lower.or(upper, digit); 

Y aquí está el código si desea utilizar dichas funciones:

RegExp.any = function() { 
    var components = [], 
     arg; 

    for (var i = 0; i < arguments.length; i++) { 
     arg = arguments[i]; 
     if (arg instanceof RegExp) { 
      components = components.concat(arg._components || arg.source); 
     } 
    } 

    var combined = new RegExp("(?:" + components.join(")|(?:") + ")"); 
    combined._components = components; // For chained calls to "or" method 
    return combined; 
}; 

RegExp.prototype.or = function() { 
    var args = Array.prototype.slice.call(arguments); 
    return RegExp.any.apply(null, [this].concat(args)); 
}; 

Las alternativas están envueltos en grupos de no-captura y se combinan con el operador de disyunción, haciendo de este un poco más enfoque robusto para expresiones regulares más complejas.

Tenga en cuenta que deberá incluir este código antes de ¡llamando a las funciones auxiliares!