澳门新葡萄京娱乐场正则表达式一

4.per正则函数 1.preg_grep函数 preg_grep(pattern,array input);
输入数组input中寻找匹配模式pattern的字串,并将所有的匹配字符串返回。返回值就是所有匹配的字符串组成的数组。
2.preg_match函数 preg_match(pattern,string subject,[array matches])
该函数在subject字符串中寻找匹配pattern的字符串。如果找到则返回一个非零值,否则返回零值。如果选用了可选项matches,那么匹配的字符串将被放到第一个元素的位置,可以用$matches[0]来读取,圆括号匹配的结果也按顺序放在这个数组中,第一个是$matches[1],第二个是$matches[2],依次类推。
3.preg_match_all函数 preg_match_all(pattern,subject,array
matches,[int order])
该函数在subject字符串中寻找匹配pattern的互不重叠的文本,找到了匹配的文本则返回匹配文本的个数,否则返回0。匹配文本被放在二维数组matches中,matches[0]中存放的是所有符合的字符串。各种嵌入的子模式匹配的结果依次放在数组matches[1]~[n]中。
order参数可选,可取的值为PREG_PATTERN_ORDER和PREG_SET_ORDER。
4.preg_replace函数 preg_replace(pattern,replacement,subject,[int
limit])
该函数将subject中符合pattern模式的部分替换成replacement,返回值类型和subject类型一样,如果有替换,则返回替换后的值,反之则返回原来的值。
参数可以是数组也可以是变量,有几种情况:
1如果subject参数是数组类型。函数对每一个数组元素进行替换操作;
2如果pattern是数组则函数根据每一个pattern中的类型进行替换;
3如果pattern和replacement都是数组,则按两个数组中的元素对应完成替换;
4如果replacement中的元素个数少于pattern中的元素个数。那么不够的部分将有空字符串来代替。
5.preg_split函数 preg_split(pattern,subject,[int limit][flages])
该函数以pattern定义的模式为分隔符将subject字符串分隔为若干个部分,返回数组,其中存放被分隔后的字符串。limit可限制返回字符串的数目,如果设置为-1表示对返回的字符串数目不加任何限制。flags也是可选项,其有两个值:PREG_SPLIT_NO_EMPTY设定函数不返回空字符串,PERG_SPLIT_DELIM_CAPTURE,该选项设定pattern中的嵌入子模式也会被函数匹配。

preg_grep
(PHP 4, PHP 5)

1. preg_match — 执行一个正则表达式匹配 int preg_match ( string $pattern , string $subject [, array
&$matches [, int $flags = 0 [, int $offset = 0 ]]] )
搜索subject与pattern给定的正则表达式的一个匹配.
pattern:
要搜索的模式,字符串类型。
subject :
输入字符串。
matches:
如果提供了参数matches,它将被填充为搜索结果。
$matches[0]将包含完整模式匹配到的文本,
$matches[1]将包含第一个捕获子组匹配到的文本,以此类推。
flags:
flags可以被设置为以下标记值:PREG_OFFSET_CAPTURE
如果传递了这个标记,对于每一个出现的匹配返回时会附加字符串偏移量(相对于目标字符串的)。
注意:这会改变填充到matches参数的数组,使其每个元素成为一个由
第0个元素是匹配到的字符串,第1个元素是该匹配字符串
在目标字符串subject中的偏移量。
offset:
通常,搜索从目标字符串的开始位置开始。可选参数 offset 用于
指定从目标字符串的某个未知开始搜索(单位是字节)。
返回值:
preg_match()返回 pattern 的匹配次数。
它的值将是0次(不匹配)或1次,因为 preg_match()在第一次匹配后
将会停止搜索。
preg_match_all()不同于此,它会一直搜索subject直到到达结尾。
如果发生错误 preg_match()返回 FALSE。
示例:

preg_grep —   返回与模式匹配的数组单元 
说明
array preg_grep ( string pattern, array input [, int flags] )

<?php
/*
 *模式分隔符后的”i”标记这是一个大小写不敏感的搜索
 *将会输出:1
 */
echo preg_match(“/,s*(php)/i”, “In my point, PHP is the web
scripting language of choice.”);
echo “<br/>”.”n”;
/*
 *将会输出:Array([0]=>, PHP [1]=>PHP) 
 */
