深入探索 Ruby 正则表达式：强大的文本模式匹配工具

在处理文本数据时，无论是查找、替换、验证还是提取特定信息，正则表达式（Regular Expression，简称 Regex 或 Regexp）都是一个极其强大且灵活的工具。对于 Ruby 开发者来说，正则表达式是语言核心的一部分，与字符串操作紧密集成，使得处理复杂的文本任务变得高效而优雅。

本文将带你深入了解 Ruby 中的正则表达式，从基础概念到高级特性，帮助你掌握这一强大的文本处理利器。

什么是正则表达式？为什么使用它？

简单来说，正则表达式是一种描述文本模式的迷你语言。它使用一系列特殊字符和语法来定义一个搜索模式，然后可以在字符串中查找与该模式匹配的部分。

想象一下，你需要从一个长文本中找出所有有效的电子邮件地址，或者替换所有链接中的域名，或者验证用户输入的手机号码格式是否正确。如果使用传统的字符串方法（如 include?, start_with?, sub 配合固定字符串），这些任务会变得异常繁琐，甚至无法实现。正则表达式正是为了解决这类问题而生。

使用正则表达式的优点：

灵活性和强大性： 可以描述任意复杂的文本模式。
效率： 许多正则表达式引擎经过高度优化，匹配速度很快（尽管复杂模式可能导致性能问题）。
简洁性： 复杂的匹配逻辑可以用一行正则表达式表达。
通用性： 正则表达式的概念和大部分语法在不同编程语言和工具中是通用的。

Ruby 对正则表达式提供了原生且强大的支持，通过内置的 Regexp 类以及字符串类的各种方法，使得在 Ruby 中使用正则表达式变得非常方便。

Ruby 中的正则表达式基础

在 Ruby 中，创建正则表达式对象有几种方式：

正则表达式字面量（Literal）： 这是最常见的方式，使用斜杠 /pattern/ 包围模式。
ruby /hello/ # 匹配字符串 "hello" /[0-9]+/ # 匹配一个或多个数字
字面量形式是推荐的方式，因为它更简洁，并且 Ruby 会在编译时解析它。
%r{pattern} 语法： 类似于 %w 和 %q，可以使用任意分隔符，这在模式本身包含斜杠时非常有用，避免了反斜杠转义的麻烦。
ruby %r{/usr/local/bin} # 匹配路径，无需转义斜杠 %r!http://example.com! # 也可以使用感叹号等其他字符
Regexp.new(pattern, options, encoding) 方法： 用于动态构建正则表达式，或者需要传递选项时。
ruby pattern = "dynamic" regexp = Regexp.new(pattern) # => /dynamic/ case_insensitive_regexp = Regexp.new("hello", Regexp::IGNORECASE) # => /hello/i
通常情况下，字面量足以满足需求，只有在模式字符串是变量或需要动态构建时才考虑 Regexp.new。

Ruby 中使用正则表达式进行匹配操作

一旦有了正则表达式对象，就可以在字符串上执行各种匹配操作。Ruby 的 String 类提供了多个方法来与 Regexp 对象协同工作：

=~ 操作符： 这是最基本的匹配操作符。
ruby "hello world" =~ /world/ # => 6 (匹配到的起始索引) "hello world" =~ /ruby/ # => nil (未匹配到)
如果匹配成功，=~ 返回匹配到的起始索引；如果匹配失败，则返回 nil。这是一个快速检查字符串是否包含某个模式的方法。匹配成功时，Ruby 会设置一些特殊的全局变量（如 $, $&, $1, $2 等），用于访问匹配结果和捕获的分组，但这在现代 Ruby 代码中不推荐过度依赖，因为它们会污染全局命名空间且影响性能，使用 match 方法更佳。
match 方法： 这是获取匹配结果的推荐方式。
“`ruby
match_data = “hello world”.match(/world/)
puts match_data # => #
puts match_data[0] # => “world” (整个匹配到的部分)
puts match_data.begin(0) # => 6 (匹配到的起始索引)
puts match_data.end(0) # => 11 (匹配到的结束索引 + 1)

match_data = “hello world”.match(/ruby/)
puts match_data.nil? # => true
``match方法返回一个MatchData对象（如果匹配成功）或nil（如果匹配失败）。MatchData` 对象提供了丰富的接口来访问匹配到的字符串、捕获的分组、索引等信息。
match? 方法： 在 Ruby 2.4 引入，用于只检查模式是否存在，不返回 MatchData 对象。
ruby "hello world".match?(/world/) # => true "hello world".match?(/ruby/) # => false
如果只需要知道是否匹配成功，使用 match? 比 match 更高效，因为它避免了创建 MatchData 对象的开销。
String#[] 方法： 字符串的索引操作也可以接受正则表达式。
ruby "hello world"[/world/] # => "world" (返回匹配到的字符串) "hello world"[/ruby/] # => nil
如果正则表达式包含捕获分组，[] 方法可以用来直接获取捕获的内容：
ruby "hello 123 world"[/[0-9]+/] # => "123" "hello 123 world"[/(h.*?o)\s(\d+)/, 1] # => "hello" (获取第一个捕获分组) "hello 123 world"[/(h.*?o)\s(\d+)/, 2] # => "123" (获取第二个捕获分组) "hello 123 world"[/(h.*?o)\s(\d+)/] # => #<MatchData "hello 123" 1:"hello" 2:"123"> (返回 MatchData 对象)

