Regular Expression （正規錶示式 簡寫 regexp或regex）是一個字串 Regular Expression 新手入門 - 趣味新聞網

發表日期 2008-05-14T01:00:25+08:00

     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 ";
} else {
print "no match ";
}


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

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

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


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

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

print "$st ";


##
## 在 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 );
}
//
// 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] ";
}
####

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

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

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

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

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

例：
$st = "11 22 33";
$pattern = ' ';

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

[[ 字元類彆 (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 等於寫 [ f] ，即白格字元 (Whitespace character)，
包括space, tab, newline, carriage return, form feed

S 等於寫 [^ 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 = '(dd):(dd):(dd)';

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。

(dd):(dd):(dd)
1______2______3

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

[[群組 - 巢狀群組]]

括號內也可以有括號，成為巢狀群組，例如：

(dd):((dd):(dd))
1______23______4

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

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

if ($time_string =~ /$pattern/) {
print "$1=$1 $2=$2 $3=$3 $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 $2=$2 $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 = '(dd):(dd):(dd)';

$time_string =~ /$pattern/;

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

執行結果：
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 "$`=$` $&=$& $'=$'";
####

執行結果：
$`=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'，因為它是最少次數。

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

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

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

在預設的情況下，它會配到「任何一個字元，除瞭 " " 之外」：

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

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

如果要配到「任何一個字元，包括 " "」，
就到加入 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';

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

[[ 字串的結尾 ]]

如果要錶示「字串的結尾，或者在字串最尾的 和前麵字元的中間」，
可以用 '$'，例如：

$st = "AA BB "; ## 用瞭雙引號
$pattern = '$';

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

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

$st = "頭AA BB尾 尾"; ## $st = "AA BB ";
$pattern = '尾'; ## $pattern = '$';

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

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

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

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

[[ 多行 (Multi-line) ]]

一個字串內可以含有 ，例如：

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

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

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

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


想像成：

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


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


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


想像成：

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

如果用瞭 m 修飾詞，您仍然可以用：

A 錶示沒有 m 修飾詞的 '^' 意思
 錶示沒有 m 修飾詞的 '$' 意思
z 代錶字串的結尾（即  ，但不包括最尾 和前麵字元的中間）


$st = "AA AA AA ";
$pattern1 = 'AAA';
$pattern2 = 'AA';
$pattern3 = 'AAz';


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

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


看看大傢能否解釋以下程式的執行結果：

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

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

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

[[ 字的邊界 Word Boundary ]]

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

例如：

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

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

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

 不代錶某個字元，而是代錶某個位置的特性。
您可以想像成：

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

您可以用 B 來錶示  的相反，即「不是邊界」，

例如：

$st = 'ABCDE';
$pattern = 'BCB';

@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 = '(dd):(dd):(dd)';

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

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

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

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}，
所以配到。

分享鏈接