$matches = array();
preg_match(“/,s*(php)/i”, “In my point, PHP is the web scripting
language of choice. I love php”, $matches);
print_r($matches);
echo “<br/>”.”n”;
/*
 *将会输出:Array([0]=>Array([0]=>, PHP [1]=>11)
[1]=>Array([0]=>PHP [1]=>13)) 
 */
preg_match(“/,s*(php)/i”, “In my point, PHP is the web scripting
language of choice. I love php”, $matches, PREG_OFFSET_CAPTURE);
print_r($matches);
echo “<br/>”.”n”;
/*
 *将会输出:Array([0]=>Array([0]=>e php [1]=63)
[1]=>Array([0]=>php [1]=>65)) 
 */
preg_match(“/[,a-z]?s*(php)/i”, “In my point, PHP is the web
scripting language of choice. I love php”, $matches,
PREG_OFFSET_CAPTURE, 28);
print_r($matches);
echo “<br/>”.”n”;
?> 

preg_grep() 返回一个数组,其中包括了 input 数组中与给定的 pattern 模式相匹配的单元。 

2.preg_match_all —
执行一个全局正则表达式匹配
int preg_match_all ( string $pattern , string $subject [,
array &$matches [, int $flags = PREG_PATTERN_ORDER [, int $offset =
0 ]]] )
搜索subject中所有匹配pattern给定正则表达式
的匹配结果并且将它们以flag指定顺序输出到matches中. 在第一个匹配找到后,
子序列继续从最后一次匹配位置搜索.
pattern:
要搜索的模式,字符串形式。
subject :
输入字符串。
matches:
多维数组,作为输出参数输出所有匹配结果, 数组排序通过flags指定。
flags:
可以结合下面标记使用(注意不能同时使用PREG_PATTERN_ORDER和PREG_SET_ORDER),如果没有给定排序标记,假定设置为PREG_PATTERN_ORDER:
PREG_PATTERN_ORDER:
结果排序为$matches[0]保存完整模式的所有匹配,
$matches[1]保存第一个子组的所有匹配,以此类推。
PREG_SET_ORDER:
结果排序为$matches[0]包含第一次匹配得到的所有匹配(包含子组),
$matches[1]是包含第二次匹配到的所有匹配(包含子组)的数组,以此类推。
PREG_OFFSET_CAPTURE:
如果这个标记被传递,每个发现的匹配返回时会增加它相对目标字符串的偏移量。
注意这会改变matches中的每一个匹配结果字符串元素,使其
成为一个第0个元素为 匹配结果字符串,第1个元素为
匹配结果字符串在subject中的偏移量。
返回值:
返回完整匹配次数(可能是0),或者如果发生错误返回FALSE。
示例:

flags 可以是以下标记: 

<?php
/*
 *将会输出:2
 */
echo preg_match_all(“/php/i”, “In my point, PHP is the web scripting
language of choice. I love php”, $matches);
echo “<br/>”.”n”;
/*
 *将会输出:Array([0]=>, PHP [1]=>PHP) 
 */
$matches = array();
preg_match(“/[,a-z]?s*(php)/i”, “In my point, PHP is the web
scripting language of choice. I love php”, $matches);
print_r($matches);
echo “<br/>”.”n”;
/*
 *将会输出:Array([0]=>Array([0]=>, PHP [1]=>e php)
[1]=>Array([0]=>PHP [1]=>php)) 
 */
$matches = array();
preg_match_all(“/[,a-z]?s*(php)/i”, “In my point, PHP is the web
scripting language of choice. I love php”, $matches,
PREG_PATTERN_ORDER);
print_r($matches);
echo “<br/>”.”n”;
/*
 *将会输出:Array([0]=>Array([0]=>Array([0]=>, PHP
[1]=>11) [1]=>Array([0]=>PHP [1]=>13))
[1]=>Array([0]=>Array([0]=>e php [1]=>63)
[1]=>Array([0]=>php [1]=>65)))
 */
$matches = array();
preg_match_all(“/[,a-z]?s*(php)/i”, “In my point, PHP is the web
scripting language of choice. I love php”, $matches,
PREG_SET_ORDER|PREG_OFFSET_CAPTURE);
print_r($matches);
echo “<br/>”.”n”;
/*
 *Array([0]=>Array([0]=>e php [1]=>63)
[1]=>Array([0]=>php [1]=>65))
 */
