php — PCRE regular expression repetition/quantifier

The number of repetitions is specified through a quantifier, which can follow the following elements:

A single character, which can be an escaped

metacharacter.

Character classes

Backreferences (see next section)

Subgroups (unless it is an assertion)

General repetition quantifiers specify the number of matches for a minimum value and a maximum value, wrapped in curly braces Numbers, two numbers separated by commas. Both numbers must be less than 65536, and the first number must be less than or equal to the second. For example: z{2,4} matches "zz", "zzz", "zzzz". A single closing curly brace is not a special character. If the second number is omitted, but the comma is still present, it means there is no upper limit; if the second number and the comma are both omitted, then the quantifier limits a certain number of matches. For example, [aeiou]{3,} matches at least three consecutive vowels, but can also match more, while d{8} can only match 8 numbers. When the left curly bracket appears in a position that does not allow the use of quantifiers or does not match the quantifier syntax, it is considered an ordinary character and itself is matched in the original text. For example, {,6} is not a quantifier and will match the four characters "{,6}" according to the original text.

The quantifier {0} is authorized, and the behavior it will cause is that the preceding term and quantifier do not exist.

For convenience (and historical compatibility), the three most commonly used quantifiers have single-character abbreviations.

Single character quantifier

* Equivalent to {0,}

+ Equivalent to {1,}

? Equivalent to {0,1}

can be followed by a subpattern that does not match any characters Followed by a quantifier that matches 0 or more characters to construct an uncapped infinite loop. For example: (a?)*

Earlier versions of perl and pcre will get an error at compile time for this mode. However, since this can be useful in some cases, this pattern is now accepted, but if any repetition of the subpattern does not match any characters, the loop will be forced out.

By default, quantifiers are "greedy", that is, they will match as many characters as possible (up to the maximum allowed number of matches) without causing pattern matching to fail. A classic example of this problem is trying to match comments in C. Everything that appears between /* and */ is considered a comment, and individual * and / are allowed in the middle of comments. One attempt to match C comments is to use the pattern /*.**/. If you apply this pattern to the string "/* first comment*/ not comment /*second comment*/" it will match the wrong result, also It is the entire string. This is due to the greedy nature of the quantifier, which will try to match as many characters as possible.

However, if a quantifier is immediately followed by a ? (question mark) token, it becomes lazy (non-greedy) mode, which no longer matches as much as possible, but as little as possible. So the pattern /*.*?*/ will work correctly on C comment matching. The meaning of each quantifier itself does not change, but the number of preferred matches changes due to the addition of ?. Do not confuse this use of ? with its use as a quantifier. Because it has two uses, sometimes it will have quantifiers. For example, d??d will be more inclined to match a number, but at the same time, if it is to achieve the purpose of the entire pattern matching, it can also accept the matching of two numbers. Annotation: Taking the pattern wd??dw as an example, for the string "a33a", although d?? is non-greedy, using greedy will cause the entire pattern to not match, so in the end it still selects a number that matches .

If the PCRE_UNGREEDY option is set (an option not available in perl), then the quantifier is non-greedy by default. However, a single quantifier can be made greedy by following it with a ? In other words, the PCRE_UNGREEDY option reverses the greedy default behavior.

The quantifier followed by a “+” means “possession”. It will eat as many characters as possible and does not pay attention to other subsequent patterns. For example, .*abc matches "aabc", but .*+abc will not match, because .*+ will eat the entire string, resulting in the following The remaining patterns are not matched. Since PHP 4.3.3, you can use the possessor (+) to modify quantifiers to improve speed.

When a subgroup is qualified by a quantifier with a minimum quantity greater than 1 or a maximum quantity limit, more storage is required for compiled mode in proportion to the minimum or maximum quantity.

If a pattern starts with .* or .{0,} and the PCRE_DOTALL option is turned on (equivalent to perl's /s), which allows . to match newlines, then the pattern will be implicitly fastened, because no matter what, Each next character position in the target string is tried, so there is never a point at which all matches are retried after the first time. PCRE will treat this pattern the same as A. In order to obtain this optimization when the pattern starts with .* when we know that the target string does not contain a newline, it is worth setting PCRE_DOTALL, or alternatively specifying the anchor explicitly using ^.

Annotation: The optimization here means that after the pattern does not match, it will not look back to find the next position. For example, if PCRE_DOTALL is not set, and the first character of the target string is a newline character, then the pattern will try the first character and find that it does not match. , will try again using the pattern starting from the second character position. After using PCRE_DOTALL, it will definitely match... Similarly, when using ^ or /A, the limitation is that once the pattern does not match, you can exit directly without starting the entire pattern again at the next position of the target string. match.

When a captured subgroup is repeated, the result of the captured subgroup is the value captured in the last iteration. For example, (tweedle[dume]{3}s*)+matches the string "tweedledum tweedledee", and the obtained subgroup capture result is "tweedledee". However, in the case of nested capture subgroups, the corresponding capture values ​​may be set in previous iterations. For example, /(a|(b))+/ matches the string "aba", and the result of the second captured subgroup will be "b". Translator's note: If you don't understand the part after "however", let's use an example to illustrate that b is the last captured result of the second subgroup, so the final result of the second subgroup is b, which is in line with the rules described before "however".