Javascript multiple regex pattern

Quote the periods, replace the X's with \d+, and join them all together with pipes:

const allowedIPpatterns = [ 
  "10.X.X.X", 
  "12.122.X.X",
  "12.211.X.X",
  "64.X.X.X",
  "64.23.X.X",
  "74.23.211.92"   //, etc.
];

const allowedRegexStr = '^(?:' + 
  allowedIPpatterns.
    join('|').
    replace(/\./g, '\\.').
    replace(/X/g, '\\d+') + 
  ')$';

 const allowedRegexp = new RegExp(allowedRegexStr);

Then you're all set:

 '10.1.2.3'.match(allowedRegexp) // => ['10.1.2.3']
 '100.1.2.3'.match(allowedRegexp) // => null

How it works:

First, we have to turn the individual IP patterns into regular expressions matching their intent. One regular expression for "all IPs of the form '12.122.X.X'" is this:

^12\.122\.\d+\.\d+$

• ^ means the match has to start at the beginning of the string; otherwise, 112.122.X.X IPs would also match.
• 12 etc: digits match themselves
• \.: a period in a regex matches any character at all; we want literal periods, so we put a backslash in front.
• \d: shorthand for [0-9]; matches any digit.
• +: means "1 or more" - 1 or more digits, in this case.
• $: similarly to ^, this means the match has to end at the end of the string.

So, we turn the IP patterns into regexes like that. For an individual pattern you could use code like this:

const regexStr = `^` + ipXpattern. 
  replace(/\./g, '\\.').
  replace(/X/g, '\\d+') + 
  `$`;

Which just replaces all .s with \. and Xs with \d+ and sticks the ^ and $ on the ends.

(Note the doubled backslashes; both string parsing and regex parsing use backslashes, so wherever we want a literal one to make it past the string parser to the regular expression parser, we have to double it.)

In a regular expression, the alternation this|that matches anything that matches either this or that. So we can check for a match against all the IP's at once if we to turn the list into a single regex of the form re1|re2|re3|...|relast.

Then we can do some refactoring to make the regex matcher's job easier; in this case, since all the regexes are going to have ^...$, we can move those constraints out of the individual regexes and put them on the whole thing: ^(10\.\d+\.\d+\.\d+|12\.122\.\d+\.\d+|...)$. The parentheses keep the ^ from being only part of the first pattern and $ from being only part of the last. But since plain parentheses capture as well as group, and we don't need to capture anything, I replaced them with the non-grouping version (?:..).

And in this case we can do the global search-and-replace once on the giant string instead of individually on each pattern. So the result is the code above:

const allowedRegexStr = '^(?:' + 
  allowedIPpatterns.
    join('|').
    replace(/\./g, '\\.').
    replace(/X/g, '\\d+') + 
  ')$';

That's still just a string; we have to turn it into an actual RegExp object to do the matching:

const allowedRegexp = new RegExp(allowedRegexStr);

As written, this doesn't filter out illegal IPs - for instance, 10.1234.5678.9012 would match the first pattern. If you want to limit the individual byte values to the decimal range 0-255, you can use a more complicated regex than \d+, like this:

(?:\d{1,2}|1\d{2}|2[0-4]\d|25[0-5])

That matches "any one or two digits, or '1' followed by any two digits, or '2' followed by any of '0' through '4' followed by any digit, or '25' followed by any of '0' through '5'". Replacing the \d with that turns the full string-munging expression into this:

const allowedRegexStr = '^(?:' + 
  allowedIPpatterns.
    join('|').
    replace(/\./g, '\\.').
    replace(/X/g, '(?:\\d{1,2}|1\\d{2}|2[0-4]\\d|25[0-5])') + 
  ')$';

And makes the actual regex look much more unwieldy:

^(?:10\.(?:\d{1,2}|1\d{2}|2[0-4]\d|25[0-5])\.(?:\d{1,2}|1\d{2}|2[0-4]\d|25[0-5]).(?:\d{1,2}|1\d{2}|2[0-4]\d|25[0-5])|12\.122\....

but you don't have to look at it, just match against it. :)