返回匹配的正则表达式的部分

Question

In a regular expression that uses OR (pipe), is there a convenient method for getting the part of the expression that matched.

Example:

/horse|caMel|TORTOISe/i.exec("Camel");

returns Camel . What I want is caMel .

I understand that I could loop through the options instead of using one big regular expression; that would make far more sense. But I'm interested to know if it can be done this way.

Answer 1

Very simply, no.

Regex matches have to do with your input string and not the text used to create the regular expression. Note that that text might well be lost, and theoretically is not even necessary. An equivalent matcher could be built out of something like this:

var test = function(str) {
    var text = str.toLowerCase();
    return text === "horse" || text === "camel" || text === "tortoise";
};

Another way to think of it is that the compilation of regular expressions can divorce the logic of the function from their textual representation. It's one-directional.

Sorry.

Answer 2

There is not a way built-in to the Javascript RegExp object; without changing your expression. The closest you can get is source which will just return the entire expression as a string.

Since you know you're expression is a series of | OR | OR s, you could capturing groups to figure out which group matched, and combine that with .source to find out the contents of that group:

var exp = /(horse)|(caMel)|(TORTOISe)/i;
var result = exp.exec("Camel");
var match = function(){
    for(var i = 1; i < result.length; i++){
        if(result[i]){
            return exp.source.match(new RegExp('(?:[^(]*\\((?!\\?\\:)){' + i + '}([^)]*)'))[1];
        }
    }
}();

// match == caMel

It is also extremely easy (although somewhat impractical) to write a RegExp engine from scratch would you could technically add that functionality to. It would be much slower than using an actual RegExp object, since the whole engine would have to be interpreted at run-time. It would, however, be able to return exactly the matched portion of the expression for any regular expression and not be limited to one which consists of a series of | OR | OR s.

The best way to solve your problem, however, is probably not to use a loop or a regular expression at all, but instead to create an object where you use a canonical form for the key:

var matches = {
  'horse': 'horse',
  'camel': 'caMel',
  'tortoise': 'TORTOISe'
};

// Test "Camel"
matches['Camel'.toLowerCase()]; // "caMel"

Answer 3

This will give the wanted value without looping:

var foo, pat, tres, res, reg = /horse|caMel|TORTOISe/i;
foo = reg.exec('Camel');

if (foo) {
    foo = foo[0].replace(/\./g, '\\.');
    pat = new RegExp('\\|' + foo + '\\|', 'i');
    tres = '|' + reg.source + '|';
    res = tres.match(pat)[0].replace(/\|/g, '');
}

alert(res);

If there's no match, now you get undefined , though it's easy to change to something else.