正则表达式的构建块 (Pattern Building Blocks)

正则表达式的强大之处在于其由各种特殊字符和结构组成的模式。下面我们将介绍构成正则表达式模式的基本元素：

1. 字面量字符 (Literal Characters)

大多数字符在正则表达式中代表它们自身。例如，/abc/ 匹配字符串 “abc”。

2. 元字符 (Metacharacters)

一些字符在正则表达式中具有特殊含义，它们是元字符。常见的元字符包括：. ^ $ * + ? { } ( ) [ ] \ |。如果想匹配这些元字符本身，需要使用反斜杠 \ 进行转义，例如 /\./ 匹配字符 .。

3. 字符类 (Character Classes) `[]`

方括号 [] 定义一个字符集合，匹配方括号中的任意一个字符。
* [aeiou]：匹配任何一个元音字母。
* [0-9]：匹配任何一个数字（等同于 \d）。
* [a-z]：匹配任何一个小写字母。
* [A-Z]：匹配任何一个大写字母。
* [a-zA-Z0-9_]：匹配任何一个字母、数字或下划线（等同于 \w）。

在 [] 内部，一些元字符会失去特殊含义（例如 .，*，+ 等），但 - 用于表示范围，^ 用于否定，\ 用于转义。

否定字符类 [^...]： 如果 ^ 是方括号内的第一个字符，则表示匹配不在这个集合中的任意字符。
- [^0-9]：匹配任何一个非数字字符（等同于 \D）。
- [^aeiou]：匹配任何一个非元音字符。

4. 预定义字符类 (Predefined Character Classes)

为了方便，正则表达式提供了一些预定义的字符类，它们是常用字符类的简写：
* \d：匹配任意一个数字（[0-9]）
* \D：匹配任意一个非数字字符（[^0-9]）
* \w：匹配任意一个“字”字符（字母、数字、下划线，即 [a-zA-Z0-9_]）
* \W：匹配任意一个非“字”字符（[^a-zA-Z0-9_]）
* \s：匹配任意一个空白字符（空格、制表符 \t、换行符 \n、回车符 \r、换页符 \f 等）
* \S：匹配任意一个非空白字符
* \h：匹配任意一个十六进制数字字符 ([0-9a-fA-F]) – Ruby 特有或更常见于 Ruby
* \H：匹配任意一个非十六进制数字字符 ([^0-9a-fA-F]) – Ruby 特有或更常见于 Ruby
* .：匹配除了换行符 \n 之外的任意一个字符。如果启用多行模式（m 选项），. 也会匹配换行符。

5. POSIX 字符类

Ruby 也支持 POSIX 风格的字符类，它们写在双层方括号内，并以冒号包围，例如 [:digit:]，并且必须用在外层方括号内：
* [[:digit:]]：等同于 \d 或 [0-9]
* [[:alpha:]]：匹配字母（[a-zA-Z]）
* [[:alnum:]]：匹配字母或数字（[a-zA-Z0-9]）
* [[:space:]]：等同于 \s
* [[:upper:]]：匹配大写字母
* [[:lower:]]：匹配小写字母
* [[:punct:]]：匹配标点符号
* [[:graph:]]：匹配可打印的、非空格字符
* [[:print:]]：匹配可打印字符（包括空格）
* [[:cntrl:]]：匹配控制字符
* [[:xdigit:]]：等同于 \h

