2007-11-05

[轉載]Regular Expression 教學

文章原始出處
作者 : hkln(HKLN.net)


[分享] Regular Expression 新手入門

Regular Expression (正規表示式,簡寫 regexp或regex)
是一個字串,可用來描述字串的模式,
例如我要表達「兩個英文大寫字母」,那麼 regexp 就是 [A-Z]{2}。
而使用這個 regexp ,就可以在一個字串內找出配合 (Match) 的部份,
例如在字串 $st = '11AA22BB33' 內,有哪些部份配合「兩個英文大寫字母」這個模式?
就會找到 'AA' 和 'BB' 兩部份了。

以下是一些常見的 regexp 應用:

use strict;
my ($st, $pattern, $replacement, @array, @matches);

##
## 有沒有找到至少一個 Match?
##
$st = '11AA22';
$pattern = 'AA';

if ($st =~ /$pattern/) {
print "has at least one match\n";
} else {
print "no match\n";
}


##
## 找出所有 Matches
##
$st = '11AA22BB33';
$pattern = '[A-Z]{2}';

@matches = $st =~ /$pattern/g;

foreach my $i (0 .. $#matches) {
print "$i : $matches[$i]\n";
}


##
## 找出所有 Matches,並取代它們
##
$st = '11AA22AA33';
$pattern = 'AA';
$replacement = 'XX';

$st =~ s/$pattern/$replacement/g;

print "$st\n";


##
## 在 Matches 的位置分割
##
$st = '11AA22AA33';
$pattern = 'AA';

@array = split /$pattern/, $st;

print join ',', @array;



以下是 .Net 例子(以 C# 語言)

using System;
using System.Text.RegularExpressions;

class MainClass
{
public static void Main(string[] args)
{
string st, pattern, replacement;
string[] array;
MatchCollection mc;

//
// has at least one match?
//
st = "11AA22";
pattern = @"AA";

if ( Regex.IsMatch(st, pattern) ) {
Console.WriteLine("has at least one match");
} else {
Console.WriteLine("no match");
}

//
// get all matches
//
st = "11AA22BB33";
pattern = @"[A-Z]{2}";

mc = Regex.Matches(st, pattern);

for (int i = 0; i < mc.Count; i++ )
{
Console.WriteLine("{0} : {1}", i, mc[i]);
}
//
// search and replace
//
st = "11AA22AA33"; pattern = @"AA"; replacement = "XX";
st = Regex.Replace(st, pattern, replacement);
Console.WriteLine("{0}", st);
//
// split
//
st = "11AA22AA33"; pattern = "AA";
array = Regex.Split(st, pattern);
Console.WriteLine(String.Join(",", array));
}
}


[[解釋 regexp 的意思]]
當您遇到一些很難看得懂的 regexp, 您可以用 YAPE::Regex::Explain 模組, 把 regexp 翻譯成英文,這對新手來說有很大幫助。

#### use YAPE::Regex::Explain;
my $pattern = '[A-Z]{2}';
print YAPE::Regex::Explain->new($pattern)->explain;
####

輸出結果:
[A-Z]{2} any character of: 'A' to 'Z' (2 times)
意思是「任何一個由 'A' 至 'Z' 的字元(兩次)」,
那麼它配合的東西就是:
AA
AB
...
AZ
BA
BB
...
ZA
ZB
...
ZZ
------------------------------------------------------------------------------------------------

>我目前所碰到的瓶頸是
>有沒有可能使用Regular Expression來判斷輸入的是數字,並且限定其數值範圍0.0

參考 perlretut 內的 "Building a regexp" 一節

------------------------------------------------------------------------------------------------

[[ 特殊字元 (Metacharacter) ]]

當您要表示一些特殊字元,例如括號,那就不能直接寫:
$pattern = '(';

而要在前面加上反斜號:
$pattern = '\(';

以下 regexp 的特殊字元:

{}[]()^$.|*+?/

為什麼這些是特殊字元呢?本文稍後會介紹。

例:
####
$st = '11((22';
$pattern = '\(\(';

@matches = $st =~ /$pattern/g;

foreach my $i (0 .. $#matches) {
print "$i : $matches[$i]\n";
}
####

順帶一提,應儘量用單引號來括字串,
因為它不會好像雙引號那樣會做字串插入,如果寫:
$pattern = "\(\(";

那結果變成:
$pattern = '((';

------------------------------------------------------------------------------------------------

[[ 脫離序列 (Escape Sequence) ]]

當您要表示 tab、 newline 等不能列印的字元,
可以用 Escape Sequence。

例:
$st = "11\t22\t33";
$pattern = '\t';

------------------------------------------------------------------------------------------------

[[ 字元類別 (Character Class) ]]

您除了可以表示一個固定的字元外,如
$pattern = 'A';

還可以表示一個字元集合,例如您想表示
「'A'字元或者'B'字元或者'C'字元」,可以寫
$pattern = '[ABC]';

即把您想 match 的字元寫在中括號內。

例:
$st = '11A22B33C44D';
$pattern = '[ABC]';

會找到以下的 match:
0 : A
1 : B
2 : C

例如您想找 'AAAXX' 或者 'AABXX' 或者 'AACXX':

$st = '11AACXX22AABXX33AAAXX44AAD';
$pattern = 'AA[ABC]XX';

會找到以下的 match:

0 : AACXX
1 : AABXX
2 : AAAXX

留意一點,雖然 $pattern 內的 [ABC] 是先寫A,
但結果是先找到 'AACXX',而不是'AAAXX',
因為 Perl 是先從 $st 的左邊開始找,而不是先從右邊開始找,
而 'AACXX' 是最左邊的 match。

------------------------------------------------------------------------------------------------

[[ 字元類別 - 脫離序列 ]]

在字元類別內表示一些特殊字元,也是要加反斜號,
不過字元類別內的特殊字元是:
-]\^$


