web-dev-qa-db-fra.com

Combinaison d'expressions régulières en Javascript

Est-il possible de combiner des expressions régulières en javascript?.

Pour ex: 

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

c'est à dire. puis-je affecter des expressions régulières à des variables et combiner ces variables en utilisant des caractères de correspondance de modèle tels que nous faisons dans des expressions régulières

javascriptregex
31
Jinu Joseph Daniel

La réponse est oui! Vous devez initialiser la variable sous la classe RegExp:

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

par conséquent, les expressions rationnelles peuvent être créées dynamiquement. Après création:

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

Ensuite, vous pouvez les combiner normalement, oui.

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

Si les expressions rationnelles ne sont pas connues à l'avance, 

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

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

Si c'est quelque chose que vous ne devez faire qu'une ou deux fois, je continuerais de le faire au cas par cas, comme suggéré par d'autres réponses.

Toutefois, si vous devez en faire beaucoup, quelques fonctions d’aide peuvent améliorer la lisibilité. Par exemple:

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

Et voici le code si vous souhaitez utiliser ces fonctions:

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

Les alternatives sont encapsulées dans des groupes sans capture et combinées à l'opérateur disjonction, ce qui en fait une approche un peu plus robuste pour les expressions régulières plus complexes.

Notez que vous devrez inclure ce code avant en appelant les fonctions d'assistance!

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

Basé sur la réponse de Bry6n, voici une solution que j'utilise:

const Regexes = {
  Empty: /^$/,
  Minus: /^[-]$/,
  DotAndNumber: /^\.\d+$/,
  NumberAndDot: /^\d+\.$/,
  Float: /^[-]?\d+(\.\d+)?$/,
};

const orRegex = (...regexes) =>
  new RegExp(regexes.map(r => r.source).join('|'));

const FloatInputRegex = orRegex(
  Regexes.Empty,
  Regexes.Minus,
  Regexes.DotAndNumber,
  Regexes.NumberAndDot,
  Regexes.Float,
);
0
Sebastien Lorber