Regular Expression: /.+?/

Question

How would the '.+?' regular expression work? Is the .+ part matching anything written, and the ? part saying it can either be there or not? So, for example, this regular expression would match:

'cat'
'' (ie, nothing written, just the empty string)

Answer 1

I suggest you looking at http://www.regular-expressions.info/

Answer 2

+? (lazy plus)

Repeats the previous item once or more. Lazy, so the engine first matches the previous item only once, before trying permutations with ever increasing matches of the preceding item.

/".+?"/ matches "def" (and "ghi") in abc "def" "ghi" jkl, while /".+"/ matches "def" "ghi".

You can find more info here

Answer 3

The "+?" is not a "+" quantifier followed by a "?" quantifier. Instead the "?" modifies the "+" to perform a "lazy" or "non greedy" match, meaning that the least number of characters that match is already sufficient.

So a "a+?" regex would match just a single "a" in "caaat".

Answer 4

Besides what Hans Kesting already said, a lazy multiplier will do the exact oposite of the normal greedy multipliers: The possible match is kept as small as possible and the rest of the regular expression is tested.

So if you’re having the string aaba and test the regular expression a.*b on it, the internal processing steps would be as follows:

1. a in a.*b matches aaba
2. .* in a.*b matches aaba, and since .* is greedy
   1. .* then matches aaba
   2. .* then matches aaba
3. b in a.*b fails as there is no letter left
   • backtracking goes one step back and .* will now only match bb in aaba
4. b in a.*b still fails on aaba
   • backtracking goes one step back and .* now matches only b in aaba
5. b in a.*b now matches b in aaba and we’re done.

So the full match is aaba.

If we do the same with a lazy multiplier (a.*?b), the processing will do the oposite, try to match the least possible characters as possible:

1. a in a.*?b matches aaba
2. .* in a.*?b matches nothing (* = zero or more repetitions), and since .* is declared as lazy (.*?), the rest of the regular expression is tested
3. b in a.*?b fails on aaba
   • backtracking will try to increase the match of .*
4. .* matches now aaba
5. b in a.*?b matches aaba and we’re done.

So the full match if aaba.

Answer 5

There is documentation on how Perl handles these quantifiers perldoc perlre.

By default, a quantified subpattern is "greedy", that is, it will match as many times as possible (given a particular starting location) while still allowing the rest of the pattern to match. If you want it to match the minimum number of times possible, follow the quantifier with a "?". Note that the meanings don't change, just the "greediness":

    *?     Match 0 or more times, not greedily
    +?     Match 1 or more times, not greedily
    ??     Match 0 or 1 time, not greedily
    {n}?   Match exactly n times, not greedily
    {n,}?  Match at least n times, not greedily
    {n,m}? Match at least n but not more than m times, not greedily

By default, when a quantified subpattern does not allow the rest of the overall pattern to match, Perl will backtrack. However, this behaviour is sometimes undesirable. Thus Perl provides the "possessive" quantifier form as well.

    *+     Match 0 or more times and give nothing back
    ++     Match 1 or more times and give nothing back
    ?+     Match 0 or 1 time and give nothing back
    {n}+   Match exactly n times and give nothing back (redundant)
    {n,}+  Match at least n times and give nothing back
    {n,m}+ Match at least n but not more than m times and give nothing back

For instance,

   'aaaa' =~ /a++a/

will never match, as the a++ will gobble up all the a 's in the string and won't leave any for the remaining part of the pattern. This feature can be extremely useful to give perl hints about where it shouldn't backtrack. For instance, the typical "match a double-quoted string" problem can be most efficiently performed when written as:

   /"(?:[^"\\]++|\\.)*+"/

as we know that if the final quote does not match, backtracking will not help. See the independent subexpression (?>...) for more details; possessive quantifiers are just syntactic sugar for that construct. For instance the above example could also be written as follows:

   /"(?>(?:(?>[^"\\]+)|\\.)*)"/

link