The secret of regular expressions (2) components and methods

Now that we understand what regular expressions do and the basic rules, we can begin to read regular expressions.

Many students, when reading other people’s re, will not understand, very dizzy, I started the same. In fact, the essence of regular reading and writing lies in “splitting” and “combining”, like alchemy. Because regular expressions are composed of a series of elements in a certain way, I have divided them into the following 6 categories according to their characteristics:

1. Metacharacter – quantifier class
2. Metacharacters – special classes
3. Escape class
4. Feature modifier Pattern modifier
5. Capture subgroups & references
6. Non-captured subgroup: one-time subgroup & assertion

This classification is to help you understand, re is a tool, is to use, do not memorize. We need to understand how they’re made up, and then break them down and combine them.

Metacharacter – quantifier class Repetition

Let’s start by recognizing some of the basic elements of re. Some characters in a regular expression are given special meanings called metacaracters, so that they no longer simply represent themselves. They can be understood as special codes in the regular expression. Let’s start with the most common quantifiers.

Quantifiers, which in the re mean repetition, only refer to the object immediately preceding it, which may be a character, which may be a subgroup, and this is important, and beginners often get this wrong.

For example,.* ABC matches "aabc", but.*+ ABC does not match because.*+ eats the entire string, leaving the rest of the pattern unmatched.Copy the code

[aeiou]{3,} matches at least three consecutive vowelsCopy the code

Here's an example in PHP's official documentation, which is well written: /\*.*\*/ // use this expression to match the following strings, /* any of 0 or more characters */ // * first comment*/ not comment /*second comment*/ By default matches the full text. If you change the expression to /\*. /* first comment*/Copy the code

To fill in the blanks from the previous section, where I mentioned greed in a broad sense, here are two examples:

1. I’m going to use the expression ‘a*? 3’ to match ‘a3’, it should only match the number 3, but it will match a3 as well;

2. Here’s another one: ‘\d+? A ‘, to match ‘133456789654a’, will match the whole character even if lazy mode is used, in order to try to match it;

This is greed in the broad sense, the maximum character match for the entire expression, and this is always in effect.

Alternatively, we can construct an infinite loop with no upper bound by a subpattern that does not match any characters followed by an *. Such as: (a)? *, this is a supplementary little tip.

Metacaracters – Special class meta-characters

The following metacharacters are commonly used:

I introduced it first because the same metacharacters have different meanings inside and outside the character class []. Most metacharacters have lost their special meanings inside the character class [], except for the following three: For example, [^()] represents all non-() characters; for example, [^()] represents all non-() characters; [^aeiou] Matches all characters that are not vowels. [-] Indicates the range of characters. For example, [w-c] is equivalent to [wxyzABC] in case of case insensitive. [\] escapes, this is the same as outside [], while some escape characters can also be used inside [], such as \d,\ d \w,\ wCopy the code

Next look at the special metacharacters outside the character class [] :

Optional branches Note the following three points: An optional path that allows matching an empty string; The matching process tries each alternative path from left to right, using the first one that matches successfully, so be careful about the order of branches when using it; Symbol in front of all content (not follow) and later, as the two branches, if use in the subgroups (|), is behind the front all subgroups of content and | | the composition of the two branches;Copy the code

escape

After the basic element metacharacters are introduced, the problem arises. What if I want to match an asterisk *, and I don’t want it to represent the quantifier, and I want it to revert to its original meaning?

Here we use the most common character in the re, the backslash \ escape character. Understanding what it means is crucial for us to read and write re.

In addition to restoring the meaning of the metacaracter itself, backslashes can also be used to describe specific characters.

Each of the following pairs of escape sequences represents two disjointed parts of the complete character set. No character can match two at once. All lower case sequences represent yes, and all upper case sequences represent no.

For example: "Tom is a cat", can use the expression ^ (\ w + | \ s) * $to match the entire string, but if you use \ b. * \ b can only match from TomCopy the code

These sequences of character classes can occur either inside or outside the brackets []. They match one character at a time from the character type they represent.

Here are some special escape characters that are often used:

Re also has relative matches for hidden formats in strings, but these characters have no special meaning in the character class [] and are treated as normal characters:

Feature Modifier Pattern Modifier

In the first section of basic re rules, we mentioned that re is case-sensitive by default, matches single-line strings by default, and quantifier matches are greedy by default. So what if you want to be case-insensitive, match multiple lines, or change its greedy property?

This is where the attribute modifier comes in. There is a special class of characters in the re that are used to modify the entire matching rule. Here are some of the more common feature modifiers:

Attribute modifiers can be used in three ways:

For example: '/CAT[AEiou]/ I ', the I after the/delimiter makes the entire expression case-insensitive. I) [AEiou] / ', will (? '/(a(? I) Bc | d)/' can match the aBC, aBC, abD, etc., this influence will penetrate to the alternative branchesCopy the code

Attribute modifiers can be used side by side, such as (? Im) indicates multi-line mode and is case insensitive. You can also use it to cancel these Settings, such as (? Im-sx) is set to disable both PCRE_DOTALL and PCRE_EXTENDED modes.

Ok, to summarize, in this section we’ve looked at some of the basic elements of re: metacaracters, quantifiers, and their greedy nature; Metacaracter special classes, especially the difference between inside and outside parentheses of the character class []; And the role of escape characters, and some special escape characters. Finally, how to modify the default properties of the re with the attribute modifier.

Summary is not easy, do not reprint privately, otherwise knock to the end.

Resources: www.php.net official documentation