例如，匹配一个或多个数字：/[[:digit:]]+/。

6. 量词 (Quantifiers)

量词用来指定其前面的元素（字符、字符类、分组等）应该重复出现的次数。
* ?：0 次或 1 次（可选的）
* *：0 次或多次
* +：1 次或多次
* {n}：正好 n 次
* {n,}：至少 n 次
* {n,m}：至少 n 次，但不超过 m 次

示例：
* /a?/：匹配 “a” 或者什么都不匹配。
* /a*/：匹配空字符串，”a”，”aa”，”aaa” 等。
* /a+/：匹配 “a”，”aa”，”aaa” 等，但不匹配空字符串。
* /\d{3}/：匹配正好 3 个数字，如 “123”。
* /\d{3,}/：匹配 3 个或更多个数字，如 “123”，”1234″。
* /\d{3,5}/：匹配 3 到 5 个数字，如 “123”，”1234″，”12345″。

贪婪与惰性匹配 (Greedy vs. Lazy Quantifiers):
默认情况下，量词是“贪婪的”（Greedy），它们会尽可能多地匹配字符。这有时会导致意想不到的结果。
例如，对于字符串 "bolditalic"，使用模式 /.*<\/b>/ 匹配  标签：
ruby "bolditalic".match(/.*<\/b>/) # => #<MatchData "bolditalic">
由于 .* 是贪婪的，它会一直匹配到最后一个  出现的位置。

为了解决这个问题，可以在量词后面加上 ? 使其变为“惰性的”（Lazy）或“非贪婪的”，它们会尽可能少地匹配字符。
* ??：0 次或 1 次，优先匹配 0 次
* *?：0 次或多次，优先匹配 0 次
* +?：1 次或多次，优先匹配 1 次
* {n,}?：至少 n 次，优先匹配 n 次
* {n,m}?：至少 n 次，但不超过 m 次，优先匹配 n 次

使用惰性量词修改上面的例子：
ruby "bolditalic".match(/.*?<\/b>/) # => #<MatchData "bold">
现在 .*? 只匹配到第一个  出现的位置。理解贪婪与惰性对于编写正确的正则表达式至关重要。

7. 定位符/锚点 (Anchors)

定位符不匹配实际字符，而是匹配字符串中的特定位置。
* ^：匹配行的开头。
* $：匹配行的结尾。
* \A：匹配整个字符串的开头。
* \Z：匹配整个字符串的结尾，但在最后一个换行符之前（如果有的话）。
* \z：匹配整个字符串的绝对结尾。
* \b：匹配单词边界。单词边界是指 \w 字符和 \W 字符之间的位置，或者 \w 字符和字符串开头/结尾之间的位置。
* \B：匹配非单词边界。

^ 和 $ 与 \A 和 \z 的区别：
默认情况下，^ 和 $ 匹配整个字符串的开头和结尾。但是，如果正则表达式使用了多行模式（m 选项，或在模式中包含 (?m)），^ 和 $ 就会匹配每一行的开头和结尾（即换行符 \n 之后和之前）。\A 和 \z 则始终匹配整个字符串的开始和结束，不受多行模式影响。\Z 是一个稍微特殊的锚点，很少使用，通常用 \z 替代。

\b 和 \B 的示例：
ruby "cat and dog".scan(/\bcat\b/) # => ["cat"] (匹配一个独立的单词 "cat") "category".scan(/\bcat\b/) # => [] ("cat" 不是一个独立的单词) "categorization".scan(/cat\B/) # => ["cat"] ("cat" 后面跟着一个单词字符 'e', 是非单词边界) "cat".scan(/cat\b/) # => ["cat"] ("cat" 后面是字符串结尾, 是单词边界)

8. 分组与捕获 (Grouping and Capturing) `()`

圆括号 () 用于创建分组。分组有双重作用：
1. 结构化模式： 将多个元素组合成一个逻辑单元，可以对整个分组应用量词或进行其他操作。例如，/(ab)+/ 匹配一个或多个连续的 “ab”。
2. 捕获匹配内容： 默认情况下，每个分组会“捕获”它所匹配到的字符串。这些捕获的内容可以通过 MatchData 对象或全局变量访问。