本文稍後會解釋為何它們是特殊字元。

例:
$st = '11A22B33-44]';
$pattern = '[AB\-\]]';

會找到以下的 match:
0 : A
1 : B
2 : -
3 : ]

------------------------------------------------------------------------------------------------

[[ 字元類別 - 範圍運算子 (Range Operator) ]]

您可以用減號,來表示一段字元範圍,例如
$pattern = '[ABCDEFGHIJ]';

可以寫成
$pattern = '[A-J]';

這樣就更簡潔了。又例如
$pattern = '[ABCDKLMN0123]';

可以寫成
$pattern = '[A-DK-N0-3]';

但如果把減號寫在最頭或者最尾,例如
$pattern = '[-AB]';

$pattern = '[AB-]';

那麼減號就直接表示 '-' 字元,而不是範圍運算子了。

例:
$st = '99A88L773]';
$pattern = '[A-DK-N0-3]';

會找到以下的 match:
0 : A
1 : L
2 : 3


------------------------------------------------------------------------------------------------

[[ 字元類別 - 反相字元類別 (Negated Character Class) ]]

例如要表示「'A'或者'B'或者'C'」,就寫
$pattern = '[ABC]';

但如果要表示「'A'或者'B'或者'C'」的相反,即「不是'A'並且不是'B'並且不是'C'」
就可以寫
$pattern = '[^ABC]';

在字元類別內,如果第一個字元是 '^',就表示這是一個「反相字元類別」。

例:
$st = '11A22B33X44Y';
$pattern = '[^A-C0-9]';

會找到以下的 match:
0 : X
1 : Y

------------------------------------------------------------------------------------------------

[[ 字元類別 - 簡寫 ]]

Perl 提供了一些常用的字元類別簡寫,例如
$pattern = '[0-9]';

其實可以寫成
$pattern = '\d';

這就更簡潔了。以下列出這些簡寫:

\d 等於寫 [0-9]
\D 等於寫 [^0-9] ,即 \d 的相反
\w 等於寫 [0-9a-zA-Z_] ,即數字、英文大小寫字母和底線
\W 等於寫 [^0-9a-zA-Z_] ,即 \w 的相反
\s 等於寫 [\ \t\n\r\f] ,即白格字元 (Whitespace character),
包括space, tab, newline, carriage return, form feed

\S 等於寫 [^\ \t\n\r\f] ,即 \s 的相反

