Summary of regular processing functions for PHP regular expressions (preg_match, preg_match_all, preg_replace, pr_PHP tutorial

Previously we have learned the basic syntax of regular expressions, including delimiters, atoms, metacharacters and pattern modifiers. In fact, if regular expressions want to work, they must borrow regular expression processing functions. In this section, we will introduce the perl-based regular expression processing function in PHP, which mainly includes processing operations such as segmentation, matching, search, replacement, etc. We still explain it with examples, so let's get started.

Like regular expressions, regular expression processing functions cannot be used independently, but must be combined to complete specific functions. We also said before that perl-based regular expressions are faster than the POXIS regular expression processing function, so we only introduce perl-based regular expressions starting with preg. Note: Do not use regular expressions to process strings when you can even use string functions, because string processing functions are faster.

Let’s take a look at some commonly used regular expression processing functions.

1, preg_match() function.

The function preg_match() performs a regular expression match, which is defined as follows:

int preg_match ( string $pattern , string $subject [, array &$matches [, int $ flags = 0 [, int $offset = 0 ]]] )

actually searches for the part of the subject that matches the pattern and saves it in the matches array. Please see the example:

Copy code The code is as follows:

$pattern = '/.*?/' ;
$string = 'welcome to phpfunsdsadsadas';
if (preg_match($pattern, $string , $arr)) {
echo "Regular expression {$pattern} and string {$string} match successfully
" ;
print_r($arr);
} else {
echo "Regular expression {$pattern} and string {$string} failed to match";
}
?>

2, preg_match_all() function.

The function preg_match_all() function performs a global regular expression matching. Its definition is the same as the preg_match() function, except that all results are matched. Please see the example:

Copy code The code is as follows:

$pattern = '/< b>.*?/';
$string = 'welcome to phpfunsdsadsadas';
if (preg_match_all($pattern, $string, $arr)) {
echo "Regular expression{$pattern} and string{$string} Match successfully
";
print_r($arr);
} else {
echo "regular expression{$pattern} Failed to match string {$string}";
}
?>

Still the above example (only changed the regular processing function to preg_match_all( )), but the contents of the matching result array are different.

3, preg_replace() function

The function preg_replace() performs a regular expression replacement, which is defined as follows:

mixed preg_replace ( mixed $ pattern, mixed $replacement, mixed $subject [, int $limit = -1 [, int &$count ]] )

actually searches for the part of the subject that matches the pattern and replaces it with replacement. Where limit Refers to the maximum number of substitutions for each pattern on each subject. The default is -1 (infinite). If count is specified, it will be filled with the number of completed substitutions.

Note:

A, if subject is an array, preg_replace() returns an array, otherwise it returns a string.

B, if a match is found, the replaced subject is returned, otherwise the unchanged subject is returned. If an error occurs, NULL is returned.

C, the submode can be applied to the parameter replacement, using n or ${n}. (In the regular expression pattern, we can only use the form of n to obtain the matched subpattern, remember!)

D, if the pattern modifier e is used, the function can be parsed in the parameter replacement. (In other regular expression processing functions, the pattern modifier e is ignored!)

See the following comprehensive example:

Copy code The code is as follows:

$pattern = '/(php)|(mysql)/e';
$string = 'php and mysql in this string have been replaced with uppercase letters! ';
$result = preg_replace($pattern, 'strtoupper("${1}2")', $string, -1, $count);
echo $result.'
';
echo $count;
?>

In the above example, we used the pattern modifier e, so that the strtoupper() function can be parsed as a string. This is the role of the pattern modifier e! The parameters ${1} and 2 are sub Mode 1 and submode 2. The function of the above example is to replace the matched sub-patterns php and mysql in the string $string with uppercase letters!

4, preg_split() function.

preg_split executes a regular expression to separate strings. Its definition is as follows:

array preg_split ( string $pattern , string $subject [, int $limit = -1 [, int $flags = 0 ]] )

actually divides the subject according to Pattern splits and returns the split array. Among them, limit separates the limit into limit substrings at most, and the last substring returned will contain all the remaining parts. The limit value is -1, and 0 or null means "no limit".

Let’s look at an example:

Copy the code The code is as follows:

$pattern = '/

(.*?)

/';
$string = '

php

and

mysql< in this string ;/p>Split! ';
$result = preg_split($pattern, $string, -1, PREG_SPLIT_DELIM_CAPTURE);
print_r($result);
?>

In the above example, We use the constant PREG_SPLIT_DELIM_CAPTURE to set the return result to include the sub-pattern (if set to PREG_SPLIT_NO_EMPTY, preg_split() will return the separated non-empty part.) If we remove the parentheses of the regular expression in the above example, the result will no longer Contains two successfully matched sub-patterns, php and mysql.

We have just introduced the commonly used regular expression processing functions. The examples in this section may be a little more difficult, but I hope you will try them carefully and experience them. We will often use them in the regular expression application part that follows. Regular expression processing function.

http://www.bkjia.com/PHPjc/326078.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/326078.htmlTechArticlePreviously we have learned the basic syntax of regular expressions, including delimiters, atoms, metacharacters and patterns modifier. In fact, if regular expressions want to work, they must borrow...