$matches = array();
preg_match_all(“/[,a-z]?s*(php)/i”, “In my point, PHP is the web
scripting language of choice. I love php”, $matches,
PREG_SET_ORDER|PREG_OFFSET_CAPTURE, 28);
print_r($matches);
echo “<br/>”.”n”;
?>

PREG_GREP_INVERT 
如果传递入此标记,preg_grep() 会返回输入数组中不匹配给定 pattern 的单元。本标记自 PHP 4.2.0 起可用。 

3.preg_split —
通过一个正则表达式分隔字符串
array preg_split ( string $pattern , string $subject [, int
$limit = -1 [, int $flags = 0 ]] )
通过一个正则表达式分隔给定字符串.
pattern:
用于搜索的模式,字符串形式。
subject:
输入字符串
limit:
如果指定,将限制分隔得到的子串最多只有limit个,返回的最后一个
子串将包含所有剩余部分。limit值为-1, 0或null时都代表”不限制”,
作为php的标准,你可以使用null跳过对flags的设置。
flags:
flags 可以是任何下面标记的组合(以位或运算 | 组合):
PREG_SPLIT_NO_EMPTY:
如果这个标记被设置, preg_split() 将进返回分隔后的非空部分。
PREG_SPLIT_DELIM_CAPTURE:
如果这个标记设置了,用于分隔的模式中的括号表达式将被捕获并返回。
PREG_SPLIT_OFFSET_CAPTURE:
如果这个标记被设置, 对于每一个出现的匹配返回时将会附加字符串偏移量.
注意:这将会改变返回数组中的每一个元素,
使其每个元素成为一个由第0个元素为分隔后的子串,第1个元素为该子串在subject中的偏移量组成的数组。
返回值:
返回一个使用 pattern 边界分隔 subject 后得到 的子串组成的数组。
示例:

自 PHP 4.0.4 起,preg_grep() 返回的结果使用从输入数组来的键名进行索引。如果不希望这样的结果,用 array_values() 对 preg_grep() 返回的结果重新索引。 

<?php
/*
 *将会输出:
 *Array ( [0] => In my point, [1] => is the web scripting
language of choice. I love [2] => )
 */
$matches = array();
print_r(preg_split(“/php/i”, “In my point, PHP is the web scripting
language of choice. I love php”));
echo “<br/>”.”n”;
/*
 *将会输出:
 *Array ( [0] => In my point, [1] => is the web scripting
language of choice. I love php )
 */
$matches = array();
print_r(preg_split(“/php/i”, “In my point, PHP is the web scripting
language of choice. I love php”, 2));
echo “<br/>”.”n”;
/*
 *将会输出:
 *Array ( [0] => In my point, [1] => is the web scripting
language of choice. I love )
 */
$matches = array();
print_r(preg_split(“/php/i”, “In my point, PHP is the web scripting
language of choice. I love php”, -1, PREG_SPLIT_NO_EMPTY));
echo “<br/>”.”n”;
?>

上面是手册上对preg_grep()的说明。首先这是perl兼容的正则函数,所以我猜想preg_grep的意思是p(perl)reg(regular)_grep,其特点是可做用于数组,通过自己扩展,可用做多维数组中的正则匹配,并且可以通过flags参数返回匹配或者非匹配数组。其效率比用foreach(…){if…}结构快很多(未验证),而且可匹配复杂模式。在搜索、分检等应用中用途不小。

4.preg_quote — 转义正则表达式字符 string preg_quote ( string $str [, string $delimiter = NULL
] )
preg_quote()需要参数 str 并向其中
每个正则表达式语法中的字符前增加一个反斜线。
这通常用于你有一些运行时字符串 需要作为正则表达式进行匹配的时候。

例:

正则表达式特殊字符有: . + * ? [ ^ ] $ ( ) { } = ! < > | :

str:
输入字符串
delimiter:
如果指定了可选参数 delimiter,它也会被转义。这通常用于
转义PCRE函数使用的分隔符。 /是最通用的分隔符。
返回值:
返回转义后的字符串。
示例:

<?php
//在这个例子中,preg_quote($word)
用于保持星号原文涵义,使其不使用正则表达式中的特殊语义。
$textbody = “This book is *very* difficult to find.”;
$word = “*very*”;
$textbody = preg_replace (“/” . preg_quote($word) . “/”, “<i>” .
$word . “</i>”, $textbody);
//将会输出This book is <i>*very*</i> difficult to find.
echo htmlspecialchars($textbody);
?>