還有一個很特別的簡寫,就是點號 '.',
因為它比較複雜,所以稍後再介紹它。

例:
$st = '11A22b33_44=';
$pattern = '\D';

會找到以下的 match:
0 : A
1 : b
2 : _
3 : =


例:
$st = '11AA22A_33A044AX';
$pattern = 'A[^\dX-Z]';

會找到以下的 match:
0 : AA
1 : A_

------------------------------------------------------------------------------------------------

[[ Alternation ]]

如果想表示「'AB'字串或'KLM'字串或者'PQRST'」,可以寫
$pattern = 'AB|KLM|PQRST';
即用直線分隔它們。

Alternation 跟 Character Class 很像,
例如以下兩者是一樣的:

$pattern = '[ABC]';
$pattern = 'A|B|C';

不過 Character Class 不能表示超過一個字元的字串。

例:
$st = '11AB22KLMN33PQRS';
$pattern = 'AB|KLM|PQRST';

會找到以下的 match:
0 : AB
1 : KLM

如果寫:
$pattern = 'PQRST|KLM|AB';

那還是會先找到 'AB',效果跟 Character Class 一樣。

------------------------------------------------------------------------------------------------

[[群組 (Group)]]

如果想表示「'ABC'或者'ABKL'或者'ABPQR'」,除了可以寫:
$pattern = 'ABC|ABKL|ABPQR';

還可以這樣寫:
$pattern = 'AB(C|KL|PQR)';

即用括號來分開'AB'和接著的那三個 Alternatives,
好像數學上把 2*3 + 2*4 + 2*5 寫成 2 * (3+4+5)。

如果想連'AB'都要 match:
$pattern = 'AB|ABC|ABKL|ABPQR';

也可以把空字串都寫到括號內:
$pattern = 'AB(C|KL|PQR|)';

------------------------------------------------------------------------------------------------

[[群組 - 特殊變數 $1, $2, ...]]

括號還有一種特別的功能,就是把括號內 match 到的部份
放到特殊變數 $1, $2, ...。

例如您想檢查某字串是含有時間的模式,例如 HH:MM:SS,
(不檢查數值範圍),同時想取得時分秒各個部份,可以寫:

####
my ($time_string, $hour, $minute, $second);

$time_string = '12:34:56';
$pattern = '(\d\d):(\d\d):(\d\d)';

if ($time_string =~ /$pattern/) {
($hour, $minute, $second) = ($1, $2, $3);
print "hour=$hour,minute=$minute,second=$second";
} else {
print 'Invalid time format';
}

####

執行結果:
hour=12,minute=34,second=56


至於哪部份是 $1, $2, ...,就以開括號出現的先後順序來決定,
例如括著「時」那個開括號是第一個出現的,所以它就對應 $1。

(\d\d):(\d\d):(\d\d)
1______2______3

------------------------------------------------------------------------------------------------

[[群組 - 巢狀群組]]

括號內也可以有括號,成為巢狀群組,例如:

(\d\d):((\d\d):(\d\d))
1______23______4

####
my ($time_string, $hour, $minute, $second);

$time_string = '12:34:56';
$pattern = '(\d\d):((\d\d):(\d\d))';

if ($time_string =~ /$pattern/) {
print "\$1=$1\n\$2=$2\n\$3=$3\n\$4=$4";
} else {
print 'Invalid time format';
}
####

執行結果:
$1=12
$2=34:56
$3=34
$4=56

------------------------------------------------------------------------------------------------

[[群組 - 返回參照 (Backreferences) \1, \2, ...]]


跟 $1, $2, ... 有很密切關係的東西,就是 Backreferences,
即 \1, \2, ... 。

它們不同之處,在於 $1 只應該用在 regexp 「以外」,
而 \1 只應該用在 regexp 「以內」。

例:
####
$st = 'A_A';
$pattern = '([ABC])_\1';

if ($st =~ /$pattern/) {
print "\$1=$1";
}
####

執行結果:
$1=A


您可以嘗試把 $st 改成:
$st = 'B_B';
$st = 'C_C';

