Find regular expressions

Question

Is there an existing algorithm to find all literal Regular Expression occurrences within a single line of valid JavaScript code?

Given that a literal Regular Expression cannot be multi-line, I need to detect all regular expressions within a single line of code, or more specifically - the beginning and end indexes for each regular expression, if they are present.

function enumRegex(textLine) {
    // magic happens here;
}

var testLine = 'var regEx1 = /one/; regEx2 = /two/;';

console.log(enumRegex(testLine));

Expected output: Array of index pairs (start and end index for each RegEx found):

[{13,17},{29,33}]

UPDATE: After playing with this: Is there a regular expression to detect a valid regular expression?, I'm not sure it would even work. So, if someone suggests using a regular expression to detect regular expressions, it would require an example that actually works. I'd rather hope to see an algorithm.

Answer 1

The only complication that stops you from doing /\/.+\/[a-z]*/g as your regex test is... well, it would fail to find itself, for starters. It doesn't like escaped backslashes.

Not a problem.

/\/(?:\\.|[^\/])+\/[a-z]*/g

So what does this regex do?

1. Look for / - this is the start of a regex... probably!
2. Look for one of more of either...
   • A backslash followed by any character (this is our escape-ignoring logic, note that "any character" excludes newlines)
   • OR any character that is not a forward slash
3. Find the / that indicates the end of the regex
4. Find any modifiers attached to the regex literal.

And... done! If this regex matches something, then it has found something that looks like a regex. However... that's not to say you've found a valid regex. For that, we need some validation.

First, let's capture the regex and modifiers:

/\/((?:\\.|[^\/])+)\/([a-z]*)/g

Now, for each match, we attempt to create a regex object from it:

isValid = true;
try {
    new RegExp(match[1], match[2]);
    // pass suspect regex as first argument, modifiers as second
}
catch(e) {
    isValid = false;
}

So your final code might look something like...

function enumRegex(textLine) {
    var parser = new RegExp("/((?:\\\\.|[^/])+)/([a-z]*)","g");
    // note that rules for escaping are very different in new RegExp than with literals

    var match, results = [];
    while( match = parser.exec(textLine)) {
        try {
            new RegExp(match[1],match[2]);
        }
        catch(e) {
            continue;
        }
        results.push(match[0]);
    }

    return results;
}

It is worth noting that this is far from flawless. Problems include:

• var falseMatch = 'var string = "/trololol/";';
• var falseMatch = '// comment line with a /regex-like substring/derp';
• var falseMatch = 'var number = 8 / 2 / 2;'; (the / 2 / is seen as a regex)

These and more would require more content-aware parsing than a simple regex will allow.