5.preg_grep — 返回匹配模式的数组条目 array preg_grep ( string $pattern , array $input [, int
$flags = 0 ] )
返回给定数组input中与模式pattern匹配的元素组成的数组.
pattern:
要搜索的模式, 字符串形式.
input:
输入数组.
flags:
如果设置为PREG_GREP_INVERT, 这个函数返回输入数组中与
给定模式pattern不匹配的元素组成的数组.
返回值:
返回使用input中key做索引的数组.
示例:

<?php
$array = array(“abc”, “dd”, “123”, “123.22”, “word123”, “33.2”,
“0.22”);
//返回所有包含浮点数的元素
//输出:Array ( [3] => 123.22 [5] => 33.2 [6] => 0.22 )
$fl_array = preg_grep(“/^(d+)?.d+$/”, $array);
print_r($fl_array);
//返回所有包含浮点数的元素
//输出:Array ( [0] => abc [1] => dd [2] => 123 [4]
=> word123 )
$fl_array = preg_grep(“/^(d+)?.d+$/”, $array,
PREG_GREP_INVERT);
print_r($fl_array);
?>

6.preg_replace —
执行一个正则表达式的搜索和替换
mixed preg_replace ( mixed $pattern , mixed $replacement ,
mixed $subject [, int $limit = -1 [, int &$count ]] )
搜索subject中匹配pattern的部分, 以replacement进行替换。
pattern:
要搜索的模式。可以是一个字符串或字符串数组。 可以使用一些PCRE修饰符,
包括’e'(PREG_REPLACE_EVAL),可以为这个函数指定。
replacement:
用于替换的字符串或字符串数组。如果这个参数是一个字符串,并且pattern是一个数组,那么所有的模式都使用这个字符串进行替换。如果pattern和replacement都是数组,每个pattern使用replacement中对应的
元素进行替换。如果replacement中的元素比pattern中的少,
多出来的pattern使用空字符串进行替换。replacement中可以包含后向引用\n或(php
4.0.4以上可用)$n,语法上首选后者。 每个
这样的引用将被匹配到的第n个捕获子组捕获到的文本替换。
n可以是0-99,\0和$0代表完整的模式匹配文本。
捕获子组的序号计数方式为:代表捕获子组的左括号从左到右,
从1开始数。如果要在replacement中使用反斜线,必须使用4个(“\\”,译注:因为这首先是php的字符串,经过转义后,是两个,再经过
正则表达式引擎后才被认为是一个原文反斜线)。
当在替换模式下工作并且后向引用后面紧跟着需要是另外一个数字(比如:在一个匹配模式后紧接着增加一个原文数字),
不能使用\1这样的语法来描述后向引用。比如, \11将会使
preg_replace()不能理解你希望的是一个\1后向引用紧跟一个原文1,还是
一个\11后向引用后面不跟任何东西。 这种情况下解决方案是使用${1}1。
这创建了一个独立的$1后向引用, 一个独立的原文1。 当使用e修饰符时,
这个函数会转义一些字符(即:’、”、 和 NULL)
然后进行后向引用替换。当这些完成后请确保后向引用解析完后没有单引号或
双引号引起的语法错误(比如:
‘strlen(‘$1′)+strlen(“$2”)’)。确保符合PHP的
字符串语法,并且符合eval语法。因为在完成替换后,
引擎会将结果字符串作为php代码使用eval方式进行评估并将返回值作为最终参与替换的字符串。
subject:
要进行搜索和替换的字符串或字符串数组。
如果subject是一个数组,搜索和替换回在subject的每一个元素上进行,
并且返回值也会是一个数组。
limit:
每个模式在每个subject上进行替换的最大次数。默认是 -1(无限)。
count:
如果指定,将会被填充为完成的替换次数。
返回值:
如果subject是一个数组, preg_replace()返回一个数组,
其他情况下返回一个字符串。
如果匹配被查找到,替换后的subject被返回,其他情况下 返回没有改变的
subject。如果发生错误,返回 NULL 。
示例:
使用后向引用紧跟数值原文:

<?php
$string = ‘April 15, 2003’;
/*
 *w+字符重复一次或者多次
 *d+数字重复一次或者多次
 *i忽略大小写
 */
$pattern = ‘/(w+) (d+), (d+)/i’;
/*
 *$0 完整的模式匹配文本
 *${1}1 第一个小括号中的模式匹配文本并且在后面加1
 *\3 第三个小括号中的模式匹配文本
 */
