PHP regular expression capturing groups and non-capturing groups (detailed explanation), php regular expression_PHP tutorial

PHP regular expression capturing group and non-capturing group (detailed explanation), PHP regular expression

regular expression is often used in the project development process, it can be said that it can be regular Expressions are the most basic requirement for every programmer. Beginners find it difficult when they first come into contact with regular expressions. Recently, I benefited a lot from reading "PHP Regular Expressions" written by a friend on his blog. I was very interested in wildcards and capturing data in the chapter. These two chapters happen to also cover the content of capturing groups and non-capturing groups of regular expressions, so as to analyze this content

We know that in regular expressions (x) means matching 'x' and recording the matching value. This is just a popular way of saying it, or even a loose way of saying it. Only the () capture group form will record matching values. Non-capturing groups only match but do not record.

　Capture group:

　(pattern)

This form is the one we see most. It matches and returns the capture results. It can be nested. The group numbers are arranged in sequence from left to right.

Copy code The code is as follows:
$regex = '/(ab(c) ) d(e)?/';
$str = 'abccde';
$matches = array();

if(preg_match($regex, $str, $matches)){
Print_r($matches);
}

Matching results:

Copy code The code is as follows:
Array ( [0] => abccde [1] => abcc [2] => c [3] => e )
​(?Ppattern)

Although this method looks slightly more complicated when constructing regular expressions, it is essentially the same as (pattern). The biggest advantage is reflected in the processing of results. Programmers can directly and quickly call the results based on the they set, without having to count the subgroups in which the required results are located.

Copy code The code is as follows:
$regex = '/(?Pw(?Pw))abc(?Pw)45/';

$str = 'fsabcd45';
$matches = array();

if(preg_match($regex, $str, $matches)){
Print_r($matches);
}

Matching results:

Copy code The code is as follows:
Array ( [0] => fsabcd45 [group1] => fs [1] => fs [group2] => s [2] => s [group3] => d [3] => d )
num

Num is an integer and a back reference to the capturing group. For example, 2 represents the matching value of the second subgroup, and represents the matching value of the first subgroup

Copy code The code is as follows:
$regex = '/(w)(w)21/';
$str = 'abba';
$matches = array();

if(preg_match($regex, $str, $matches)){
Print_r($matches);
}

Matching results:

Copy code The code is as follows:
Array ( [0] => abba [1] => a [2] => b )

Note that I overlooked a small detail here. My first code at the beginning was $regex = “/(w)(w)21/”; returned no matching result. After debugging, I found Only ' ' can be used here. You still need to pay attention to the usage difference between ' and ".

　k< name >

After understanding (?Ppattern) and num, this is not difficult to understand. k< name > is a back reference to the named capture group. where name is the capture group name.

Copy code The code is as follows:
$regex='/(?Pw)abck/';

$str="fabcf";

echo preg_match_all($regex, $str,$matches);

print_r($matches);

Matching results:

Copy code The code is as follows:
Array ( [0] => Array ( [0] => fabcf ) [name] => Array ( [0] => f ) [1] => Array ( [0] => f ) )

Non-capturing group:

　(?:pattern)

The only difference from (pattern) is that it matches pattern but does not capture the matching result. No more examples will be given here.

There are four other methods that actually talk about the same thing: pre-checking.

Pre-checking is divided into forward pre-checking and reverse pre-checking. According to the literal understanding, forward lookup is to determine whether certain characters behind the matching string exist or not, while reverse lookup is to determine whether certain characters before the matching string exist or not.

Forward pre-check determines whether there is a use (?=pattern), or whether there is a use (?!pattern).

Reverse pre-check determines whether there is a use (?<=pattern) or whether there is a use (?

Copy code The code is as follows:
$regx='/(?<=a)bc(?=d)/';

$str="abcd ebcd abce ebca";

if(preg_match_all($regx, $str, $matches)){

Print_r($matches);
}

Matching results:

Copy code The code is as follows:
Array ( [0] => Array ( [0] => bc) )

Whether to use these four forms, just pay attention to the position of the relative matching string and whether the assertion is positive or negative, and you will quickly master it.

In addition, the four forms of pre-checking are zero-width. Only one judgment is made when matching, and it does not occupy any position. /HE(?=L)LLO/ matches HELLO, but /HE(?=L)LO/ does not match HELLO. After all, the two do not match in terms of number of bytes. The former has only 4, while the latter has 5.

The above is the entire content of the detailed explanation of regular expression capturing groups and non-capturing groups in PHP. I hope it can enlighten you.