JavaScript regular expression unexpected behavior

Question

Let's have the following (a bit complex) regular expression in JavaScript:

\{\{\s*(?:(?:\:)([\w\$]+))?\#(?:([\w\$\/]+@?)?([\s\S]*?))?(\.([\w\$\/]*))?\s*\}\}

I am wondering why it matches the whole string here:

{{:control#}}x{{*>*}}

but not in the following case (where a space is added after #):

{{:control# }}x{{*>*}}

In PHP or Python, it matches in both cases just the first part {{: ... }}.

I want JavaScript to match only the first part as well. Is it possible without hacking (?!}}) before [\s\S]?

Moreover, is performance the reason for this different behavior in JavaScript, or is it just a bug in specification?

Wiktor Stribiżew · Accepted Answer · 2015-07-02 18:05:40Z

3

You can use a lazy ?? quantifier to achieve the same behavior in JavaScript:

\{\{\s*(?:(?::)([\w$]+))?#(?:([\w$\/]+@?)?([\s\S]*?))??(\.([\w$\/]*))?\s*}}
                                                     ^^

See demo

From rexegg.com:

A?? Zero or one A, zero if that still allows the overall pattern to match (lazy)

This is no bug, and is right according to the ECMA standard specifications JavaScript abides by.

Here, in (?:([\w$\/]+@?)?([\s\S]*?))?, we have an optional non-capturing group that can match an empty text. JavaScript regex engine "consumes" empty texts in optional groups for them to be later accessible via backreferences. This problem is closely connected with the Backreferences to Failed Groups. E.g. ((q)?b\2) will match b in JavaScript, but it won't match in Python and PCRE.

According to the official ECMA standard, a backreference to a non-participating capturing group must successfully match nothing just like a backreference to a participating group that captured nothing does.

edited Jul 2, 2015 at 18:05

answered Jul 2, 2015 at 15:02

Wiktor Stribiżew

631k41 gold badges502 silver badges632 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

TN. Over a year ago

Why it works in PHP, Python or .NET without the ???

Wiktor Stribiżew Over a year ago

No, ? is a greedy quantifier in all languages, I added more details to the answer.

collapsar · Accepted Answer · 2015-07-02 15:17:08Z

0

This subpattern is responsible for the behaviour:

([\w\$\/]+@?)?  // P1

as it matches greedily, your whole test string (without the space) gets consumed.

As @stribizhev suggests, qualifying the designated part of your regex for non-greedy matching, results in a conservative match.

Both versions will match up to and including #, since both match patterns contain this character without any occurrence restrictions.

The second test string (including the space after #) matches non-greedily, since the P1 does not match white-space. Instead this white-space gets matcehd by the subsequent subexpression ( [\s\S]*? ), thus finishing the match.

edited Jul 2, 2015 at 15:17

answered Jul 2, 2015 at 15:12

collapsar

17.4k5 gold badges40 silver badges66 bronze badges

Collectives™ on Stack Overflow

JavaScript regular expression unexpected behavior

2 Answers 2

2 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related