$replacement = ‘$0:<br/> ${1}1,\3’;
echo preg_replace($pattern, $replacement, $string);
?>

preg_replace()中使用基于索引的数组:

$string = ‘The quick brown fox jumped over the lazy dog.’;
$patterns = array();
$patterns[0] = ‘/quick/’;
$patterns[1] = ‘/brown/’;
$patterns[2] = ‘/fox/’;
$replacements = array();
$replacements[2] = ‘bear’;
$replacements[1] = ‘black’;
$replacements[0] = ‘slow’;
//会输出:The bear black slow jumped over the lazy dog.
echo preg_replace($patterns, $replacements, $string);
//对模式和替换内容按key进行排序我们可以得到期望的结果.
ksort($patterns);
ksort($replacements);
//会输出:The slow black bear jumped over the lazy dog.
echo preg_replace($patterns, $replacements, $string);

替换一些值:

<?php
$patterns = array (‘/(19|20)(d{2})-(d{1,2})-(d{1,2})/’,
                   ‘/^s*{(w+)}s*=/’);
$replace = array (‘3/4/12’, ‘$1 =’);
echo preg_replace($patterns, $replace, ‘{startDate} = 1999-5-27’);
?>

使用修饰符’e’:

<?php
$html_body = “<p><span>hello</span></p>”;
//会输出:<P><SPAN>hello</SPAN></P>
echo
htmlspecialchars(preg_replace(“/(</?)(w+)([^>]*>)/e”,
             “‘\1’.strtoupper(‘\2’).’\3′”,
             $html_body));
?>

剥离空白字符:

<?php
$str = ‘foo   o’;
$str = preg_replace(‘/ss+/’, ‘ ‘, $str);
// 将会改变为’foo o’
echo $str;
?>

使用参数count:

<?php
$count = 0;
echo preg_replace(array(‘/d/’, ‘/s/’), ‘*’, ‘xp 4 to’, -1 ,
$count);
//等价于echo preg_replace(‘/d|s/’, ”, ‘xp 4 to’, -1 , $count);
echo $count; //3
?>

7.preg_replace_callback —
执行一个正则表达式搜索并且使用一个回调进行替换
mixed preg_replace_callback ( mixed $pattern , callable
$callback , mixed $subject [, int $limit = -1 [, int &$count ]] )
这个函数的行为除了 可以指定一个 callback 替代 replacement 进行替换
字符串的计算,其他方面等同于 preg_replace()。
pattern:
要搜索的模式,可以使字符串或一个字符串数组。
callback:
一个回调函数,在每次需要替换时调用,调用时函数得到的参数是从subject中匹配到的结果。回调函数返回真正参与替换的字符串。
你可能经常会需要callback函数而 仅用于
preg_replace_callback()一个地方的调用。在这种情况下,你可以使用匿名函数来定义一个匿名函数作为preg_replace_callback()调用时的回调。
这样做你可以保留所有
调用信息在同一个位置并且不会因为一个不在任何其他地方使用的回调函数名称而污染函数名称空间。
subject:
要搜索替换的目标字符串或字符串数组。
limit:
对于每个模式用于每个 subject 字符串的最大可替换次数。
默认是-1(无限制)。
count:
如果指定,这个变量将被填充为替换执行的次数。
示例:
preg_replace_callback() 和 create_function():

<?php
// 将文本中的年份增加一年.
$text = “April fools day is 04/01/2002n”;
$text.= “Last christmas was 12/24/2001n”;
// 回调函数
function next_year($matches)
{
  // 通常: $matches[0]是完成的匹配
  // $matches[1]是第一个捕获子组的匹配
  // 以此类推
  return $matches[1].($matches[2]+1);
}
/**
 *将会输出:
 *April fools day is 04/01/2003
 *Last christmas was 12/24/2002
 */
echo preg_replace_callback(
            “|(d{2}/d{2}/)(d{4})|”,
            “next_year”,
            $text);
//使用create_function
echo preg_replace_callback(
            “|(d{2}/d{2}/)(d{4})|”,
            create_function(
            ‘$matches’,
            ‘return $matches[1].($matches[2]+1);’
            ),
            $text);
?>

<?
$arr = array(‘abc’=>12.213,’bb’=>12345,’ba’=>23.2321,34.3,’23’=>’3.3′,’23434’=>’bbb’);

