Łączenie wyrażeń regularnych w JavaScript

Question

Czy możliwe jest łączenie wyrażeń regularnych w javascript.

Dla ex:

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

tj. mogę przypisać do zmiennych wyrażeń regularnych i połączyć te zmienne przy użyciu wzorca dopasowania znaków jako robimy w wyrażeniach regularnych

Answer 1

Odpowiedź brzmi: tak! Należy zainicjować zmienną w ramach klasy RegExp:

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

dlatego też wyrażenie regularne może być tworzone dynamicznie. Po utworzeniu:

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

Następnie można je łączyć w zwykły sposób, tak.

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

Answer 2

Jeśli wyrażenia regularne nie są znane wcześniej,

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

Jeśli jest coś, co trzeba zrobić tylko raz lub dwa razy, będę trzymać się robi to na podstawie na razie jako sugerowane przez innych odpowiedzi.

Jeśli jednak potrzebujesz dużo, kilka funkcji pomocniczych może poprawić czytelność. Na przykład:

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

A oto kod, jeśli chcesz korzystać z tych funkcji:

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

Alternatywy są zapakowane w niewyspecjalizowanych przechwytywania grup i połączone z operatorem alternatywy, dzięki czemu jest nieco bardziej niezawodne podejście do bardziej złożonych wyrażeń regularnych.

Należy pamiętać, że przed należy podać ten kod, wywołując funkcje pomocnika!