Is it possible to combine regular expressions in javascript.
For ex:
var lower = /[a-z]/;
var upper = /[A-Z]/;
var alpha = upper|lower;//Is this possible?
ie. can i assign regular expressions to variables and combine those variables using pattern matching characters as we do in regular expressions
The answer is yes!
let lower = /[a-z]/;
let upper = /[A-Z]/;
Then you can combine them dynamically by using the .source attribute:
let finalRe = new RegExp(lower.source + "|" + upper.source);
new RegExp(/a/) and just /a/? The latter already creates a RegExp instance.
If regexps are not known beforehand,
var one = /[a-z]/;
var two = /[A-Z]/;
var one_or_two = new RegExp("(" + one.source + ")|(" + two.source + ")")
use a general function:
const getComposedRegex = (...regexes) => new RegExp(regexes.map(regex => regex.source).join("|"))
Then call it with any number of Regexes.
const reg1 = /[w]{3}/i
const reg2 = /http/i
const composedReg = getComposedRegex(reg1, reg2)
If this is something you only need to do once or twice, I'd stick with doing it on a per-case basis as suggested by other answers.
If you need to do a lot, however, a couple of helper functions might improve readability. For example:
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);
And here's the code if you want to use those functions:
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));
};
The alternatives are wrapped in non-capturing groups and combined with the disjunction operator, making this a somewhat more robust approach for more complex regular expressions.
Note that you will need to include this code before calling the helper functions!
Based on Bry6n answer here's a solution I use:
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,
);
alpha = new RegExp( lower.source + "|" + upper.source );
console.log( alpha );
// /[a-z]|[A-Z]/
For those looking for a simple example with modern syntax:
const lower = /[a-z]/;
const upper = /[A-Z]/;
const alpha = new RegExp(`(${lower.source}|${upper.source})`);
This approach is not only useful for dynamic regex but also for readability.
Another function, which also merges the /flags:
function combineRegExp(...patterns) {
const pattern = patterns.map(p => p.source).join("|")
const flags = new Set(patterns.flatMap(p => [...p.flags]))
return new RegExp(pattern, [...flags].join(""))
}
/[a-zA-Z]/?