您會發現 \1 能夠取得之前所 match 的東西,
即應該放到 $1 的值。但要緊記,不應該在 regexp 以內寫 $1。


例:
####
$st = 'ALZ_A_L_Z';
$pattern = '([ABC])([KLM])([XYZ])_\1_\2_\3';

if ($st =~ /$pattern/) {
print "\$1=$1\n\$2=$2\n\$3=$3";
}
####

執行結果:
$1=A
$2=L
$3=Z

------------------------------------------------------------------------------------------------

[[ 群組 - $1, $2, ... 的開始和結束位置 ]]

Perl 5.6.0 提供了兩個陣列 @- 和 @+,
@- 儲存了 $1, $2, ... 的開始位置,@+ 就儲存結束位置。

例:
####
my ($time_string, $hour, $minute, $second);

$time_string = '12:34:56';
$pattern = '(\d\d):(\d\d):(\d\d)';

$time_string =~ /$pattern/;

foreach my $i (1 .. $#-) {
print "Match $i='${$i}' at position ($-[$i] , $+[$i])\n";
}
####

執行結果:
Match 1='12' at position (0 , 2)
Match 2='34' at position (3 , 5)
Match 3='56' at position (6 , 8)

------------------------------------------------------------------------------------------------

[[ 群組 - $` 、 $& 和 $' ]]

如果 regexp 沒有寫括號,就沒有 $1, $2, ... 可用了,
但您仍然可以用 $& 來取得 match,$` 則取得 match 前面所有東西,
$' 取得 match 後面所有東西。


####
$st = '11AA22';
$pattern = 'AA';

$st =~ /$pattern/;

print "\$`=$`\n\$&=$&\n\$'=$'";
####

執行結果:
$`=11
$&=AA
$'=22


如果用 substr 來表示,那麼:

$` 是 substr( $st, 0, $-[0] )
$& 是 substr( $st, $-[0], $+[0] - $-[0] )
$' 是 substr( $st, $+[0] )

------------------------------------------------------------------------------------------------

[[ 重覆 (Repetition) ]]

如果想表示「五個 'A' 字元」,可以寫
$pattern = 'AAAAA';

也可以用量化詞 (Quantifier) ,寫成
$pattern = 'A{5}';

這樣就更清楚了。而量化詞可以寫在字元、字元類別或群組的後面。

例:
$st = '11AAA22AAAAA';
$pattern = 'A{5}';

------------------------------------------------------------------------------------------------

[[重覆 - 最多和最少]]

量化詞可分成兩類:
1) 最多配對(貪心的) Maximal Match (Greedy)
2) 最少配對(不貪心的) Minimal Match (Non-greedy)


以下列出「最多配對」:

A? 表示 0 個或 1 個 'A' 字元(以最多為準)
A* 表示 0 個或以上的 'A' 字元(以最多為準)
A+ 表示 1 個或以上的 'A' 字元(以最多為準)

A{n} 表示 n 個 'A' 字元
A{n,m} 表示最少 n 個,最多 m 個 'A' 字元(以最多為準)
A{n,} 表示最少 n 個 'A' 字元(以最多為準)

以下列出「最少配對」:

A?? 表示 0 個或 1 個 'A' 字元(以最少為準)
A*? 表示 0 個或以上的 'A' 字元(以最少為準)
A+? 表示 1 個或以上的 'A' 字元(以最少為準)

A{n}? 表示 n 個 'A' 字元
(這個其實沒有所謂的「最多」還是「最少」之分,
定義這個符號只是為了保持符號一致性而己)
A{n, m}? 表示最少 n 個,最多 m 個 'A' 字元(以最少為準)
A{n,}? 表示最少 n 個 'A' 字元(以最少為準)


到底「最多配對」和「最少配對」有什麼分別呢?例如

$st = 'AAAAA';
$pattern1 = 'A{3,5}'; # 最多配對
$pattern2 = 'A{3,5}?'; # 最少配對

那麼 match 可能是:
1) 'AAA'(字元位置0至2)
2) 'AAAA'(字元位置0至3)
3) 'AAAAA'(字元位置0至4)

