I'm trying to lazy match a group in JavaScript, but what I have it not working quite as I'd expect.
"/1000/2000/".match("(?:/)(.*?)(?:/)$")
This is what I have and what I believe this regexp will do:
/ character/ characters, but the shortest match/ characterThat should then return me 2000, but it's returning 1000/2000. Why is that?
When matching a string against a regex, the engine will try every position from left to right until a match is found.
Since the string is scanned from left to right, (?:/)(.*?)(?:/)$ can find a match at index 0 of the input string /1000/2000/.
The lazy quantifier only affect the order the repetition is tried. It will try empty string, then repeat once, twice, 3 times, etc. Since . matches anything except for line terminators, and the string is tried from left to right, the whole /1000/2000/ is matched.
By the way, while it's usually said that .*? matches the least number of character possible, the correct definition is that lazy quantifier will try expanding the atom (in this case is .) the least number of times possible, so that the sequel (in this case is (?:/)$) can be matched.
The solution, as mentioned in other answers, is to limit the set of allowed characters in between / by replacing . with [^/]. After the character class is changed, you can use either greedy or lazy quantifier, since the grammar has become unambiguous, thus the search order doesn't affect the final result.
(?:) is a non-capturing group - it still includes the contents in the match but does not create a group match for the () brackets.
Breaking down you regular expression:
(?:/) will match the first slash in the string (but the brackets do not create a group.)(.*?) will match zero-or-more of any character until the first match of the subsequent part of the pattern (and the brackets create a separate capturing group)(?:/)$ will match a slash followed immediately by the end-of-the-string (and the brackets do not create a group).So the first part will match the first character and the last part will match the last character and the middle bit will match as much as it needs to fulfil the other matches (i.e. everything in between).
As an alternative, this will match the last character string between two slashes where the last slash is at the end of the word:
"/1000/2000/".match("[^/]*(?=/$)")
?=. Thank you very much!the ?:X pattern is a match but do not capture instruction in JavaScript, so we see the following pattern:
(?:/)(.*?)(?:/)$
translating to:
/ (somewhere), but do not capture/ followed by end of string, but do not captureSo, the first / is matched and prompty forgotten, then we match set (2) which tries a non-greedy match for "any character" that is followed by (?:/)$. Since the final part matches only the slash at the end of your input string, we find and ignore the first and last /, which leaves us with 1000/2000.
If you wanted 1000 instead, then there isn't really a reason to bother with regexp at all:
// get some input
var s = "/1000/2000/";
// split on slashes
var t = s.split('/');
// filter out empties
t = t.filter(function(a) { return !!a ; });
// convert to ints, because why not. Note that even regexp will
// yield strings, so you still have to do this if you do use regexp.
t = t.mapfunction(a) { return parseInt(a,10); });
// results are....
console.log(t.join(", ")); // => "1000, 2000"
If you're looking for "things between slashes", just look for things that are not slashes:
"/1000/2000/".match(/([^\/]+)/g) // => Array [ "1000", "2000" ]
something between /arr[arr.length-1], done. Last element.
prompty forgotten This is wrong terminology. It's not forgotten, and it's still included in the main match.Try this but it is not really the most elegant solution out there:
'/1000/2000/'.match(/(?!\/)\d+(?=\/$)/);
somethingbetween/, right before the end of the string.