非贪婪量词在匹配 HTML/XML 标签、引号括起来的字符串等场景中非常有用，可以避免匹配到超出预期范围的内容。

7. 边界匹配 (Anchors)

边界匹配器（或称锚点）不匹配实际的字符，而是匹配位置。它们用于将模式固定在字符串的特定位置。

• ^: 匹配字符串的开始。
• $: 匹配字符串的结束。
• \b: 匹配一个单词边界。
• \B: 匹配一个非单词边界。

^ 和 $ 示例：

“`ruby
puts “start”.match(/^start/).to_s # => start (必须以 start 开头)
puts “start and end”.match(/^start/).to_s # => start
puts “not start”.match(/^start/).to_s # => “” (匹配失败)

puts “end”.match(/end$/).to_s # => end (必须以 end 结尾)
puts “start and end”.match(/end$/).to_s # => end
puts “ending”.match(/end$/).to_s # => “” (匹配失败)

匹配整个字符串

puts “exactly”.match(/^exactly$/).to_s # => exactly (字符串必须正好是 “exactly”)
puts ” exactly “.match(/^exactly$/).to_s # => “” (有空格，匹配失败)
“`

\b (单词边界) 示例：

\b 匹配单词字符 (\w，即字母、数字、下划线) 和非单词字符 (\W) 之间的位置。它也匹配字符串的开始和结束位置，如果这些位置紧邻单词字符。

“`ruby
text = “word words wording sword”

匹配完整的单词 “word”

puts text.match(/\bword\b/).to_s # => word

如果没有 \b，会匹配到 words 和 wording 中的 “word” 子串

puts text.match(/word/).to_s # => word

puts “word”.match(/\bword\b/).to_s # => word (字符串开头和结尾是边界)
puts “word!”.match(/\bword\b/).to_s # => word (! 是非单词字符)
puts “!word”.match(/\bword\b/).to_s # => word (! 是非单词字符)
puts “keyword”.match(/\bword\b/).to_s # => “” (k 是单词字符，不是边界)
“`

\B (非单词边界) 示例：

\B 匹配一个非单词边界的位置。例如，在两个单词字符之间，或在两个非单词字符之间。

“`ruby
text = “keyword words”

匹配作为子串的 “word”，而不是完整的单词

puts text.match(/\Bword\b/).to_s # => word (匹配 keyword 中的 word)
“`

\A, \Z, \z 的区别 (高级边界):

在 Ruby 中，还有更精确的边界匹配器：

• \A: 只匹配字符串的绝对开头。不受多行模式 (m 选项) 的影响。
• \Z: 匹配字符串的结尾，但在最后一个换行符 \n 之前（如果存在）。
• \z: 匹配字符串的绝对结尾。不受多行模式 (m 选项) 的影响。

通常情况下，^ 等同于 \A，$ 等同于 \Z。但在启用多行模式 (/m 或 Regexp::MULTILINE) 时，^ 和 $ 会匹配每一行的开头和结尾（即 \n 之后和之前的位置），而 \A, \Z, \z 仍然只匹配整个字符串的开始和结束。

示例：

“`ruby
text_multiline = “Line 1\nLine 2\nLine 3”

默认行为：

puts text_multiline.match(/^Line/).to_s # => Line (匹配第一行开头)
puts text_multiline.match(/3$/).to_s # => 3 (匹配最后一行结尾)
puts text_multiline.match(/\ALine/).to_s # => Line (匹配字符串绝对开头)
puts text_multiline.match(/3\Z/).to_s # => 3 (匹配字符串结尾，\n前)
puts text_multiline.match(/3\z/).to_s # => 3 (匹配字符串绝对结尾)

puts text_multiline.match(/\nLine/).to_s # => \nLine (匹配换行符后跟着 Line)

在多行模式下 (/m)：

注意：在 Ruby 的正则表达式中，/m 选项（Regexp::MULTILINE）的默认行为是让 ‘.’ 匹配换行符。

行锚点 (^ 和 $) 的多行行为由 /m 或 /n (弃用) /u /e 之外的选项控制，但通常 ^和$ 本身就是多行模式下的行锚点。

实际测试 Ruby 文档和行为表明，^和$ 默认就是多行感知的，除非使用了 /m （它主要影响 . 的行为）或其他编码选项。

更准确地说，在 Ruby 中，^ 和 $ 总是匹配行的开始和结束，而 \A 和 \z 总是匹配字符串的开始和结束。

\Z 匹配字符串结尾，但在可能的最终换行符之前。

让我们用更清晰的例子说明 \Z 和 \z 的区别：

text_end_newline = “Hello\n”
puts text_end_newline.match(/o\Z/).to_s # => o (匹配到 \n 前的 o)
puts text_end_newline.match(/o\z/).to_s # => “” (匹配不到，因为 \z 在字符串的绝对结尾，o 不在那里)
puts text_end_newline.match(/\n\z/).to_s # => \n (匹配字符串末尾的 \n)
“`