// 返回所有含有浮点数的数组元素。
$fl_array = preg_grep (“/^(d+)?.d+$/”, $arr);
print_r($fl_array);

?>

preg_match
(PHP 3 >= 3.0.9, PHP 4, PHP 5)

preg_match — 进行正则表达式匹配
说明
int preg_match ( string pattern, string subject [, array matches [, int flags]] )

在 subject 字符串中搜索与 pattern 给出的正则表达式相匹配的内容。 

如果提供了 matches,则其会被搜索的结果所填充。$matches[0] 将包含与整个模式匹配的文本,$matches[1] 将包含与第一个捕获的括号中的子模式所匹配的文本,以此类推。 

flags 可以是下列标记: 

PREG_OFFSET_CAPTURE 
如果设定本标记,对每个出现的匹配结果也同时返回其附属的字符串偏移量。注意这改变了返回的数组的值,使其中的每个单元也是一个数组,其中第一项为匹配字符串,第二项为其偏移量。本标记自 PHP 4.3.0 起可用。 

flags 参数自 PHP 4.3.0 起可用。 

preg_match() 返回 pattern 所匹配的次数。要么是 0 次(没有匹配)或 1 次,因为 preg_match() 在第一次匹配之后将停止搜索。preg_match_all() 则相反,会一直搜索到 subject 的结尾处。如果出错 preg_match() 返回 FALSE。 

提示: 如果只想查看一个字符串是否包含在另一个字符串中,不要用 preg_match()。可以用 strpos() 或 strstr() 替代,要快得多。 

上面是手册里对preg_match()的说明,我认为这个函数的功用在于他可做来做验证,也就是某字符串是否符合某特定要求。其局限是上面所说的要么匹配0次,要么1次。并且返回值是匹配次数。当需要全匹配时可使用preg_match_all().另外值得一提的是$matches数组的作用,可做自模式的返回值,有时很有用。

例:

<?

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 {
     print “A match was not found.”;
}

?>

<?php
// 从 URL 中取得主机名
preg_match(“/^(http://)?([^/]+)/i”,
     “”, $matches);
$host = $matches[2];

// 从主机名中取得后面两段
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 — 进行全局正则表达式匹配

手册上该函数的解释非常明确,就不多做说明了。
说明
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] 为第一个括号中的子模式所匹配的字符串组成的数组,以此类推。 

<?php
preg_match_all (“|<[^>]+>(.*)</[^>]+>|U”,
     “<b>example: </b><div align=left>this is a test</div>”,
     $out, PREG_PATTERN_ORDER);
print $out[0][0].”, “.$out[0][1].”n”;
print $out[1][0].”, “.$out[1][1].”n”;
?>  

本例将输出: 

<b>example: </b>, <div align=left>this is a test</div>
example: , this is a test

因此,$out[0] 包含匹配整个模式的字符串,$out[1] 包含一对 HTML 标记之间的字符串。 

PREG_SET_ORDER 
对结果排序使 $matches[0] 为第一组匹配项的数组,$matches[1] 为第二组匹配项的数组,以此类推。 

<?php
preg_match_all (“|<[^>]+>(.*)</[^>]+>|U”,
     “<b>example: </b><div align=left>this is a test</div>”,
     $out, PREG_SET_ORDER);
print $out[0][0].”, “.$out[0][1].”n”;
print $out[1][0].”, “.$out[1][1].”n”;
?>  

本例将输出: 

<b>example: </b>, example:
<div align=left>this is a test</div>, this is a test

本例中,$matches[0] 是第一组匹配结果,$matches[0][0] 包含匹配整个模式的文本,$matches[0][1] 包含匹配第一个子模式的文本,以此类推。同样,$matches[1] 是第二组匹配结果,等等。 

PREG_OFFSET_CAPTURE 
如果设定本标记,对每个出现的匹配结果也同时返回其附属的字符串偏移量。注意这改变了返回的数组的值,使其中的每个单元也是一个数组,其中第一项为匹配字符串,第二项为其在 subject 中的偏移量。本标记自 PHP 4.3.0 起可用。 

如果没有给出标记,则假定为 PREG_PATTERN_ORDER。 

返回整个模式匹配的次数(可能为零),如果出错返回 FALSE。 

例子 1. 从某文本中取得所有的电话号码