如果是「最多配對」,那麼 match 就是 'AAAAA',因為它是最多次數,
如果是「最少配對」,那麼 match 就是 'AAA',因為它是最少次數。

------------------------------------------------------------------------------------------------

[[ 特點字元 - 任何一個字元 ]]

如果要表示「任何一個字元」,可以用點號 '.'。

在預設的情況下,它會配到「任何一個字元,除了 "\n" 之外」:

$st = "123ABC_!@\n";
$pattern = '.';

@matches = $st =~ /$pattern/g;

如果要配到「任何一個字元,包括 "\n"」,
就到加入 s 這個「修飾詞」(Modifier):

@matches = $st =~ /$pattern/sg;

s 的意思是「把字串當作單行 (Single Line)」。

------------------------------------------------------------------------------------------------

[[ 字串的開頭 ]]

如果要表示「字串的開頭」,可以用 '^',例如:

$st = 'AA22';
$pattern = '^AA';

@matches = $st =~ /$pattern/g;


執行結果:
0 : AA


但 match 當中不會有 '^' 所配出來的字元,
因為 '^' 主要用來測試字串的特性(例如字串位置),
而不是配任何字元的。

為了方便理解,您可以把它「想像」成一個看得見的字元,
例如:

$st = '頭AA22尾'; ## $st = 'AA22'
$pattern = '頭AA'; ## $pattern = '^AA';

------------------------------------------------------------------------------------------------

[[ 字串的結尾 ]]

如果要表示「字串的結尾,或者在字串最尾的 \n 和前面字元的中間」,
可以用 '$',例如:

$st = "AA\nBB\n"; ## 用了雙引號
$pattern = '$';

@matches = $st =~ /$pattern/g;

結果有兩個 match ,但是'$' 與 '^' 一樣,是不會配到字元的。
您可以把它想像成:

$st = "頭AA\nBB尾\n尾"; ## $st = "AA\nBB\n";
$pattern = '尾'; ## $pattern = '$';

另外,當檢查一個字串是否符合某種格式時,
通常會 '^' 和 '$' 一起用,
例如檢查某字串是否符合「三位數字」的格式:

####
$st = "123";
$pattern = '^\d{3}$';

if ($st =~ /$pattern/) {
print "Valid format";
} else {
print "Invalid format";
}
####

------------------------------------------------------------------------------------------------

[[ 多行 (Multi-line) ]]

一個字串內可以含有 \n,例如:

$st = "AA\nAA\nAA\n";
$pattern = '^AA';

如果我們想 '^' 配到每一行的開頭,
可以用 m 修飾詞:

@matches = $st =~ /$pattern/mg;

執行結果:
0 : AA
1 : AA
2 : AA


想像成:

$st = "頭AA尾\n頭AA尾\n頭AA尾\n尾";
$pattern = '頭AA';


用了 m 修飾詞,也會令 '$' 配到每一行的結尾,


$st = "AA\nAA\nAA\n";
$pattern = 'AA$';
@matches = $st =~ /$pattern/mg;


想像成:

$st = "頭AA尾\n頭AA尾\n頭AA尾\n尾";
$pattern = 'AA尾';

如果用了 m 修飾詞,您仍然可以用:

\A 表示沒有 m 修飾詞的 '^' 意思
\Z 表示沒有 m 修飾詞的 '$' 意思
\z 代表字串的結尾(即 \Z ,但不包括最尾 \n 和前面字元的中間)


$st = "AA\nAA\nAA\n";
$pattern1 = '\AAA';
$pattern2 = 'AA\Z';
$pattern3 = 'AA\z';


總括來說,s 修飾詞會影響 '.' 的意思,
m 修飾詞會影響 '^' 和 '$' 的意思,
s 和 m 總共有四種可能:

沒有 s 和 m :預設模式 (Default Mode)
/s :單行模式 (Single Line Mode)
/m :多行模式 (Multi-Line Mode)
/sm :清楚多行模式 (Clean Multi-Line Mode)


看看大家能否解釋以下程式的執行結果:

####
$st = "A\nA\nA\n";
$pattern = '(^|$|.)';

@matches = $st =~ /$pattern/smg;
####