对于大多数常见的匹配任务，^ 和 $ 就足够了。只有当你需要严格区分整个字符串的开头/结尾和每一行的开头/结尾时，才需要用到 \A, \Z, \z。

8. 特殊字符序列 (Shorthand Character Classes)

为了方便，正则表达式定义了一些常用的字符集合的简写形式。

• \d: 匹配任意数字字符，等价于 [0-9]。
• \D: 匹配任意非数字字符，等价于 [^0-9]。
• \w: 匹配任意“单词”字符（字母、数字或下划线），等价于 [a-zA-Z0-9_]。
• \W: 匹配任意非“单词”字符，等价于 [^a-zA-Z0-9_]。
• \s: 匹配任意空白字符（空格、制表符 \t、换行符 \n、回车符 \r、换页符 \f 等），等价于 [ \t\n\r\f\v]。
• \S: 匹配任意非空白字符，等价于 [^ \t\n\r\f\v]。

示例：

ruby
puts "Phone: 123-456-7890".match(/\d{3}-\d{3}-\d{4}/).to_s # => 123-456-7890
puts "ID: user_123".match(/\w+/).to_s # => ID (匹配一个或多个单词字符)
puts "Space out".match(/\s/).to_s # => " " (匹配一个空格)
puts "NoSpace".match(/\S/).to_s # => N (匹配一个非空白字符)

这些简写形式极大地提高了正则表达式的可读性和编写效率。

9. 分组和捕获 (Grouping and Capturing)

圆括号 () 在正则表达式中有两个主要作用：

1. 分组 (Grouping): 将多个元素视为一个整体，以便对其应用量词或进行其他操作。
2. 捕获 (Capturing): 匹配到的分组内容会被“捕获”并存储起来，以便后续引用或提取。

分组示例：

“`ruby

匹配连续出现的 “ab” 两次

puts “abab”.match(/(ab){2}/).to_s # => abab

匹配 “go” 或 “stop” 后面跟 “ing”

puts “going”.match(/(go|stop)ing/).to_s # => going
puts “stopping”.match(/(go|stop)ing/).to_s # => stopping
“`

在没有分组的情况下，量词和选择符 | 会按照特定的优先级结合。例如，go|stop+ing 意味着 go 或 (stop 出现一次或多次) 后面跟 ing。使用分组可以明确指定结合关系。

捕获示例：

当使用圆括号 () 进行分组时，匹配到的子字符串会被自动捕获。match 方法返回的 MatchData 对象可以让你访问这些捕获的内容。match_data[0] 是整个匹配到的字符串，match_data[1] 是第一个捕获组的内容，match_data[2] 是第二个捕获组的内容，以此类推。

“`ruby

匹配一个日期格式 YYYY-MM-DD，并捕获年、月、日

date_pattern = /(\d{4})-(\d{2})-(\d{2})/
text = “Today’s date is 2023-10-26.”

match_data = text.match(date_pattern)

if match_data
puts “Full match: #{match_data[0]}” # => 2023-10-26
puts “Year: #{match_data[1]}” # => 2023
puts “Month: #{match_data[2]}” # => 10
puts “Day: #{match_data[3]}” # => 26
# 你也可以使用名称访问，如果使用了命名捕获组 (稍后介绍)
end
“`