<?php
preg_match_all (“/(?   (d{3})?   )?   (?(1)   [-s] ) d{3}-d{4}/x”,
                 “Call 555-1212 or 1-800-555-1212”, $phones);
?>  

例子 2. 搜索匹配的 HTML 标记(greedy)

<?php
// \2 是一个逆向引用的例子,其在 PCRE 中的含义是
// 必须匹配正则表达式本身中第二组括号内的内容,本例中
// 就是 ([w]+)。因为字符串在双引号中,所以需要
// 多加一个反斜线。
$html = “<b>bold text</b><a href=howdy.html>click me</a>”;

preg_match_all (“/(<([w]+)[^>]*>)(.*)(</\2>)/”, $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 — 转义正则表达式字符
说明
string preg_quote ( string str [, string delimiter] )

preg_quote() 以 str 为参数并给其中每个属于正则表达式语法的字符前面加上一个反斜线。如果你需要以动态生成的字符串作为模式去匹配则可以用此函数转义其中可能包含的特殊字符。 

如果提供了可选参数 delimiter,该字符也将被转义。可以用来转义 PCRE 函数所需要的定界符,最常用的定界符是斜线 /。 

正则表达式的特殊字符包括:.  + * ? [ ^ ] $ ( ) { } = ! < > | :。 

注: 本函数可安全用于二进制对象。

上面是手册上的解释,也很明白,不多说了,另外手册上还有一注释就是该函数可安全用于二进制对象,这点很有用。

例: 例子 1. preg_quote() 例子

<?php
$keywords = ‘$40 for a g3/400’;
$keywords = preg_quote($keywords, ‘/’);
echo $keywords; // returns $40 for a g3/400
?>  

例子 2. 给某文本中的一个单词加上斜体标记

<?php
// 本例中,preg_quote($word) 用来使星号不在正则表达式中
// 具有特殊含义。

$textbody = “This book is *very* difficult to find.”;
$word = “*very*”;
$textbody = preg_replace (“/”.preg_quote($word).”/”,
                           “<i>”.$word.”</i>”,
                           $textbody);
?>  

接下来就是应用超灵活、、功能超强大、使用超广泛的preg_replace函数。

preg_replace
(PHP 3 >= 3.0.9, PHP 4, PHP 5)

preg_replace — 执行正则表达式的搜索和替换
说明
mixed preg_replace ( mixed pattern, mixed replacement, mixed subject [, int limit] )

在 subject 中搜索 pattern 模式的匹配项并替换为 replacement。如果指定了 limit,则仅替换 limit 个匹配,如果省略 limit 或者其值为 -1,则所有的匹配项都会被替换。 

replacement 可以包含 \n 形式或(自 PHP 4.0.4 起)$n 形式的逆向引用,首选使用后者。每个此种引用将被替换为与第 n 个被捕获的括号内的子模式所匹配的文本。n 可以从 0 到 99,其中 \0 或 $0 指的是被整个模式所匹配的文本。对左圆括号从左到右计数(从 1 开始)以取得子模式的数目。 

对替换模式在一个逆向引用后面紧接着一个数字时(即:紧接在一个匹配的模式后面的数字),不能使用熟悉的 \1 符号来表示逆向引用。举例说 \11,将会使 preg_replace() 搞不清楚是想要一个 \1 的逆向引用后面跟着一个数字 1 还是一个 \11 的逆向引用。本例中的解决方法是使用 ${1}1。这会形成一个隔离的 $1 逆向引用,而使另一个 1 只是单纯的文字。 

如果搜索到匹配项,则会返回被替换后的 subject,否则返回原来不变的 subject。 

preg_replace() 的每个参数(除了 limit)都可以是一个数组。如果 pattern 和 replacement 都是数组,将以其键名在数组中出现的顺序来进行处理。这不一定和索引的数字顺序相同。如果使用索引来标识哪个 pattern 将被哪个 replacement 来替换,应该在调用 preg_replace() 之前用 ksort() 对数组进行排序。 

如果 subject 是个数组,则会对 subject 中的每个项目执行搜索和替换,并返回一个数组。 

如果 pattern 和 replacement 都是数组,则 preg_replace() 会依次从中分别取出值来对 subject 进行搜索和替换。如果 replacement 中的值比 pattern 中的少,则用空字符串作为余下的替换值。如果 pattern 是数组而 replacement 是字符串,则对 pattern 中的每个值都用此字符串作为替换值。反过来则没有意义了。 

/e 修正符使 preg_replace() 将 replacement 参数当作 PHP 代码(在适当的逆向引用替换完之后)。提示:要确保 replacement 构成一个合法的 PHP 代码字符串,否则 PHP 会在报告在包含 preg_replace() 的行中出现语法解析错误。 

注: limit 参数是 PHP 4.0.1pl2 之后加入的。 

我认为其强大之处就是他不但可以处理字符串,而且可以处理数组,并且他的逆向引用功能非常灵活。基本上他可以满足普通用户的大部分需求,如果他不能胜任,那么我们还有preg_replace_callback()函数,可以自定义回调函数,满足你的高级要求。如设计过滤器等。

preg_replace_callback
(PHP 4 >= 4.0.5, PHP 5)

preg_replace_callback — 用回调函数执行正则表达式的搜索和替换
说明
mixed preg_replace_callback ( mixed pattern, callback callback, mixed subject [, int limit] )

本函数的行为几乎和 preg_replace() 一样,除了不是提供一个 replacement 参数,而是指定一个 callback 函数。该函数将以目标字符串中的匹配数组作为输入参数,并返回用于替换的字符串。 

例子 1. preg_replace_callback() 例子

<?php
   // 此文本是用于 2002 年的,
   // 现在想使其能用于 2003 年
   $text = “April fools day is 04/01/2002n”;
   $text.= “Last christmas was 12/24/2001n”;

   // 回调函数
   function next_year($matches) {
     // 通常:$matches[0] 是完整的匹配项
     // $matches[1] 是第一个括号中的子模式的匹配项
     // 以此类推
     return $matches[1].($matches[2]+1);
   }

   echo preg_replace_callback(
               “|(d{2}/d{2}/)(d{4})|”,
               “next_year”,
               $text);

   // 结果为:
   // April fools day is 04/01/2003
   // 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. 

对于使用preg_replace_callback()函数的朋友来说,你应该回需要callback函数(否则用他干嘛,直接用preg_replace不是更好),不过也经常只是用一处。既然这样你可以用create_function()来声明一个匿名函数作为preg_replace_callback()的回调函数。这样,我们即满足了声明信息的需要,有不致因这个不会再用到的函数名而混乱。

例子 2. preg_replace_callback() 和 create_function()

<?php
   /* 一个 UNIX 风格的命令行过滤器,将每个段落开头的
   * 大写字母转换成小写字母 */

   $fp = fopen(“php://stdin”, “r”) or die(“can’t read stdin”);
   while (!feof($fp)) {
       $line = fgets($fp);
       $line = preg_replace_callback(
           ‘|<p>s*w|’,
           create_function(
               // 这里使用单引号很关键,
               // 否则就把所有的 $ 换成 $
               ‘$matches’,
               ‘return strtolower($matches[0]);’
           ),
           $line
       );
       echo $line;
   }
   fclose($fp);
?>  

最后是

preg_split
(PHP 3 >= 3.0.9, PHP 4, PHP 5)

preg_split — 用正则表达式分割字符串
不再赘述。
说明
array preg_split ( string pattern, string subject [, int limit [, int flags]] )

返回一个数组,包含 subject 中沿着与 pattern 匹配的边界所分割的子串。 

如果指定了 limit,则最多返回 limit 个子串,如果 limit 是 -1,则意味着没有限制,可以用来继续指定可选参数 flags。 

flags 可以是下列标记的任意组合(用按位或运算符 | 组合): 

PREG_SPLIT_NO_EMPTY 
如果设定了本标记,则 preg_split() 只返回非空的成分。 

PREG_SPLIT_DELIM_CAPTURE 
如果设定了本标记,定界符模式中的括号表达式也会被捕获并返回。本标记添加于 PHP 4.0.5。 

PREG_SPLIT_OFFSET_CAPTURE 
如果设定了本标记,如果设定本标记,对每个出现的匹配结果也同时返回其附属的字符串偏移量。注意这改变了返回的数组的值,使其中的每个单元也是一个数组,其中第一项为匹配字符串,第二项为其在 subject 中的偏移量。本标记自 PHP 4.3.0 起可用。 

提示: 如果不需要正则表达式的功能,可以选择使用更快(也更简单)的替代函数如 explode() 或 str_split()。  

发表评论

电子邮件地址不会被公开。 必填项已用*标注