Ruby 正则表达式

正则表达式是一种强大的文本处理工具，可以用来在文本中进行匹配、查找、替换等操作。Ruby语言中内置了正则表达式的支持，本文将介绍Ruby中正则表达式的基本用法和语法。

正则表达式的定义

正则表达式是一种特殊的字符序列，用来描述一组匹配某个特定模式的字符串。它通常包含正则表达式操作符、限定符、元字符等多种组成部分，可以使用这些组成部分来表达出各种复杂的模式。

Ruby中的正则表达式

Ruby中的正则表达式可以用来匹配字符串、查找、替换等操作。Ruby正则表达式的语法和很多其他语言一样，主要使用“/”符号将正则表达式内容括起来。例如：

/regex/

其中，regex为正则表达式的内容。在Ruby中，正则表达式也可以使用%q/.. /格式。例如：

%q/regex/

正则表达式的元字符

元字符是组成正则表达式的基本单元，它可以代表各种字符或字符集。Ruby支持的元字符包括：

. ：匹配所有字符，除了换行符；
^ ：匹配字符串的开头；
$ ：匹配字符串的结尾；
[] ：字符集，匹配括号中的任意一个字符。例如：[abc]可以匹配a、b、c中的任意一个字符；
[^] ：否定字符集，匹配不属于括号中的任何一个字符。例如：[^abc]可以匹配非a、b、c的任意一个字符；
() ：分组，将括号中的内容作为一个整体进行匹配；
| ：或，匹配左右两侧任意一个正则表达式；
- ：匹配前面字符的0次或多次出现；
- ：匹配前面字符的1次或多次出现；
? ：匹配前面字符的0次或1次出现。

例如，下面是一些正则表达式的示例：

/abc/           # 匹配abc字符串
/^abc/          # 匹配以abc开头的字符串
/abc$/          # 匹配以abc结尾的字符串
/[abc]/         # 匹配a、b、c中的任意一个字符
/[^abc]/        # 匹配非a、b、c的任意一个字符
/(abc)+/        # 匹配1个或多个abc字符串
/(abc|def)/     # 匹配abc或def字符串
/ab*c/          # 匹配ac、abc、abbc等字符串
/ab+c/          # 匹配abc、abbc、abbbc等字符串
/ab?c/          # 匹配ac或abc字符串

正则表达式的限定符

正则表达式的限定符用于指定匹配规则的次数。Ruby支持的限定符包括：

- ：匹配0次或多次出现；
- ：匹配1次或多次出现；
? ：匹配0次或者1次出现；
{n} ：匹配n次出现；
{n,} ：匹配n次以上出现；
{n,m} ：匹配n到m次出现。

例如，下面是一些限定符的示例：

/a*/            # 匹配0个或多个a字符
/a+/            # 匹配1个或多个a字符
/a?/            # 匹配0个或者1个a字符
/a{3}/          # 匹配3个a字符
/a{3,}/         # 匹配3个以上的a字符
/a{3,7}/          # 匹配3到7个a字符

Ruby中的正则表达式操作符

在Ruby中，正则表达式可以使用以下操作符：

=~ ：匹配正则表达式；
!~ ：不匹配正则表达式；
= ：用于case语句的比较；
match ：对一个字符串进行匹配。

例如，下面是一些操作符的示例：

"abc" =~ /a/        # => 0
"abc" =~ /d/        # => nil

"abc" !~ /a/        # => false
"abc" !~ /d/        # => true

case "abc"
when /a/
  puts "匹配a"
when /d/
  puts "匹配d"
end

# 输出：匹配a

"abc".match(/a/)    # => #<MatchData "a">

正则表达式的特殊字符

正则表达式中还有一些特殊字符和转义序列，它们有特殊的含义。Ruby中的正则表达式支持的特殊字符和转义序列包括：

\d ：匹配数字字符；
\D ：匹配非数字字符；
\w ：匹配单词字符（字母、数字和下划线）；
\W ：匹配非单词字符；
\s ：匹配空白字符（空格、制表符、换行符等）；
\S ：匹配非空白字符；
\b ：匹配单词边界；
\B ：匹配非单词边界；
\n ：匹配换行符；
\t ：匹配制表符；
\ ：转义字符。

例如，下面是一些特殊字符和转义序列的示例：

/\d+/           # 匹配1个或多个数字字符
/\w+/           # 匹配1个或多个单词字符
/\s+/           # 匹配1个或多个空白字符
/\babc\b/       # 匹配abc单词

