Matching text between delimiters: greedy or lazy regular expression?

Question

For the common problem of matching text between delimiters (e.g. < and >), there's two common patterns:

• using the greedy * or + quantifier in the form START [^END]* END, e.g. <[^>]*>, or
• using the lazy *? or +? quantifier in the form START .*? END, e.g. <.*?>.

Is there a particular reason to favour one over the other?

Answer 1

Some advantages:

[^>]*:

• More expressive.
• Captures newlines regardless of /s flag.
• Considered quicker, because the engine doesn't have to backtracks to find a successful match (with [^>] the engine doesn't make choices - we give it only one way to match the pattern against the string).

.*?

• No "code duplication" - the end character only appears once.
• Simpler in cases the end delimiter is more than a character long. (a character class would not work in this case) A common alternative is (?:(?!END).)*. This is even worse if the END delimiter is another pattern.

Answer 2

The first is more explicit, i. e. it definitely excludes the closing delimiter from being part of the matched text. This is not guaranteed in the second case (if the regular expression is extended to match more than just this tag).

Example: If you try to match <tag1><tag2>Hello! with <.*?>Hello!, the regex will match

<tag1><tag2>Hello!

whereas <[^>]*>Hello! will match

<tag2>Hello!