捕获分组的访问：
使用 match 方法后，返回的 MatchData 对象提供了访问捕获内容的便捷方式：
“`ruby
match_data = “My email is [email protected]”.match(/(\w+)@(\w+.\w+)/)
puts match_data[0] # => “[email protected]” (整个匹配到的部分)
puts match_data[1] # => “test” (第一个捕获分组)
puts match_data[2] # => “example.com” (第二个捕获分组)
puts match_data[:username] if match_data # 使用命名捕获时访问

也可以通过 MatchData 对象的 captures 方法获取所有捕获分组的数组

puts match_data.captures # => [“test”, “example.com”]
`` 不推荐使用全局变量$1,$2,$3, ...$,$&, $, $'，它们虽然方便但在复杂代码中容易出错。$& 对应 match_data[0]，$' 对应匹配内容之前的字符串，$' 对应匹配内容之后的字符串。

非捕获分组 (?:...)：
如果你只需要使用分组来结构化模式，而不需要捕获其内容，可以使用非捕获分组 (?:...)。这可以提高性能，因为引擎不需要存储这些匹配结果。
“`ruby
“color colour”.scan(/col(?:ou?)r/) # => [“color”, “colour”]

这里 (?:ou?) 只是为了让 ? 量词应用于 ou 整体，但 ou 或 u 本身不被捕获。

“`

9. 选择符/或 (Alternation) `|`

Ruby 中的替换和分割操作

除了匹配，正则表达式在 Ruby 中也常用于字符串的替换和分割。

String#sub 和 String#gsub： 用于替换匹配到的模式。
- sub(pattern, replacement)：替换第一次匹配到的部分。
- gsub(pattern, replacement)：替换所有匹配到的部分（global substitution）。
- 对应的破坏性方法 sub! 和 gsub! 会修改原字符串。
replacement 可以是字符串，也可以是块（Block）。在字符串替换中，可以使用反向引用（Backreferences）来引用捕获的分组。
* \1, \2, …：引用第 1, 2, … 个捕获分组。
* \& 或 \0: 引用整个匹配到的部分。
* \``: 引用匹配之前的字符串。 *\’`: 引用匹配之后的字符串。

示例：
“`ruby
“hello world”.sub(/world/, “ruby”) # => “hello ruby”
“a 1 b 2 c 3”.gsub(/\d+/, “-“) # => “a – b – c -“

使用捕获分组和反向引用

“First Last”.gsub(/(\w+)\s(\w+)/, “\2, \1”) # => “Last, First” (注意 Ruby 字符串中 \ 需要转义)

使用块进行替换

“items: 1, 2, 3”.gsub(/\d+/) { |match| match.to_i * 10 } # => “items: 10, 20, 30”
“`
使用块进行替换非常灵活，可以在块中进行任意计算来决定替换后的内容。
String#scan： 用于查找字符串中所有与模式匹配的部分，返回一个数组。
ruby "a1b2c3d4e5".scan(/\d/) # => ["1", "2", "3", "4", "5"] "a1b2c3d4e5".scan(/[a-z]\d/) # => ["a1", "b2", "c3", "d4", "e5"]
如果正则表达式包含捕获分组，scan 会返回一个数组的数组，每个子数组包含一次匹配中所有捕获的分组。
ruby "Name: Alice, Age: 30; Name: Bob, Age: 25".scan(/Name: (\w+), Age: (\d+)/) # => [["Alice", "30"], ["Bob", "25"]]
String#split： 使用正则表达式作为分隔符来分割字符串。
ruby "a,b,c".split(/,/) # => ["a", "b", "c"] "word1\nword2\r\nword3".split(/\s+/) # => ["word1", "word2", "word3"] (按一个或多个空白符分割)
如果正则表达式包含捕获分组，分割结果会包含捕获到的分隔符。
ruby "a(1)b(2)c".split(/([()])/)) # => ["a", "(", "1", ")", "b", "(", "2", ")", "c"]

高级正则表达式特性

掌握了基础构建块后，可以探索一些更高级的特性。

1. 反向引用 (Backreferences) in Patterns

前面提到了在替换字符串中使用反向引用。反向引用也可以用在正则表达式模式内部，用来引用前面捕获分组匹配到的内容。
* \1, \2, …：引用第 1, 2, … 个捕获分组匹配到的文本。

示例： 查找重复的单词。
“`ruby
“hello hello world world”.scan(/\b(\w+)\s+\1\b/) # => [[“hello”], [“world”]]