正则表达式的匹配结果

当执行正则表达式匹配时，会返回一个匹配对象（MatchData）。这个匹配对象包含了匹配到的字符串的信息，可以通过它来获取匹配到的内容、位置等信息。例如：

text = "hello world"
match_obj = /l/.match(text)
p match_obj            # => #<MatchData "l">
p match_obj[0]         # => "l"
p match_obj.begin(0)   # => 2
p match_obj.end(0)     # => 3
p match_obj.offset(0)  # => [2, 3]

在上面的示例中，首先使用正则表达式/l/对字符串”hello world”进行了匹配，返回一个MatchData对象。这个对象中的[0]元素是匹配到的字符串”l”，begin(0)和end(0)是匹配到的字符串的位置（起始索引和结束索引），offset(0)是一个数组，包含了匹配到的字符串的起始索引和结束索引。

Ruby自定义正则表达式

除了使用预定义的正则表达式之外，Ruby还允许我们自己定义正则表达式。定义正则表达式的方式是通过Regexp类定义一个新的正则表达式对象。例如：

my_regex = Regexp.new("[a-z]+")
text = "hello world"
match_obj = my_regex.match(text)
p match_obj            # => #<MatchData "hello">

在上面的示例中，我们定义了一个正则表达式对象my_regex，并将它用于匹配字符串”hello world”。可以看到，返回的匹配结果是”hello”，这说明我们定义的正则表达式成功匹配了字符串。

Ruby中的替换操作

除了匹配之外，正则表达式在Ruby中还可以用来替换字符串中的部分内容。Ruby提供了sub和gsub方法来实现替换操作。其中，sub方法只替换第一个匹配项，而gsub方法会替换所有匹配项。

例如，下面是一些替换操作的示例：

text = "hello world"
new_text = text.sub(/l/, "L")
puts new_text          # => "heLlo world"

new_text = text.gsub(/l/, "L")
puts new_text          # => "heLLo worLd"

text = "hello, world!"
new_text = text.gsub(/(hello), (world)/, '\2, \1')
puts new_text          # => "world, hello!"

在上面的示例中，首先使用sub方法替换了第一个匹配到的字符”l”为”L”，返回了新的字符串。接着使用了gsub方法替换了所有匹配到的”l”为”L”，返回了新的字符串。最后，我们使用了gsub方法将”hello, world”替换成”world, hello”，其中 ‘\2, \1’ 表示交换了第一组和第二组括号中匹配的内容。

Ruby中的匹配模式

在Ruby中，正则表达式可以指定匹配模式，来控制正则表达式的匹配方式。Ruby中支持的匹配模式包括：

i ：不区分大小写匹配；
m ：多行匹配；
x ：忽略空白字符；
o ：仅解析一次正则表达式。

例如，下面是一些匹配模式的示例：

"hello World" =~ /world/i    # => 6
"hello\nWorld" =~ /^world/m  # => nil

/\d{3}\s*\d{4}/ =~ "1234 5678"  # => 0
/\d{3}\s*\d{4}/ =~ " 1234 5678" # => 1

/abc/o =~ "abc"   # => 0
/abc/o =~ "abca"  # => nil

在上面的示例中，我们使用了不同的匹配模式来对不同的字符串进行了匹配。在第一个例子中，使用了不区分大小写的模式来匹配字符串中的”world”。在第二个例子中，使用了多行模式来匹配一个包含换行符的文本。在第三个例子中，使用了忽略空白字符的模式来匹配一串带空格的数字。在最后一个例子中，使用了仅解析一次的模式，匹配了一次”abc”之后就不再匹配。

综合示例

下面是一个综合示例，它使用正则表达式来过滤一个字符串中所有的数字字符，并对匹配到的数字进行平方操作：

text = "a1b2c3d4e5"
pattern = /\d/
replacement = lambda { |match| match[0].to_i ** 2 }
new_text = text.gsub(pattern, &replacement)
puts new_text  # => "a1b4c9d16e25"

在上面的示例中，我们首先定义了一个字符串text，它包含了一系列数字字符。然后定义了一个正则表达式/\d/，它用来匹配所有的数字字符。接着定义了一个替换方法replacement，它接收一个MatchData对象作为参数，并将这个对象中的第一组匹配到的数字字符转换成整数之后进行平方操作。最后使用gsub方法将匹配到的数字字符进行替换，返回一个新的字符串。