------------------------------------------------------------------------------------------------

[[ 字的邊界 Word Boundary ]]

字的邊界是指兩個連續字元的中間,
一個會配到 \w,而另一個會配到 \W。
(字串的開頭和結尾也視為配到 \W)

例如:

$st = 'ABC-=+';
$pattern = 'C\b';

@matches = $st =~ /$pattern/g;

因為左邊的 'C' 會配到 \w,而右邊的 '-' 會配到 \W,
所以 \b 會配到它們的中間。

\b 不代表某個字元,而是代表某個位置的特性。
您可以想像成:

$st = '界ABC界-=+';
$pattern = 'C界';

您可以用 \B 來表示 \b 的相反,即「不是邊界」,

例如:

$st = 'ABCDE';
$pattern = '\BC\B';

@matches = $st =~ /$pattern/g;

因為 'C' 本身配到 \w ,而它左邊的'B'和右邊的'D'也是配到 \w,
所以沒有邊界。

------------------------------------------------------------------------------------------------

[[ 不分大小寫 (Case-insensitive) ]]

如果加入了 i 修飾詞,就會做不分大小寫的配對,
例如:

$st = '11AA22BB';
$pattern = '[abAB]';

@matches = $st =~ /$pattern/g;

可以用 i 修飾詞寫成:

$st = '11AA22BB';
$pattern = '[AB]'; # 或者 '[ab]'

@matches = $st =~ /$pattern/ig;

因為不分大小寫,所以不必在 $pattern 把大小寫都列出來了。

------------------------------------------------------------------------------------------------

[[ x 修飾詞 ]]

如果用了 x 修飾詞,就會令 regexp 解譯器忽略 $pattern 內的白格,
(除了那些在被反斜號標示了的白格,及那些在字元類別內的白格)
還有在 $pattern 內的 '#' 也會有好像 Perl 一樣的單行註解作用,
(除了那些在被反斜號標示了的'#',及那些在字元類別內的'#')

它的用途是讓您可以把 regexp 寫成容易閱讀的方式,及加入註解。
例子:


不用 x 修飾詞的寫法:

$st = '11AA22 33\\\\44##';
$pattern = '(A| |\\\\|#)';
@matches = $st =~ /$pattern/g;


用了 x 修飾詞的寫法:

$st = '11AA22 33\\\\44##';