(\w+) 捕获一个单词

\s+ 匹配一个或多个空白符

\1 匹配与第一个捕获分组 (\w+) 完全相同的文本

\b 确保后面是单词边界

“`

2. 零宽断言 (Zero-width Assertions / Lookarounds)

零宽断言匹配一个位置，就像 ^, $ 或 \b 一样，它们不消耗字符，但会根据该位置前面或后面的文本来判断是否匹配。这使得你可以根据上下文进行匹配，而无需将上下文包含在最终的匹配结果中。
* 肯定先行断言 (Positive Lookahead) (?=...)： 匹配后面紧跟着 ... 模式的位置。
ruby "apple pie".scan(/apple(?=\spie)/) # => ["apple"] (匹配 "apple"，但只在后面跟着 " pie" 的情况下) "apple cider".scan(/apple(?=\spie)/) # => []
* 否定先行断言 (Negative Lookahead) (?!...)： 匹配后面没有紧跟着 ... 模式的位置。
ruby "apple cider".scan(/apple(?!\spie)/) # => ["apple"] (匹配 "apple"，但只在后面没有跟着 " pie" 的情况下) "apple pie".scan(/apple(?!\spie)/) # => []
* 肯定后行断言 (Positive Lookbehind) (?<=...)： 匹配前面紧跟着 ... 模式的位置。（注意：大部分 regex 引擎要求 ... 模式具有固定长度，但 Ruby 的 Onigmo 引擎通常支持可变长度，尽管会更慢）。
ruby "$100".scan(/(?<=\$)\d+/) # => ["100"] (匹配数字，但只在前面跟着 "$" 符号的情况下) "€50".scan(/(?<=\$)\d+/) # => []
* 否定后行断言 (Negative Lookbehind) (?<!...)： 匹配前面没有紧跟着 ... 模式的位置。
ruby "Item-A".scan(/(?<!-)\w+/) # => ["Item", "A"] (匹配单词，但不匹配前面跟着 "-" 的位置，所以 "Item-A" 分开匹配) "ItemA".scan(/(?<!-)\w+/) # => ["ItemA"]
零宽断言非常强大，但有时也难以理解和调试。

3. 原子分组 (Atomic Grouping) `(?>...)`

原子分组是另一种非捕获分组，但它有一个重要特性：一旦原子分组匹配成功，它会“锁定”所匹配的文本，并且不再回溯（backtrack）。这主要用于防止“灾难性回溯”（Catastrophic Backtracking）和优化性能，但在某些情况下也会改变匹配结果。这是一个相对高级和专门的特性。

4. 命名捕获 (Named Captures) `(?<name>...)`

在 Ruby 1.9 之后引入了命名捕获，它允许你为捕获分组指定一个名字，而不是仅仅使用数字索引。这使得代码更具可读性，并且更容易访问捕获的内容。
ruby match_data = "Email: [email protected]".match(/Email: (?<username>\w+)@(?<domain>\w+\.\w+)/) puts match_data[:username] # => "test" puts match_data[:domain] # => "example.com" puts match_data["username"] # 也可以使用字符串键
命名捕获可以通过 MatchData 对象的 [] 方法（使用符号或字符串作为键）或 named_captures 方法访问。

正则表达式选项 (Options / Flags)

可以在正则表达式字面量后面添加一个或多个字母来改变匹配的行为，或者在模式内部使用 (?option) 或 (?option:pattern)。常用的选项：

i：忽略大小写 (case-insensitive)。/abc/i 匹配 “abc”, “ABC”, “aBc” 等。
m：多行模式 (multiline)。使 ^ 和 $ 匹配每一行的开头和结尾（即 \n 之后和之前），并且 . 匹配包括换行符在内的任意字符。
x：扩展模式 (extended)。忽略模式中未转义的空白字符（空格、制表符等）和 # 后面的注释，有助于提高复杂正则表达式的可读性。/pattern/x
ruby / start # 匹配 "start" \s+ # 匹配一个或多个空白字符 (这里的空白符会被忽略，所以要用 \s+ 来匹配真正的空白符) end # 匹配 "end" /x # 匹配 "start end"
o：Once 选项。如果正则表达式包含变量，使用 o 选项会只在正则表达式第一次被创建时进行插值。这在循环中创建动态正则表达式时非常有用，可以避免重复的插值开销。

选项可以组合使用，例如 /pattern/im。

实际应用示例

1. 验证电子邮件格式 (简化版)：
“`ruby
def is_valid_email?(email)
# 这是一个简化的邮箱验证，实际复杂的邮箱格式需要更复杂的正则
email =~ /\A[\w+-.]+@[a-z\d-.]+.[a-z]+\z/i ? true : false
end

