preg_grep
(PHP 4, PHP 5)
preg_grep -- Returns the array element matching the pattern
Description
array preg_grep ( string pattern, array input [, int flags] )
preg_grep() Returns an array containing input The cells in the array that match the given pattern.
flags can be the following flags:
PREG_GREP_INVERT
If passed in, preg_grep() will return cells in the input array that do not match the given pattern. This tag is available since PHP 4.2.0.
Since PHP 4.0.4, the results returned by preg_grep() are indexed using the keys from the input array. If you do not want such results, use array_values() to reindex the results returned by preg_grep().
The above is the description of preg_grep() in the manual. First of all, this is a perl-compatible regular function, so I guess preg_grep means p(perl)reg(regular)_grep. Its characteristic is that it can be used for arrays. Through its own extension, it can be used for regular matching in multi-dimensional arrays, and it can Returns a matching or non-matching array through the flags parameter. Its efficiency is much faster than using the foreach(...){if...} structure (not verified), and it can match complex patterns. It is very useful in applications such as search and sorting.
Example:
$arr = array('abc'=>12.213,'bb'=>12345,'ba'=>23.2321,34.3,'23'=>'3.3',' 23434'=>'bbb');
// Returns all array elements containing floating point numbers.
$fl_array = preg_grep ("/^(d+)?.d+$/", $arr);
print_r($fl_array);
?>
preg_match
(PHP 3 >= 3.0.9, PHP 4, PHP 5)
preg_match -- Perform regular expression matching
Instructions
int preg_match (string pattern, string subject [, array matches [, int flags]] )
Search in the subject string for the regular expression given by pattern Matching content.
If matches are provided, it will be populated with the search results. $matches[0] will contain text that matches the entire pattern, $matches[1] will contain text that matches the first captured subpattern in parentheses, and so on.
flags can be the following flags:
PREG_OFFSET_CAPTURE
If this flag is set, the associated string offset of each matching result will also be returned. Note that this changes the value of the returned array so that each cell in it is also an array, where the first item is the matched string and the second item is its offset. This tag is available since PHP 4.3.0. The
flags parameter is available since PHP 4.3.0.
preg_match() returns the number of times pattern is matched. Either 0 times (no match) or 1 time, since preg_match() will stop searching after the first match. preg_match_all(), on the contrary, will search until the end of subject. If an error occurs, preg_match() returns FALSE.
Tip: If you just want to check whether a string is contained in another string, don't use preg_match(). You can use strpos() or strstr() instead, which is much faster.
The above is the description of preg_match() in the manual. I think the function of this function is that it can be used for verification, that is, whether a certain string meets certain requirements. The limitation is that as mentioned above, it either matches 0 times or 1 time. And the return value is the number of matches. When a full match is required, preg_match_all() can be used. It is also worth mentioning the role of the $matches array, which can be used as the return value of the self-pattern, which is sometimes useful.
Example:
if (preg_match ("/(bwebb)s(d)/i", "PHP is the web 45 scripting web 34 language of choice.",$match)) {
print "A match was found.";
print_r($match);
} else {
"A match was not found.";
}
?>
// Get the host name from the URL
preg_match( "/^(http://)?([^/]+)/i",
"http://www.php.net/index.html", $matches);
$host = $matches[2 ];
// Get the next two segments from the host name
preg_match("/[^./]+.[^./]+$/", $host, $matches);
echo "domain name is: { $matches[0]}n";
?>
preg_match_all
(PHP 3 >= 3.0.9, PHP 4, PHP 5)
preg_match_all -- Perform global regular expression matching
The explanation of this function in the manual is very It’s clear, so I won’t elaborate further.
说明
int preg_match_all ( string pattern, string subject, array matches [, int flags] )
在 subject 中搜索所有与 pattern 给出的正则表达式匹配的内容并将结果以 flags 指定的顺序放到 matches 中。
搜索到第一个匹配项之后，接下来的搜索从上一个匹配项末尾开始。
flags 可以是下列标记的组合（注意把 PREG_PATTERN_ORDER 和 PREG_SET_ORDER 合起来用没有意义）：
PREG_PATTERN_ORDER
对结果排序使 $matches[0] 为全部模式匹配的数组，$matches[1] 为第一个括号中的子模式所匹配的字符串组成的数组，以此类推。
preg_match_all ("|<[^>]+>(.*)]+>|U",
"
example: this is a test
",
$out, PREG_PATTERN_ORDER);
print $out[0][0].", ".$out[0][1]."\n";
print $out[1][0].", ".$out[1][1]."\n";
?>
本例将输出：
example: ,
this is a test
example: , this is a test
因此，$out[0] 包含匹配整个模式的字符串，$out[1] 包含一对 HTML 标记之间的字符串。
PREG_SET_ORDER
对结果排序使 $matches[0] 为第一组匹配项的数组，$matches[1] 为第二组匹配项的数组，以此类推。
preg_match_all ("|<[^>]+>(.*)]+>|U",
"
example: this is a test
",
$out, PREG_SET_ORDER);
print $out[0][0].", ".$out[0][1]."\n";
print $out[1][0].", ".$out[1][1]."\n";
?>
本例将输出：
example: , example:
this is a test
, this is a test
In this example, $matches[0] is the first set of matching results, $matches[0][0] contains the text that matches the entire pattern, $matches[0][1] contains the first match the text of the subpattern, and so on. Likewise, $matches[1] is the second set of matches, and so on.
PREG_OFFSET_CAPTURE
If this flag is set, the associated string offset will also be returned for each matching result. Note that this changes the value of the returned array so that each cell in it is also an array, where the first item is the matched string and the second item is its offset within subject . This tag is available since PHP 4.3.0.
If no tag is given, PREG_PATTERN_ORDER is assumed.
Returns the number of times the entire pattern is matched (possibly zero), or FALSE if an error occurs.
Example 1. Get all phone numbers from a certain text
preg_match_all ("/(? (d{3})? )? (?(1) [-s] ) d{3}-d {4}/x",
"Call 555-1212 or 1-800-555-1212", $phones);
?>
Example 2. Search for matching HTML tags (greedy)
/ / \2 is an example of a reverse reference. Its meaning in PCRE is that
// must match the content within the second set of brackets in the regular expression itself. In this case,
// is ([w]+). Because the string is in double quotes, you need
// to add an extra backslash.
$html = "
bold textclick me";
preg_match_all ("/(<([w]+)[^> ]*>)(.*)()/", $html, $matches);
for ($i=0; $i< count($matches[0]); $i++) {
echo "matched: ".$matches[0][$i]."n";
echo "part 1: ".$matches[1][$i]."n";
echo "part 2: ".$matches[3][$i]."n";
echo "part 3: ".$matches[4][$i]."nn";
}
?>
preg_quote
(PHP 3 >= 3.0.9, PHP 4, PHP 5)
preg_quote -- Escape regular expression character
Description
string preg_quote ( string str [, string delimiter] )
preg_quote() takes str as parameter and gives each of them Characters that are part of the regular expression syntax are preceded by a backslash. If you need to match a dynamically generated string as a pattern, you can use this function to escape the special characters it may contain.
If the optional parameter delimiter is provided, this character will also be escaped. Can be used to escape the delimiter required by the PCRE function. The most commonly used delimiter is the slash /.
Special characters of regular expressions include: . + * ? [ ^ ] $ ( ) { } = ! < > | :.
Note: This function can be safely used on binary objects.
The above is the explanation in the manual, and it is very clear. I won’t say more. In addition, there is a note in the manual that this function can be used safely for binary objects, which is very useful.
Example: Example 1. preg_quote() example
$keywords = '$40 for a g3/400';
$keywords = preg_quote($keywords, '/');
echo $keywords; // returns $40 for a g3/400
?>
// in the formula has special meaning.
$textbody = "This book is *very* difficult to find.";
$word = "*very*";
$textbody = preg_replace ("/".preg_quote($word)."/",
"< ;i>".$word."",
$textbody);
preg_replace
(PHP 3 >= 3.0.9, PHP 4, PHP 5)
preg_replace -- Perform regular expression search and replacement
Instructions
mixed preg_replace (mixed pattern, mixed replacement, mixed subject [, int limit] )
Search for a match of pattern in subject and replace it with replacement. If limit is specified, only limit matches will be replaced. If limit is omitted or has a value of -1, all matches will be replaced.
replacement can contain backreferences of the form \n or (since PHP 4.0.4) of the form $n , with the latter preferred. Each such reference will be replaced by text matching the nth captured bracketed subpattern. n can range from 0 to 99, where \0 or $0 refers to the text matched by the entire pattern. Count the left parenthesis from left to right (starting at 1 ) to get the number of subpatterns.
When the replacement pattern is followed by a number immediately after a backreference (i.e.: the number immediately after a matching pattern), the familiar \1 symbol cannot be used to represent the backreference. For example, \11 will make it unclear whether preg_replace() wants a backreference of \1 followed by the number 1 or a backreference of \11. The solution in this case is to use ${1}1. This creates an isolated backreference for $1 , leaving the other 1 just a literal.
If a match is found, the replaced subject will be returned, otherwise the original subject will be returned. Each parameter of
preg_replace() (except limit) can be an array. If pattern and replacement are both arrays, they will be processed in the order in which their keys appear in the array. This is not necessarily the same as the numerical order of the index. If you use an index to identify which pattern will be replaced by which replacement, you should use ksort() to sort the array before calling preg_replace().
If subject is an array, a search and replace is performed on each item in subject and an array is returned.
If pattern and replacement are both arrays, preg_replace() will take out values from them in order to search and replace subject. If there are fewer values in replacement than in pattern, the empty string is used as the remaining replacement value. If pattern is an array and replacement is a string, this string is used as the replacement value for each value in pattern . The other way around is meaningless. The
/e modifier causes preg_replace() to treat the replacement argument as PHP code (after the appropriate backreferences have been replaced). Tip: Make sure that replacement forms a valid PHP code string, otherwise PHP will report a syntax parsing error on the line containing preg_replace().
Note: The limit parameter was added after PHP 4.0.1pl2.
I think its power is that it can not only handle strings, but also arrays, and its reverse reference function is very flexible. Basically, it can meet most of the needs of ordinary users. If it is not competent, then we also have the preg_replace_callback() function, which can customize the callback function to meet your advanced requirements. Such as designing filters, etc.
preg_replace_callback
(PHP 4 >= 4.0.5, PHP 5)
preg_replace_callback -- Use callback function to perform regular expression search and replacement
Description
mixed preg_replace_callback (mixed pattern, callback callback, mixed subject [, int limit] )
The behavior of this function is almost the same as preg_replace(), except that instead of providing a replacement parameter, a callback function is specified. This function takes as input an array of matches in the target string and returns the string used for replacement.
Example 1. preg_replace_callback() example
//This text is for 2002,
//Now I want to make it available for 2003
$text = "April fools day is 04/01/ 2002n";
$text.= "Last christmas was 12/24/2001n";
// Callback function
function next_year($matches) {
Usually: $matches[0] is a complete match
// $ Matches [1] is the matching item of the sub -mode in the first parentheses
// to push RETURN $ matches [1]. ($ matches [2] +1); (d{2}/d{2}/)(d{4})|",
"next_year",
$text);
// Last christmas was 12/24/2002
?>
You'll often need the callback function for a preg_replace_callback() in just one place. In this case you can use create_function() to declare an anonymous function as callback within the call to preg_replace_callback(). By doing it this way you have all information for the call in one place and do not clutter the function namespace with a callback functions name not used anywhere else.
For friends who use the preg_replace_callback() function , you should need the callback function (otherwise, why use it? Wouldn't it be better to use preg_replace directly), but it is often only used in one place. In this case you can use create_function() to declare an anonymous function as the callback function of preg_replace_callback(). In this way, we satisfy the need to declare information without getting confused by a function name that will not be used again.
Example 2. preg_replace_callback() and create_function()
/* A UNIX-style command line filter that converts
* uppercase letters at the beginning of each paragraph to lowercase letters */
$fp = fopen( "php://stdin", "r") or die("can't read stdin");
while (!feof($fp)) {
$line = fgets($fp);
$line = preg_replace_callback (
'$matches',
'return strtolower( $matches[0]);'
preg_split
(PHP 3 >= 3.0.9 , PHP 4, PHP 5)
preg_split -- Use regular expressions to split strings
No more details.
Description
array preg_split (string pattern, string subject [, int limit [, int flags]] )
Returns an array containing the substrings in subject split along the boundaries matching pattern.
If limit is specified, at most limit substring will be returned. If limit is -1, it means there is no limit and can be used to continue to specify optional parameter flags.
flags can be any combination of the following flags (combined with the bitwise OR operator | ):
PREG_SPLIT_NO_EMPTY
If this flag is set, preg_split() only returns non-empty components.
PREG_SPLIT_DELIM_CAPTURE
If this flag is set, the bracket expression in the delimiter pattern will also be captured and returned. This tag was added in PHP 4.0.5.
PREG_SPLIT_OFFSET_CAPTURE
If this flag is set, if this flag is set, its associated string offset will also be returned for each matching result that occurs. Note that this changes the value of the returned array so that each cell in it is also an array, where the first item is the matched string and the second item is its offset within subject . This tag is available since PHP 4.3.0.
Tip: If you don’t need the functionality of regular expressions, you can choose to use faster (and simpler) alternative functions such as explode() or str_split().
The above introduces the summary and analysis of the regular processing function of pretty rhythm dear my future PHP, including the content of pretty rhythm dear my future. I hope it will be helpful to friends who are interested in PHP tutorials.
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