$pattern = q{

( # 左括號表示 Alternation 開始
A # 'A' 字元
| # 或者
[ ] # 用字元類別表示空格
| # 或者
\\\\ # 反斜號字元
|
[#] # 用字元類別表示'#'
) # 右括號表示完結

};

@matches = $st =~ /$pattern/xg;

------------------------------------------------------------------------------------------------

[[ 伸展模式 (Extended Patterns) ]]

除了傳統的 regexp 語法外,Perl 還定義了一些額外的語法,
但在其它工具未必有這些語法,而且有些語法可能還在實驗階段,
說不定將來會被刪除,詳情請參閱說明文件。

這些語法都是這樣子的:

(?char)

而 char 就表示伸展的種類。

------------------------------------------------------------------------------------------------

[[ 伸展模式 - 內嵌註解 (Embedding Comments) ]]

語法:
(?#text)

在 text 位置的東西會當作註解,
但要留意 text 內不可以含有右括號。

例:
$pattern = '(?# THIS IS A COMMENT)(A| |\\\\|#)';

------------------------------------------------------------------------------------------------

[[ 伸展模式 - 非捕捉群組 (Non-capturing groupings) ]]

語法:
(?:pattern)

之前提到括號有個特別的作用,就是會把配到的東西放進 $1, $2,...,
例如:

$time_string = '12:34:56';
$pattern = '(\d\d):(\d\d):(\d\d)';

if ($time_string =~ /$pattern/) {
($hour, $minute, $second) = ($1, $2, $3);
print "hour=$hour,minute=$minute,second=$second";
}

但如果您不想放的話,可以用 (?:pattern):

$time_string = '12:34:56';
$pattern = '(\d\d):(?:\d\d):(\d\d)';

if ($time_string =~ /$pattern/) {
($hour, $minute, $second) = ($1, $2, $3);
print "hour=$hour,minute=$minute,second=$second";
}


因為「分」那部份使用了(?:pattern) ,所以就不會放到本來的 $2,
這就輪到「秒」的部份放到 $2了。

------------------------------------------------------------------------------------------------

[[ 伸展模式 - 內嵌修飾詞 (Embedded Modifiers) ]]

語法:
(?imsx-imsx:pattern)

之前提到可以用 i 修飾詞來做不分大小寫的配對,例如:

$st = '11AB22Ab33aB44ab';
$pattern = 'AB';

@matches = $st =~ /$pattern/ig;

這樣整個 $pattern 都是不分大小寫了,
如果想某部份分辨大小寫,某部份不分辨,
可以用內嵌的寫法。

$st = '11AB22Ab33aB44ab';
$pattern = '(?i:A)(?-i:B)';

@matches = $st =~ /$pattern/g;

表示 A 不分大小寫,B 就分辨大小寫。
如果修飾詞前面是減號,表示關閉該修飾詞,
例如 (?s-i),表示啟動 s 修飾詞,關閉 i 修飾詞。

其實內嵌修飾詞的語法,是在非捕捉群組內加入修飾詞而己。

------------------------------------------------------------------------------------------------

[[ 伸展模式 - 往前看(Look-ahead)和往後看(Look-behind) ]]

語法:
往前看(正)(Positive Look-ahead) (?=pattern)
往後看(正)(Positive Look-behind) (?<=pattern)
往前看(負)(Negative Look-ahead) (?!pattern)
往後看(負)(Negative Look-behind) (?
舉例來說:

$st = 'ABCDEFGH';
$pattern = '\w{2}';
@matches = $st =~ /$pattern/g;


執行結果:
0 : AB
1 : CD
2 : EF
3 : GH

您可以想像它是由左往右走,當配到一個match,
下一次就由match之後開始走:

ABCDEFGH
由A的位置開始走,配到 AB,剩下 CDEFGH ('AB')
由C的位置開始走,配到 CD,剩下 EFGH ('AB', 'CD')
由E的位置開始走,配到 EF,剩下 GH ('AB', 'CD', 'EF')
由G的位置開始走,配到 GH,剩下 ('AB', 'CD', 'EF', 'GH')


如果想在走路的時候,還要同時往前面看,
可以用「往前看」或「往後看」。
例如仍然要找出 \w{2},但同時要檢查它的前面(即右面)必須是\w{2},
可以寫:

$pattern = '\w{2}(?=\w{2})';

執行結果:
0 : AB
1 : CD
2 : EF


這裡的 (?=\w{2}) 用了「往前看(正)」,
這部份是不會配到任何字元,只是用來檢查字串的特性:

ABCDEFGH
由A的位置開始,配到AB,往前看到CD,剩下 CDEFGH ('AB')
由C的位置開始,配到CD,往前看到EF,剩下 EFGH ('AB', 'CD')
由E的位置開始,配到EF,往前看到GH,剩下 GH ('AB', 'CD', 'EF')
由G的位置開始,雖然GH 可以配到\w{2} ,但往前看不到 \w{2},所以沒有match
完結

同理,如果改用「往後看」:

$pattern = '(?<=\w{2})\w{2}';

執行結果:
0 : CD
1 : EF
2 : GH

ABCDEFGH
由A的位置開始,直至走到C的位置時,
才能夠往後看到 AB,配到CD,剩下 EFGH ('CD')
由E的位置開始,往後看到CD,配到EF,剩下 GH ('CD', 'EF')
由G的位置開始,往後看到EF,配到GH,剩下 ('CD', 'EF', 'GH')
完結


Negative Look-ahead 是 Positve Look-ahead的相反,
例如仍然要找出 \w{2},但同時要檢查它的前面必須「不是」\w{2},
可以寫:

$st = 'ABCDEFGH';
$pattern = '\w{2}(?!\w{2})';
@matches = $st =~ /$pattern/g;


執行結果:
0 : FG

因為 'FG'的右面只有 'H' ,即 \w ,而不是 \w{2},
所以配到。

沒有留言:

張貼留言