puts is_valid_email?(“[email protected]”) # => true
puts is_valid_email?(“[email protected]”) # => true
puts is_valid_email?(“invalid-email”) # => false
puts is_valid_email?(“@domain.com”) # => false
`` *\A和\z：确保匹配整个字符串，防止只匹配到邮箱的一部分。 *[\w+-.]+：用户名部分，匹配一个或多个单词字符、+、–、.。 *@：匹配字面量@符号。 *[a-z\d-.]+：域名部分，匹配小写字母、数字、–、.。 *.：转义的.，匹配字面量.符号。 *[a-z]+：顶级域名部分，匹配一个或多个小写字母。 *i` 选项：忽略大小写。

2. 从 URL 中提取信息：
“`ruby
url = “https://www.example.com/path/to/page?query=string#fragment”
match_data = url.match(%r{(?\w+)://(?:www.)?(?[\w.-]+)(?/[\w/.-]+)?(?\?.)?(?#.)?})

if match_data
puts “Protocol: #{match_data[:protocol]}” # => https
puts “Domain: #{match_data[:domain]}” # => example.com
puts “Path: #{match_data[:path]}” # => /path/to/page
puts “Query: #{match_data[:query]}” # => ?query=string
puts “Fragment: #{match_data[:fragment]}” # => #fragment
end
`` *%r{…}：使用%r避免斜杠转义。 *(?…)：命名捕获。 *(?:www.)?：非捕获分组，匹配可选的www.。 *[\w.-]+：域名部分，匹配单词字符、.、-`。

3. 替换 Markdown 链接：
将 [Text](URL) 格式的链接替换为 HTML 格式 <a href="URL">Text</a>。
ruby markdown_link = "Check this [link](http://example.com) out." html_link = markdown_link.gsub(/\[(.*?)\]$(.*?)$/, '<a href="\2">\1</a>') puts html_link # => Check this <a href="http://example.com">link</a> out.
* \[(.*?)\]：匹配 [，捕获中间任意内容（惰性匹配），匹配 ]。
* $(.*?)$：匹配 (, 捕获中间任意内容（惰性匹配），匹配 ).
* 替换字符串中的 \1 和 \2 引用捕获的内容。

正则表达式的性能考量

虽然正则表达式功能强大，但在处理非常大的文本或使用非常复杂的模式时，性能可能成为问题。一个常见的陷阱是灾难性回溯 (Catastrophic Backtracking)。这通常发生在模式中包含嵌套的量词（如 (a+)+ 或 (.*)*）或包含交错的可选部分和重复时，某些输入字符串会导致正则表达式引擎尝试指数级的回溯路径，从而消耗大量时间和内存。

避免策略：
* 尽量避免使用嵌套的、贪婪的量词组合，尤其是涉及 . 或 .* 的情况。
* 在合适的地方使用惰性量词 *?, +?。
* 考虑使用原子分组 (?>...) 来防止不必要的回溯。
* 如果只是检查是否存在，使用 match? 而不是 match 或 =~。
* 对于简单的子字符串查找，String#include? 通常比正则表达式更快。
* 对于简单的替换，使用 String#sub 或 String#gsub 配合固定字符串或简单模式。

对于复杂的模式，可以使用在线工具（如 rubular.com, regex101.com）来测试模式并观察其匹配过程，这有助于发现性能问题。

学习和调试正则表达式

学习正则表达式最好的方法是实践。从简单的模式开始，逐步增加复杂性。

调试技巧：
* 将复杂的模式分解成小部分测试。
* 使用在线正则表达式测试工具，它们通常提供详细的匹配步骤解析。
* 在 Ruby 中使用 match 方法获取 MatchData 对象，检查 match[0], match[1], etc. 以及 match.begin, match.end 来理解匹配结果。
* 对于难以理解的模式，可以考虑使用 x 选项增加注释和空白，提高可读性。

总结

Ruby 对正则表达式提供了深度集成和强大的支持，使其成为处理文本数据的强大武器。从基本的字面量匹配、字符类、量词、定位符到高级的捕获分组、反向引用、零宽断言和命名捕获，正则表达式提供了一套完整的工具来描述和操作文本模式。

掌握正则表达式需要时间和练习，因为它就像学习一门新的迷你语言。理解其基本构建块、量词的贪婪/惰性行为以及锚点的作用是关键。通过在实际项目中使用并结合在线工具辅助，你将能够驾驭这一强大的工具，更高效地解决各种文本处理挑战。

希望本文能为你深入学习 Ruby 正则表达式打下坚实的基础。祝你学习愉快，编码顺利！

Ruby 正则表达式介绍 – wiki基地

深入探索 Ruby 正则表达式：强大的文本模式匹配工具

什么是正则表达式？为什么使用它？

Ruby 中的正则表达式基础

Ruby 中使用正则表达式进行匹配操作

正则表达式的构建块 (Pattern Building Blocks)

1. 字面量字符 (Literal Characters)

2. 元字符 (Metacharacters)

3. 字符类 (Character Classes) `[]`

4. 预定义字符类 (Predefined Character Classes)

5. POSIX 字符类

6. 量词 (Quantifiers)

7. 定位符/锚点 (Anchors)

8. 分组与捕获 (Grouping and Capturing) `()`

也可以通过 MatchData 对象的 captures 方法获取所有捕获分组的数组

这里 (?:ou?) 只是为了让 ? 量词应用于 ou 整体，但 ou 或 u 本身不被捕获。

9. 选择符/或 (Alternation) `|`

Ruby 中的替换和分割操作

使用捕获分组和反向引用

使用块进行替换

高级正则表达式特性

1. 反向引用 (Backreferences) in Patterns

(\w+) 捕获一个单词

\s+ 匹配一个或多个空白符

\1 匹配与第一个捕获分组 (\w+) 完全相同的文本

\b 确保后面是单词边界

2. 零宽断言 (Zero-width Assertions / Lookarounds)

3. 原子分组 (Atomic Grouping) `(?>...)`

4. 命名捕获 (Named Captures) `(?<name>...)`

正则表达式选项 (Options / Flags)

实际应用示例

正则表达式的性能考量

学习和调试正则表达式

总结

发表评论取消回复

深入探索 Ruby 正则表达式：强大的文本模式匹配工具

什么是正则表达式？为什么使用它？

Ruby 中的正则表达式基础

Ruby 中使用正则表达式进行匹配操作

正则表达式的构建块 (Pattern Building Blocks)

1. 字面量字符 (Literal Characters)

2. 元字符 (Metacharacters)

3. 字符类 (Character Classes) []

4. 预定义字符类 (Predefined Character Classes)

5. POSIX 字符类

6. 量词 (Quantifiers)

7. 定位符/锚点 (Anchors)

8. 分组与捕获 (Grouping and Capturing) ()

也可以通过 MatchData 对象的 captures 方法获取所有捕获分组的数组

这里 (?:ou?) 只是为了让 ? 量词应用于 ou 整体，但 ou 或 u 本身不被捕获。

9. 选择符/或 (Alternation) |

Ruby 中的替换和分割操作

使用捕获分组和反向引用

使用块进行替换

高级正则表达式特性

1. 反向引用 (Backreferences) in Patterns

(\w+) 捕获一个单词

\s+ 匹配一个或多个空白符

\1 匹配与第一个捕获分组 (\w+) 完全相同的文本

\b 确保后面是单词边界

2. 零宽断言 (Zero-width Assertions / Lookarounds)

3. 原子分组 (Atomic Grouping) (?>...)

4. 命名捕获 (Named Captures) (?<name>...)

正则表达式选项 (Options / Flags)

实际应用示例

正则表达式的性能考量

学习和调试正则表达式

总结

发表评论 取消回复

3. 字符类 (Character Classes) `[]`

8. 分组与捕获 (Grouping and Capturing) `()`

9. 选择符/或 (Alternation) `|`

3. 原子分组 (Atomic Grouping) `(?>...)`

4. 命名捕获 (Named Captures) `(?<name>...)`

发表评论取消回复