Regex 正規表示法 - 量詞與替代 (Quantifiers & Alternation)
量詞 (quantifier) 表示某個條件需要出現的次數。
Plus +
+ 表示連續出現 1 次或多次。
例子：
pattern ab+c 可以用來匹配 "abc", "abbc", "abbbc", "abbbbbbc" 等字串，但 "ac", "adc" 不符合。
JavaScript 使用範例
var match = /a+/.exec('caaaaaaandy');
console.log(match[0]); // aaaaaaa
Python 使用範例
import re
match = re.search(r'a+', 'caaaaaaandy')
print(match.group()) # aaaaaaa
PHP 使用範例
preg_match('/a+/', 'caaaaaaandy', $match);
echo $match[0]; // aaaaaaa
Ruby 使用範例
match = 'caaaaaaandy'.match(/a+/)
puts match[0] # aaaaaaa
Star *
* 表示連續出現 0 次或多次。
例子：
pattern ab*c 可以用來匹配 "ac", "abc", "abbc", "abbbc", "abbbbbbc" 等字串，但 "adc", "a123" 不符合。
JavaScript 使用範例
var match = /bo*/.exec('A ghost booooed');
console.log(match[0]); // boooo
Python 使用範例
import re
match = re.search(r'bo*', 'A ghost booooed')
print(match.group()) # boooo
PHP 使用範例
preg_match('/bo*/', 'A ghost booooed', $match);
echo $match[0]; // boooo
Ruby 使用範例
match = 'A ghost booooed'.match(/bo*/)
puts match[0] # boooo
Quantifier {min,max} {n} {min,}
Quantifier 有三種寫法：
{min,max}表示至少連續出現 min 次，但最多連續出現 max 次。{n}表示要出現 n 次。{min,}表示至少連續出現 min 次。
例子：
pattern ab{1,3}c 可以用來匹配 "abc", "abbc", "abbbc" 等字串，但 "ac", "abbbbbbc", "adc", "a123" 不符合。
pattern ab{3}c 可以用來匹配 "abbbc" 等字串，但 "ac", "abc", "abbc", "abbbbbbc", "adc", "a123" 不符合。
pattern ab{3,}c 可以用來匹配 "abbbc", "abbbbbbc" 等字串，但 "abc", "abbc", "ac", "adc", "a123" 不符合。
JavaScript 使用範例
var match = /a{1,3}/.exec('caaaaaaandy');
console.log(match[0]); // aaa
Python 使用範例
import re
match = re.search(r'a{1,3}', 'caaaaaaandy')
print(match.group()) # aaa
PHP 使用範例
preg_match('/a{1,3}/', 'caaaaaaandy', $match);
echo $match[0]; // aaa
Ruby 使用範例
match = 'caaaaaaandy'.match(/a{1,3}/)
puts match[0] # aaa
Optional ?
? 表示出現 0 次或 1 次。
例子：
pattern ab?c 可以用來匹配 "ac", "abc" 等字串，但 "abbc", "abbbc", "abbbbbbc", "adc", "a123" 不符合。
JavaScript 使用範例
var match = /e?le?/.exec('angel');
console.log(match[0]); // el
Python 使用範例
import re
match = re.search(r'e?le?', 'angel')
print(match.group()) # el
PHP 使用範例
preg_match('/e?le?/', 'angel', $match);
echo $match[0]; // el
Ruby 使用範例
match = 'angel'.match(/e?le?/)
puts match[0] # el
Lazy ?
對於指定的量詞，Regex 的匹配引擎在預設上，採能匹配越多字就盡量匹配，這一個特性叫做 greedy (貪婪)。
例如，用 pattern (.+)(\d+) 來匹配字串 "abcd1234"，group 1 會得到 "abcd123"，group 2 會得到 "4"，正是因為 greedy 的特性讓 .+ 匹配到盡可能多的字。
? 還有另外一個用法，接在量詞後面 (+?, *?, {min,max}?, ??) 表示 lazy (非貪婪, 懶惰) 模式，會使 Regex 的匹配引擎變成以匹配越少字為原則，盡可能匹配短結果。
例如，用 pattern (.+?)(\d+) 來匹配字串 "abcd1234"，group 1 會得到 "abcd"，group 2 會得到 "1234"，正是因為 lazy 的特性讓 .+ 匹配到盡可能少的字。
JavaScript 使用範例
var match = /<.+?>/.exec('<em>Hello World</em>');
console.log(match[0]); // <em>
Python 使用範例
import re
match = re.search(r'<.+?>', '<em>Hello World</em>')
print(match.group()) # <em>
PHP 使用範例
preg_match('/<.+?>/', '<em>Hello World</em>', $match);
echo $match[0]; // <em>
Ruby 使用範例
match = '<em>Hello World</em>'.match(/<.+?>/)
puts match[0] # <em>
Alternation |
| 語法用來表示替代的意思，有點像是 boolean OR (或)，當你有多個可能的選擇性時，可以用 | 來分隔開多個選擇。
例子：
pattern b(a|e|i)d 表示 b 和 d 之間可能會出現 a, e 或 i 字元，可以用來匹配 "bad", "bed", "bid" 等字串，但 "bd", "bbd", "b123", "bzd" 不符合。
JavaScript 使用範例
var match = /green|red/.exec('green apple');
console.log(match[0]); // green
Python 使用範例
import re
match = re.search(r'green|red', 'green apple')
print(match.group()) # green
PHP 使用範例
preg_match('/green|red/', 'green apple', $match);
echo $match[0]; // green
Ruby 使用範例
match = 'green apple'.match(/green|red/)
puts match[0] # green