捕获组是从左到右按照左括号 ( 出现的顺序编号的。

非捕获分组 (Non-capturing Groups):

如果你只需要使用圆括号进行分组，但不需要捕获其内容，可以使用非捕获分组 (?:...)。这可以提高性能，并且不会占用捕获组的编号。

“`ruby

匹配 “cat” 或 “dog”，后面跟一个或多个 “s”

使用捕获分组：

puts “cats and dogs”.match(/(cat|dog)s+/).to_s # => cats

match_data[1] 是 “cat” 或 “dog”

使用非捕获分组：

puts “cats and dogs”.match(/(?:cat|dog)s+/).to_s # => cats

如果这里是第一个捕获组，match_data[1] 将是 nil 或下一个捕获组

“`

在不需要引用分组内容时，优先使用非捕获分组。

命名捕获组 (Named Capture Groups):

为了提高可读性，可以使用 (?<name>...) 的语法为捕获组命名。

“`ruby

使用命名捕获组匹配日期

date_pattern_named = /(?\d{4})-(?\d{2})-(?\d{2})/
text = “Birth date: 1990-05-15”

match_data = text.match(date_pattern_named)

if match_data
puts “Full match: #{match_data[0]}”
puts “Year: #{match_data[:year]}” # 使用符号作为键访问
puts “Month: #{match_data[“month”]}” # 也可以使用字符串作为键访问
puts “Day: #{match_data[:day]}”
puts “As hash: #{match_data.names}” # 捕获组名称数组
puts “As hash: #{match_data.to_h}” # 转换为名称 => 捕获内容的哈希
end
“`

命名捕获组使得从 MatchData 对象中提取特定信息变得更加清晰和方便。

10. 选择符 (Alternation)

竖线 | 用作选择符，表示“或”的关系。它允许你匹配多个模式中的任意一个。

“`ruby

匹配 “cat” 或 “dog”

puts “The cat sat.”.match(/cat|dog/).to_s # => cat
puts “The dog barked.”.match(/cat|dog/).to_s # => dog

结合分组：匹配 “cat” 或 “dog”，后面跟着 “s”

puts “cats”.match(/(cat|dog)s/).to_s # => cats
puts “dogs”.match(/(cat|dog)s/).to_s # => dogs
“`

没有分组时，| 的作用范围是整个正则表达式。例如，cat|dog 匹配字符串中的 cat 或 dog。如果写成 cats|dogs，则匹配完整的 cats 字符串或完整的 dogs 字符串。使用分组 (cat|dog)s 则表示匹配 cat 或 dog 后紧跟 s。

11. 修饰符 (Options)

修饰符用于改变正则表达式的匹配行为。在 Ruby 中，修饰符可以放在字面量斜杠 / 后面，或者作为 Regexp.new 的第二个参数。

常用的修饰符：

• i (case-insensitive): 忽略大小写进行匹配。
  ruby
puts "Hello World".match(/world/i).to_s # => World
puts "HELLO WORLD".match(/world/i).to_s # => HELLO WORLD
• m (multiline): 使 . 匹配包括换行符 \n 在内的任意字符。注意，如前所述，在 Ruby 中 ^ 和 $ 默认就是多行感知的，这个选项主要影响 .。
  ruby
text_multiline = "Line 1\nLine 2"
# 默认 . 不匹配 \n
puts text_multiline.match(/Line.*Line/).to_s # => ""
# /m 选项使 . 匹配 \n
puts text_multiline.match(/Line.*Line/m).to_s # => Line 1\nLine 2

• x (extended): 忽略模式中的非转义空白字符，并支持 # 开头的行内注释。这使得编写复杂、可读性强的正则表达式成为可能。
  “`ruby
  # 匹配 YYYY-MM-DD 格式的日期，使用 /x 提高可读性
  date_pattern_readable = /
  (?\d{4}) # 匹配年份，4位数字

  • 匹配字面量连字符

    (?\d{2}) # 匹配月份，2位数字

  • 匹配字面量连字符

    (?\d{2}) # 匹配日期，2位数字
    /x

  text = “Date: 2024-01-10”
  match_data = text.match(date_pattern_readable)
  puts “Readable pattern match: #{match_data.to_h}” # => {“year”=>”2024”, “month”=>”01”, “day”=>”10”}
  注意，在 `/x` 模式下，如果你需要匹配字面意义的空格或 `#`，你需要对它们进行转义 (`\ ` 或 `\#`)。
* `o` (compile once): 如果正则表达式字面量或 `Regexp.new` 的参数包含内嵌的 Ruby 变量，使用 `/o` 选项可以确保正则表达式只在变量第一次求值时编译一次。这对于循环中使用的正则表达式可以提高性能。ruby
  word = “apple”
  1000.times do
  # 每次迭代都会重新构建和编译正则表达式 (如果 word 可能变化)
  # “some text about #{word}”.match(/#{word}/)

  # 使用 /o 选项，正则表达式只在 word 首次求值时编译
  “some text about #{word}”.match(/#{word}/o)
  end
  ``
通常字面量/pattern/本身就是编译一次的，/o主要用于字面量中包含#{…}` 插值的情况。

修饰符可以组合使用，例如 /pattern/ix。

12. 替换 (Substitution)

Ruby 提供了 sub 和 gsub 方法，结合正则表达式进行字符串替换。

• sub(pattern, replacement): 替换第一个匹配到的部分。
• gsub(pattern, replacement): 替换所有匹配到的部分。

使用字符串进行替换：

替换字符串可以使用特殊的序列来引用捕获组：

• \& 或 \0: 引用整个匹配到的字符串 (match_data[0])。
• \ + 数字: 引用对应的捕获组 (match_data[1], match_data[2], 等)。例如 \1, \2.
• \': 引用匹配点之后的字符串 (match_data.post_match)。
• \``: 引用匹配点之前的字符串 (match_data.pre_match`)。

“`ruby
text = “Replace the first word and the second word.”

替换第一个 “word” 为 “match”

puts text.sub(/word/, “match”) # => Replace the first match and the second word.

替换所有 “word” 为 “match”

puts text.gsub(/word/, “match”) # => Replace the first match and the second match.

使用捕获组进行替换：将 YYYY-MM-DD 格式转换为 DD/MM/YYYY

date = “Date is 2023-10-26.”
puts date.sub(/(\d{4})-(\d{2})-(\d{2})/, ‘\3/\2/\1’) # => Date is 26/10/2023. (\3是日，\2是月，\1是年)

使用命名捕获组

date_named = “Date is 2023-10-26.”
puts date_named.sub(/(?\d{4})-(?\d{2})-(?\d{2})/, ‘\k/\k/\k‘) # => Date is 26/10/2023.

或更推荐的 Ruby 语法:

puts date_named.sub(/(?\d{4})-(?\d{2})-(?\d{2})/) { |match|
“#{match[:day]}/#{match[:month]}/#{match[:year]}”
} # => Date is 26/10/2023.
“`

使用块进行替换：

sub 和 gsub 也可以接受一个块。匹配到的内容会作为参数传递给块，块的返回值将作为替换字符串。这使得替换逻辑更加灵活。

“`ruby
text = “prices: $1.50, $10, $0.75”

将所有美元价格转换为两小数位格式

puts text.gsub(/\$\d+(.\d+)?/) { |price_match|
# price_match 就是匹配到的 “$1.50”, “$10”, “$0.75” 等
# 移除 $ 符号，转换为浮点数，再格式化
amount = price_match[1..-1].to_f # 切掉 $ 符号并转为浮点数
sprintf(“$%.2f”, amount) # 格式化为两小数位
}

=> prices: $1.50, $10.00, $0.75

“`

使用块进行替换是处理复杂替换逻辑的强大方式。

13. 分割 (Splitting)

split 方法可以使用正则表达式作为分隔符来分割字符串，返回一个字符串数组。

“`ruby
text = “apple,orange;banana grape”

使用逗号或分号或空格作为分隔符

fruits = text.split(/[,; ]/)
puts fruits.inspect # => [“apple”, “orange”, “banana”, “grape”]

移除开头和结尾的空白符

text_with_whitespace = ” word1 word2 \n word3 ”
words = text_with_whitespace.split(/\s+/) # 使用一个或多个空白符作为分隔
puts words.inspect # => [“word1”, “word2”, “word3”]
“`

如果正则表达式包含捕获组，那么捕获到的分隔符内容也会包含在结果数组中。

“`ruby
text = “item1:value1;item2:value2”

使用冒号或分号作为分隔符，并捕获冒号和分号

parts = text.split(/(:|;)/)
puts parts.inspect # => [“item1”, “:”, “value1”, “;”, “item2”, “:”, “value2”]
“`

通常在 split 中使用非捕获分组 (?:...) 可以避免捕获分隔符本身。

“`ruby

使用非捕获分组分隔符

parts = text.split(/(?:|;)/)
puts parts.inspect # => [“item1”, “value1”, “item2”, “value2”]
“`

14. 实践示例

示例 1: 简单的邮箱格式验证 (简化版)

“`ruby
def is_simple_email?(email)
# 模式解释:
# ^ – 匹配字符串开头
# \w+ – 匹配一个或多个单词字符 (用户名部分)
# @ – 匹配字面量 @ 符号
# \w+ – 匹配一个或多个单词字符 (域名第一部分)
# (.\w+)+ – 匹配一个点号后跟一个或多个单词字符，整个模式 (.\w+) 重复一次或多次 (域名后续部分，如 .com, .co.uk)
# $ – 匹配字符串结尾
email =~ /^\w+@\w+(.\w+)+$/i # 使用 =~ 快速检查是否匹配，/i 忽略大小写
end