class Regexp

一个正则表达式（也称为regexp）是一个匹配模式（也简称为模式）。

regexp 的一种常见表示法是使用封闭的斜杠字符

/foo/

regexp 可以应用于一个目标字符串；字符串中与模式匹配的部分（如果有）称为匹配，可以称为匹配。

re = /red/
re.match?('redirect') # => true   # Match at beginning of target.
re.match?('bored')    # => true   # Match at end of target.
re.match?('credit')   # => true   # Match within target.
re.match?('foo')      # => false  # No match.

Regexp 的用法

Regexp 可用于

根据给定模式提取子字符串

re = /foo/              # => /foo/
re.match('food')        # => #<MatchData "foo">
re.match('good')        # => nil

请参阅Method match和Operator =~部分。

确定字符串是否匹配给定模式
```
re.match?('food') # => true
re.match?('good') # => false
```
请参阅Method match?部分。
作为其他类和模块中某些方法调用的参数；大多数此类方法接受一个可以是字符串或（更强大的）regexp 的参数。

请参阅Regexp Methods。

Regexp 对象

Regexp 对象具有

一个源；请参阅Sources。
多个模式；请参阅Modes。
一个超时；请参阅Timeouts。
一个编码；请参阅Encodings。

创建 Regexp

正则表达式可以通过以下方式创建：

使用斜杠字符的 regexp 字面量（请参阅Regexp Literals）
```
# This is a very common usage.
/foo/ # => /foo/
```

%r regexp 字面量（请参阅%r: Regexp Literals）

# Same delimiter character at beginning and end;
# useful for avoiding escaping characters
%r/name\/value pair/ # => /name\/value pair/
%r:name/value pair:  # => /name\/value pair/
%r|name/value pair|  # => /name\/value pair/

# Certain "paired" characters can be delimiters.
%r[foo] # => /foo/
%r{foo} # => /foo/
%r(foo) # => /foo/
%r<foo> # => /foo/

方法 Regexp.new。

方法 `match`

方法 Regexp#match、String#match 和 Symbol#match 中的每一种都会在找到匹配时返回一个 MatchData 对象，否则返回 nil；每种方法还会设置全局变量。

'food'.match(/foo/) # => #<MatchData "foo">
'food'.match(/bar/) # => nil

运算符 `=~`

运算符 Regexp#=~、String#=~ 和 Symbol#=~ 中的每一种都会在找到匹配时返回一个整数偏移量，否则返回 nil；每种方法还会设置全局变量。

/bar/ =~ 'foo bar' # => 4
'foo bar' =~ /bar/ # => 4
/baz/ =~ 'foo bar' # => nil

方法 `match?`

方法 Regexp#match?、String#match? 和 Symbol#match? 中的每一种都会在找到匹配时返回 true，否则返回 false；没有任何一种会设置全局变量。

'food'.match?(/foo/) # => true
'food'.match?(/bar/) # => false

全局变量

某些面向 regexp 的方法会将值赋给全局变量。

match：请参阅Method match。
=~：请参阅Operator =~。

受影响的全局变量是：

$~：返回一个 MatchData 对象，或 nil。
$&：返回匹配的字符串部分，或 nil。
$`：返回匹配字符串的左侧部分，或 nil。
$'：返回匹配字符串的右侧部分，或 nil。
$+：返回最后一个匹配的分组，或 nil。
$1、$2 等：返回第一个、第二个等匹配的分组，或 nil。请注意，$0 完全不同；它返回当前执行程序的名称。

这些变量（除了 $~）是 $~ 方法的简写。请参阅MatchData 中的全局变量等效性。

示例

# Matched string, but no matched groups.
'foo bar bar baz'.match('bar')
$~ # => #<MatchData "bar">
$& # => "bar"
$` # => "foo "
$' # => " bar baz"
$+ # => nil
$1 # => nil

# Matched groups.
/s(\w{2}).*(c)/.match('haystack')
$~ # => #<MatchData "stac" 1:"ta" 2:"c">
$& # => "stac"
$` # => "hay"
$' # => "k"
$+ # => "c"
$1 # => "ta"
$2 # => "c"
$3 # => nil

# No match.
'foo'.match('bar')
$~ # => nil
$& # => nil
$` # => nil
$' # => nil
$+ # => nil
$1 # => nil

请注意，Regexp#match?、String#match? 和 Symbol#match? 不会设置全局变量。

源

如上所示，最简单的 regexp 使用字面量表达式作为其源。

re = /foo/              # => /foo/
re.match('food')        # => #<MatchData "foo">
re.match('good')        # => nil

丰富的可用子表达式集合使 regexp 具有强大的功能和灵活性。

特殊字符

Regexp 特殊字符，称为元字符，在某些上下文中具有特殊含义；取决于上下文，这些有时是元字符。

. ? - + * ^ \ | $ ( ) [ ] { }

要字面匹配一个元字符，请使用反斜杠转义它。

# Matches one or more 'o' characters.
/o+/.match('foo')  # => #<MatchData "oo">
# Would match 'o+'.
/o\+/.match('foo') # => nil

要字面匹配一个反斜杠，请使用反斜杠转义它。

/\./.match('\.')  # => #<MatchData ".">
/\\./.match('\.') # => #<MatchData "\\.">

方法 Regexp.escape 返回一个已转义的字符串。

Regexp.escape('.?-+*^\|$()[]{}')
# => "\\.\\?\\-\\+\\*\\^\\\\\\|\\$\\(\\)\\[\\]\\{\\}"

源字面量

源字面量在很大程度上类似于双引号字符串；请参阅Double-Quoted String Literals。

特别地，源字面量可以包含插值表达式。

s = 'foo'         # => "foo"
/#{s}/            # => /foo/
/#{s.capitalize}/ # => /Foo/
/#{2 + 2}/        # => /4/

普通字符串字面量和源字面量之间存在差异；请参阅Shorthand Character Classes。

普通字符串字面量中的 \s 等同于空格字符；在源字面量中，它是匹配空白字符的简写。
在普通字符串字面量中，这些是（不必要的）转义字符；在源字面量中，它们是匹配各种字符的简写。
```
\w \W \d \D \h \H \S \R
```

字符类

一个字符类由方括号分隔；它指定在目标字符串的给定位置，某些字符匹配。

# This character class will match any vowel.
re = /B[aeiou]rd/
re.match('Bird') # => #<MatchData "Bird">
re.match('Bard') # => #<MatchData "Bard">
re.match('Byrd') # => nil

字符类可以包含连字符来指定字符范围。

# These regexps have the same effect.
/[abcdef]/.match('foo') # => #<MatchData "f">
/[a-f]/.match('foo')    # => #<MatchData "f">
/[a-cd-f]/.match('foo') # => #<MatchData "f">

当字符类的第一个字符是插入符号（^）时，类的含义被反转：它匹配指定字符以外的任何字符。

/[^a-eg-z]/.match('f') # => #<MatchData "f">

一个字符类可以包含另一个字符类。单独而言，这没什么用，因为 [a-z[0-9]] 描述的集合与 [a-z0-9] 相同。

然而，字符类还支持 && 运算符，它对参数执行集合交集。两者可以组合如下：

/[a-w&&[^c-g]z]/ # ([a-w] AND ([^c-g] OR z))

这等同于

/[abh-w]/

简写字符类

以下每个元字符都作为字符类的简写：

/./：匹配除换行符外的任何字符。

/./.match('foo') # => #<MatchData "f">
/./.match("\n")  # => nil

/./m：匹配任何字符，包括换行符；请参阅Multiline Mode。
```
/./m.match("\n") # => #<MatchData "\n">
```

/\w/：匹配单词字符：等同于 [a-zA-Z0-9_]。

/\w/.match(' foo') # => #<MatchData "f">
/\w/.match(' _')   # => #<MatchData "_">
/\w/.match(' ')    # => nil

/\W/：匹配非单词字符：等同于 [^a-zA-Z0-9_]。

/\W/.match(' ') # => #<MatchData " ">
/\W/.match('_') # => nil

/\d/：匹配数字字符：等同于 [0-9]。

/\d/.match('THX1138') # => #<MatchData "1">
/\d/.match('foo')     # => nil

/\D/：匹配非数字字符：等同于 [^0-9]。

/\D/.match('123Jump!') # => #<MatchData "J">
/\D/.match('123')      # => nil

/\h/：匹配十六进制数字字符：等同于 [0-9a-fA-F]。

/\h/.match('xyz fedcba9876543210') # => #<MatchData "f">
/\h/.match('xyz')                  # => nil

/\H/：匹配非十六进制数字字符：等同于 [^0-9a-fA-F]。

/\H/.match('fedcba9876543210xyz') # => #<MatchData "x">
/\H/.match('fedcba9876543210')    # => nil

/\s/：匹配空白字符：等同于 /[ \t\r\n\f\v]/。

/\s/.match('foo bar') # => #<MatchData " ">
/\s/.match('foo')     # => nil

/\S/：匹配非空白字符：等同于 /[^ \t\r\n\f\v]/。

/\S/.match(" \t\r\n\f\v foo") # => #<MatchData "f">
/\S/.match(" \t\r\n\f\v")     # => nil

/\R/：独立于平台匹配换行符。

/\R/.match("\r")     # => #<MatchData "\r">     # Carriage return (CR)
/\R/.match("\n")     # => #<MatchData "\n">     # Newline (LF)
/\R/.match("\f")     # => #<MatchData "\f">     # Formfeed (FF)
/\R/.match("\v")     # => #<MatchData "\v">     # Vertical tab (VT)
/\R/.match("\r\n")   # => #<MatchData "\r\n">   # CRLF
/\R/.match("\u0085") # => #<MatchData "\u0085"> # Next line (NEL)
/\R/.match("\u2028") # => #<MatchData "\u2028"> # Line separator (LSEP)
/\R/.match("\u2029") # => #<MatchData "\u2029"> # Paragraph separator (PSEP)

锚点

锚点是元序列，用于匹配目标字符串中字符之间的零宽度位置。

对于没有锚点的子表达式，匹配可以从目标字符串的任何位置开始。

/real/.match('surrealist') # => #<MatchData "real">

对于带有锚点的子表达式，匹配必须从匹配的锚点开始。

边界锚点

以下每个锚点都匹配一个边界。

^：匹配行的开头。

/^bar/.match("foo\nbar") # => #<MatchData "bar">
/^ar/.match("foo\nbar")  # => nil

$：匹配行的末尾。

/bar$/.match("foo\nbar") # => #<MatchData "bar">
/ba$/.match("foo\nbar")  # => nil

\A：匹配字符串的开头。

/\Afoo/.match('foo bar')  # => #<MatchData "foo">
/\Afoo/.match(' foo bar') # => nil

\Z：匹配字符串的末尾；如果字符串以单个换行符结尾，则在结尾换行符之前匹配。

/foo\Z/.match('bar foo')     # => #<MatchData "foo">
/foo\Z/.match('foo bar')     # => nil
/foo\Z/.match("bar foo\n")   # => #<MatchData "foo">
/foo\Z/.match("bar foo\n\n") # => nil

\z：匹配字符串的末尾。

/foo\z/.match('bar foo')   # => #<MatchData "foo">
/foo\z/.match('foo bar')   # => nil
/foo\z/.match("bar foo\n") # => nil

\b：在括号外匹配单词边界；在括号内匹配退格符（"0x08"）。

/foo\b/.match('foo bar') # => #<MatchData "foo">
/foo\b/.match('foobar')  # => nil

\B：匹配非单词边界。

/foo\B/.match('foobar')  # => #<MatchData "foo">
/foo\B/.match('foo bar') # => nil

\G：匹配第一个匹配位置。

在 String#gsub 和 String#scan 等方法中，它在每次迭代时都会改变。它最初匹配主题的开头，在每次后续迭代中，它匹配上次匹配完成的位置。
```
"    a b c".gsub(/ /, '_')   # => "____a_b_c"
"    a b c".gsub(/\G /, '_') # => "____a b c"
```
在 Regexp#match 和 String#match 等接受可选偏移量的方法中，它匹配搜索开始的位置。
```
"hello, world".match(/,/, 3)   # => #<MatchData ",">
"hello, world".match(/\G,/, 3) # => nil
```

环视锚点

前瞻锚点

(?=pat)：正前瞻断言：确保后面的字符匹配pat，但不将这些字符包含在匹配的子字符串中。
(?!pat)：负前瞻断言：确保后面的字符不匹配pat，但不将这些字符包含在匹配的子字符串中。

后顾锚点

(?<=pat)：正后顾断言：确保前面的字符匹配pat，但不将这些字符包含在匹配的子字符串中。
(?<!pat)：负后顾断言：确保前面的字符不匹配pat，但不将这些字符包含在匹配的子字符串中。

下面的模式使用正前瞻和正后顾来匹配出现在 … 标签中的文本，而不将标签包含在匹配中。

/(?<=<b>)\w+(?=<\/b>)/.match("Fortune favors the <b>bold</b>.")
# => #<MatchData "bold">

后顾中的模式必须是固定宽度的。但顶层替代项可以是不同长度的。例如。 (?<=a|bc) 是可以的。 (?<=aaa(?:b|cd)) 不允许。

匹配重置锚点

\K：匹配重置：regexp 中 \K 前面的匹配内容被排除在结果之外。例如，以下两个 regexp 几乎等效：
```
/ab\Kc/.match('abc')    # => #<MatchData "c">
/(?<=ab)c/.match('abc') # => #<MatchData "c">
```
这些匹配相同的字符串，并且 $& 等于 'c'，而匹配的位置不同。

以下两个 regexp 也是如此：
```
/(a)\K(b)\Kc/
/(?<=(?<=(a))(b))c/
```

交替

竖线元字符（|）可用于括号内以表示交替：两个或多个子表达式，其中任何一个都可以匹配目标字符串。

两个替代项

re = /(a|b)/
re.match('foo') # => nil
re.match('bar') # => #<MatchData "b" 1:"b">

四个替代项

re = /(a|b|c|d)/
re.match('shazam') # => #<MatchData "a" 1:"a">
re.match('cold')   # => #<MatchData "c" 1:"c">

每个替代项都是一个子表达式，并且可以由其他子表达式组成。

re = /([a-c]|[x-z])/
re.match('bar') # => #<MatchData "b" 1:"b">
re.match('ooz') # => #<MatchData "z" 1:"z">

方法 Regexp.union 提供了一种方便的方式来构造具有替代项的 regexp。

量词

简单的 regexp 匹配一个字符。

/\w/.match('Hello')  # => #<MatchData "H">

添加的量词指定需要或允许多少次匹配。

* - 匹配零次或多次。

/\w*/.match('')
# => #<MatchData "">
/\w*/.match('x')
# => #<MatchData "x">
/\w*/.match('xyz')
# => #<MatchData "xyz">

+ - 匹配一次或多次。

/\w+/.match('')    # => nil
/\w+/.match('x')   # => #<MatchData "x">
/\w+/.match('xyz') # => #<MatchData "xyz">

? - 匹配零次或一次。

/\w?/.match('')    # => #<MatchData "">
/\w?/.match('x')   # => #<MatchData "x">
/\w?/.match('xyz') # => #<MatchData "x">

{n} - 精确匹配 n 次。

/\w{2}/.match('')    # => nil
/\w{2}/.match('x')   # => nil
/\w{2}/.match('xyz') # => #<MatchData "xy">

{min,} - 匹配 min 次或更多次。

/\w{2,}/.match('')    # => nil
/\w{2,}/.match('x')   # => nil
/\w{2,}/.match('xy')  # => #<MatchData "xy">
/\w{2,}/.match('xyz') # => #<MatchData "xyz">

{,max} - 匹配 max 次或更少次。

/\w{,2}/.match('')    # => #<MatchData "">
/\w{,2}/.match('x')   # => #<MatchData "x">
/\w{,2}/.match('xyz') # => #<MatchData "xy">

{min,max} - 匹配至少 min 次，最多 max 次。

/\w{1,2}/.match('')    # => nil
/\w{1,2}/.match('x')   # => #<MatchData "x">
/\w{1,2}/.match('xyz') # => #<MatchData "xy">

贪婪、惰性或占有式匹配

量词匹配可以是贪婪的、惰性的或占有式的。

在贪婪匹配中，尽可能多地匹配出现次数，同时仍允许整体匹配成功。贪婪量词：*、+、?、{min, max} 及其变体。
在惰性匹配中，匹配最少次数的出现。惰性量词：*?、+?、??、{min, max}? 及其变体。
在占有式匹配中，一旦找到匹配，就不会回溯；该匹配会保留，即使它危及整体匹配。占有式量词：*+、++、?+。请注意，{min, max} 及其变体不支持占有式匹配。

关于贪婪和惰性匹配，请参阅Choosing Minimal or Maximal Repetition。
关于占有式匹配，请参阅Eliminate Needless Backtracking。

分组和捕获

简单的 regexp 至多只有一个匹配。

re = /\d\d\d\d-\d\d-\d\d/
re.match('1943-02-04')      # => #<MatchData "1943-02-04">
re.match('1943-02-04').size # => 1
re.match('foo')             # => nil

添加一个或多个括号对 (subexpression) 定义了分组，这可能导致多个匹配的子字符串，称为捕获。

re = /(\d\d\d\d)-(\d\d)-(\d\d)/
re.match('1943-02-04')      # => #<MatchData "1943-02-04" 1:"1943" 2:"02" 3:"04">
re.match('1943-02-04').size # => 4

第一个捕获是整个匹配的字符串；其他捕获是来自分组的匹配子字符串。

分组可以有一个量词。

re = /July 4(th)?/
re.match('July 4')   # => #<MatchData "July 4" 1:nil>
re.match('July 4th') # => #<MatchData "July 4th" 1:"th">

re = /(foo)*/
re.match('')       # => #<MatchData "" 1:nil>
re.match('foo')    # => #<MatchData "foo" 1:"foo">
re.match('foofoo') # => #<MatchData "foofoo" 1:"foo">

re = /(foo)+/
re.match('')       # => nil
re.match('foo')    # => #<MatchData "foo" 1:"foo">
re.match('foofoo') # => #<MatchData "foofoo" 1:"foo">

返回的 MatchData 对象提供了对匹配子字符串的访问。

re = /(\d\d\d\d)-(\d\d)-(\d\d)/
md = re.match('1943-02-04')
# => #<MatchData "1943-02-04" 1:"1943" 2:"02" 3:"04">
md[0] # => "1943-02-04"
md[1] # => "1943"
md[2] # => "02"
md[3] # => "04"

非捕获分组

分组可以设置为非捕获；它仍然是一个分组（并且，例如，可以有一个量词），但其匹配的子字符串不包含在捕获中。

非捕获分组以 ?:（在括号内）开头。

# Don't capture the year.
re = /(?:\d\d\d\d)-(\d\d)-(\d\d)/
md = re.match('1943-02-04') # => #<MatchData "1943-02-04" 1:"02" 2:"04">

反向引用

分组匹配也可以在 regexp 本身内部引用；这种引用称为 backreference。

/[csh](..) [csh]\1 in/.match('The cat sat in the hat')
# => #<MatchData "cat sat in" 1:"at">

下表显示了上面 regexp 中的每个子表达式如何匹配目标字符串中的子字符串。

| Subexpression in Regexp   | Matching Substring in Target String |
|---------------------------|-------------------------------------|
|       First '[csh]'       |            Character 'c'            |
|          '(..)'           |        First substring 'at'         |
|      First space ' '      |      First space character ' '      |
|       Second '[csh]'      |            Character 's'            |
| '\1' (backreference 'at') |        Second substring 'at'        |
|           ' in'           |            Substring ' in'          |

Regexp 可以包含任意数量的分组。

对于大量分组：
- 普通 \n 表示法仅适用于 n 在范围 (1..9) 内。
- MatchData[n] 表示法适用于任何非负 n。
\0 是一个特殊反向引用，指向整个匹配的字符串；它不能在 regexp 本身内部使用，但可以在其外部使用（例如，在替换方法调用中）。
```
'The cat sat in the hat'.gsub(/[csh]at/, '\0s')
# => "The cats sats in the hats"
```

命名捕获

如上所示，可以通过数字引用捕获。捕获还可以有一个名称，前缀为 ?<name> 或 ?'name'，并且名称（符号化）可以用作 MatchData[] 的索引。

md = /\$(?<dollars>\d+)\.(?'cents'\d+)/.match("$3.67")
# => #<MatchData "$3.67" dollars:"3" cents:"67">
md[:dollars]  # => "3"
md[:cents]    # => "67"
# The capture numbers are still valid.
md[2]         # => "67"

当 regexp 包含命名捕获时，没有未命名的捕获。

/\$(?<dollars>\d+)\.(\d+)/.match("$3.67")
# => #<MatchData "$3.67" dollars:"3">

命名分组可以作为 \k<name> 进行反向引用。

/(?<vowel>[aeiou]).\k<vowel>.\k<vowel>/.match('ototomy')
# => #<MatchData "ototo" vowel:"o">

当（仅当）regexp 包含命名捕获组并出现在 =~ 运算符之前时，捕获的子字符串会被分配给具有相应名称的局部变量。

/\$(?<dollars>\d+)\.(?<cents>\d+)/ =~ '$3.67'
dollars # => "3"
cents   # => "67"

方法 Regexp#named_captures 返回一个捕获名称和子字符串的哈希；方法 Regexp#names 返回一个捕获名称的数组。

原子分组

分组可以通过 (?>subexpression) 设为原子。

这会导致子表达式独立于表达式的其余部分进行匹配，因此匹配的子字符串在剩余的匹配中是固定的，除非整个子表达式必须被放弃并随后重新访问。

通过这种方式，subexpression 被视为一个不可分割的整体。原子分组通常用于优化模式以防止不必要的回溯。

示例（无原子分组）

/".*"/.match('"Quote"') # => #<MatchData "\"Quote\"">

分析

模式中的前导子表达式 " 匹配目标字符串中的第一个字符 "。
下一个子表达式 .* 匹配下一个子字符串 Quote"（包括尾随的双引号）。
现在目标字符串中没有剩余内容可以匹配模式中的尾随子表达式 "；这将导致整体匹配失败。
匹配的子字符串回溯一个位置：Quote。
最后一个子表达式 " 现在匹配最后一个子字符串 "，并且整体匹配成功。

如果子表达式 .* 被原子分组，则回溯被禁用，并且整体匹配失败。

/"(?>.*)"/.match('"Quote"') # => nil

原子分组会影响性能；请参阅Atomic Group。

子表达式调用

如上所示，反向引用编号（\n）或名称（\k<name>）可以访问捕获的子字符串；相应的 regexp子表达式也可以通过编号（\gn）或名称（\g<name>）访问。

/\A(?<paren>\(\g<paren>*\))*\z/.match('(())')
# ^1
#      ^2
#           ^3
#                 ^4
#      ^5
#           ^6
#                      ^7
#                       ^8
#                       ^9
#                           ^10

模式

匹配字符串的开头，即第一个字符之前。
进入命名分组 paren。
匹配字符串中的第一个字符 '('。
再次调用 paren 分组，即递归回第二步。
重新进入 paren 分组。
匹配字符串中的第二个字符 '('。
尝试第三次调用 paren，但失败，因为这样做会阻止整体成功匹配。
匹配字符串中的第三个字符 ')'；标记第二次递归调用的结束。
匹配字符串中的第四个字符 ')'。
匹配字符串的末尾。

请参阅Subexpression calls。

条件语句

条件结构的形式为 (?(cond)yes|no)，其中：

cond 可以是捕获编号或名称。
如果捕获了 cond，则应用的匹配为 yes；否则，应用的匹配为 no。
如果不需要，可以省略 |no。

示例

re = /\A(foo)?(?(1)(T)|(F))\z/
re.match('fooT') # => #<MatchData "fooT" 1:"foo" 2:"T" 3:nil>
re.match('F')    # => #<MatchData "F" 1:nil 2:nil 3:"F">
re.match('fooF') # => nil
re.match('T')    # => nil

re = /\A(?<xyzzy>foo)?(?(<xyzzy>)(T)|(F))\z/
re.match('fooT') # => #<MatchData "fooT" xyzzy:"foo">
re.match('F')    # => #<MatchData "F" xyzzy:nil>
re.match('fooF') # => nil
re.match('T')    # => nil

缺失运算符

缺失运算符是一种特殊的分组，它匹配任何不匹配包含的子表达式的内容。

/(?~real)/.match('surrealist') # => #<MatchData "surrea">
/(?~real)ist/.match('surrealist') # => #<MatchData "ealist">
/sur(?~real)ist/.match('surrealist') # => nil

Unicode

Unicode 属性

/\p{property_name}/ 构造（小写 p）使用 Unicode 属性名称匹配字符，很像字符类；属性 Alpha 指定字母字符。

/\p{Alpha}/.match('a') # => #<MatchData "a">
/\p{Alpha}/.match('1') # => nil

可以通过在名称前加上插入符号字符（^）来反转属性。

/\p{^Alpha}/.match('1') # => #<MatchData "1">
/\p{^Alpha}/.match('a') # => nil

或者通过使用 \P（大写 P）。

/\P{Alpha}/.match('1') # => #<MatchData "1">
/\P{Alpha}/.match('a') # => nil

请参阅Unicode Properties，了解基于众多属性的 regexp。

一些常用的属性对应于 POSIX 方括号表达式。

/\p{Alnum}/：字母和数字字符。
/\p{Alpha}/：字母字符。
/\p{Blank}/：空格或制表符。
/\p{Cntrl}/：控制字符。
/\p{Digit}/：数字字符（及类似字符）。
/\p{Lower}/：小写字母字符。
/\p{Print}/：类似于 \p{Graph}，但包含空格字符。
/\p{Punct}/：标点字符。
/\p{Space}/：空白字符（[:blank:]、换行符、回车符等）。
/\p{Upper}/：大写字母。
/\p{XDigit}/：十六进制数字允许的数字（即 0-9a-fA-F）。

这些也经常使用：

/\p{Emoji}/：Unicode emoji。
/\p{Graph}/：除 /\p{Cntrl}/ 和 /\p{Space}/ 之外的字符。请注意，Unicode “Format”类别下的不可见字符也包含在内。
/\p{Word}/：属于以下 Unicode 字符类别之一（见下文）或具有以下 Unicode 属性的字符。
- Unicode 类别
  - Mark (M)。
  - Decimal Number (Nd)。
  - Connector Punctuation (Pc)。
- Unicode 属性
  - Alpha
  - Join_Control
/\p{ASCII}/：ASCII 字符集中的字符。
/\p{Any}/：任何 Unicode 字符（包括未分配的字符）。
/\p{Assigned}/：已分配的字符。

Unicode 字符类别

Unicode 字符类别名称

可以是其全名或其缩写名称。
不区分大小写。
将空格、连字符和下划线视为等效。

示例

/\p{lu}/                # => /\p{lu}/
/\p{LU}/                # => /\p{LU}/
/\p{Uppercase Letter}/  # => /\p{Uppercase Letter}/
/\p{Uppercase_Letter}/  # => /\p{Uppercase_Letter}/
/\p{UPPERCASE-LETTER}/  # => /\p{UPPERCASE-LETTER}/

以下是 Unicode 字符类别缩写和名称。每个类别的字符枚举可在链接中找到。

字母

L、Letter：LC、Lm 或 Lo。
LC、Cased_Letter：Ll、Lt 或 Lu。
Lu、Lowercase_Letter.
Lu、Modifier_Letter.
Lu、Other_Letter.
Lu、Titlecase_Letter.
Lu、Uppercase_Letter.

标记

M、Mark：Mc、Me 或 Mn。
Mc、Spacing_Mark.
Me、Enclosing_Mark.
Mn、Nonspacing_Mark.

数字

N、Number：Nd、Nl 或 No。
Nd、Decimal_Number.
Nl、Letter_Number.
No、Other_Number.

标点符号

P、Punctuation：Pc、Pd、Pe、Pf、Pi、Po 或 Ps。
Pc、Connector_Punctuation.
Pd、Dash_Punctuation.
Pe、Close_Punctuation.
Pf、Final_Punctuation.
Pi、Initial_Punctuation.
Po、Other_Punctuation.
Ps、Open_Punctuation.
S、Symbol：Sc、Sk、Sm 或 So。
Sc、Currency_Symbol.
Sk、Modifier_Symbol.
Sm、Math_Symbol.
So、Other_Symbol.
Z、Separator：Zl、Zp 或 Zs。
Zl、Line_Separator.
Zp、Paragraph_Separator.
Zs、Space_Separator.
C、Other：Cc、Cf、Cn、Co 或 Cs。
Cc、Control.
Cf、Format.
Cn、Unassigned.
Co、Private_Use.
Cs、Surrogate.

Unicode 脚本和块

Unicode 属性包括：

Unicode 脚本；请参阅支持的脚本。
Unicode 块；请参阅支持的块。

POSIX 方括号表达式

POSIX方括号表达式也类似于字符类。这些表达式提供了上述方法的便携式替代方案，并具有包含非 ASCII 字符的额外好处。

/\d/ 仅匹配 ASCII 数字 0 到 9。
/[[:digit:]]/ 匹配 Unicode Decimal Number (Nd) 类别中的任何字符；请参阅下文。

POSIX 方括号表达式

/[[:digit:]]/：匹配 Unicode 数字。

/[[:digit:]]/.match('9')       # => #<MatchData "9">
/[[:digit:]]/.match("\u1fbf9") # => #<MatchData "9">

/[[:xdigit:]]/：匹配十六进制数字允许的数字；等同于 [0-9a-fA-F]。

/[[:upper:]]/：匹配 Unicode 大写字母。

/[[:upper:]]/.match('A')      # => #<MatchData "A">
/[[:upper:]]/.match("\u00c6") # => #<MatchData "Æ">

/[[:lower:]]/：匹配 Unicode 小写字母。

/[[:lower:]]/.match('a')      # => #<MatchData "a">
/[[:lower:]]/.match("\u01fd") # => #<MatchData "ǽ">

/[[:alpha:]]/：匹配 /[[:upper:]]/ 或 /[[:lower:]]/。
/[[:alnum:]]/：匹配 /[[:alpha:]]/ 或 /[[:digit:]]/。

/[[:space:]]/：匹配 Unicode 空格字符。

/[[:space:]]/.match(' ')      # => #<MatchData " ">
/[[:space:]]/.match("\u2005") # => #<MatchData " ">

/[[:blank:]]/：匹配 /[[:space:]]/ 或制表符。

/[[:blank:]]/.match(' ')      # => #<MatchData " ">
/[[:blank:]]/.match("\u2005") # => #<MatchData " ">
/[[:blank:]]/.match("\t")     # => #<MatchData "\t">

/[[:cntrl:]]/：匹配 Unicode 控制字符。

/[[:cntrl:]]/.match("\u0000") # => #<MatchData "\u0000">
/[[:cntrl:]]/.match("\u009f") # => #<MatchData "\u009F">

/[[:graph:]]/：匹配除 /[[:space:]]/ 或 /[[:cntrl:]]/ 之外的任何字符。
/[[:print:]]/：匹配 /[[:graph:]]/ 或空格字符。
/[[:punct:]]/：匹配任何（Unicode 标点字符}[www.compart.com/en/unicode/category/Po]

Ruby 还支持以下（非 POSIX）方括号表达式：

/[[:ascii:]]/：ASCII 字符集中的字符。
/[[:word:]]/：属于以下 Unicode 字符类别之一或具有以下 Unicode 属性的字符。
- Unicode 类别
  - Mark (M)。
  - Decimal Number (Nd)。
  - Connector Punctuation (Pc)。
- Unicode 属性
  - Alpha
  - Join_Control

Comments

可以使用 (?#comment) 构造在 regexp 模式中包含注释，其中 comment 是要忽略的子字符串。regexp 引擎会忽略任意文本。

/foo(?#Ignore me)bar/.match('foobar') # => #<MatchData "foobar">

注释不能包含未转义的终止符字符。

另请参阅Extended Mode。

模式

以下每个修饰符都会为 regexp 设置一个模式。

i：/pattern/i 设置不区分大小写模式。
m：/pattern/m 设置多行模式。
x：/pattern/x 设置扩展模式。
o：/pattern/o 设置插值模式。

这些可以全部、部分或都不应用。

修饰符 i、m 和 x 可以应用于子表达式。

(?modifier) 将模式“打开”用于后续子表达式。
(?-modifier) 将模式“关闭”用于后续子表达式。
(?modifier:subexp) 将模式“打开”用于分组内的 subexp。
(?-modifier:subexp) 将模式“关闭”用于分组内的 subexp。

示例

re = /(?i)te(?-i)st/
re.match('test') # => #<MatchData "test">
re.match('TEst') # => #<MatchData "TEst">
re.match('TEST') # => nil
re.match('teST') # => nil

re = /t(?i:e)st/
re.match('test') # => #<MatchData "test">
re.match('tEst') # => #<MatchData "tEst">
re.match('tEST') # => nil

方法 Regexp#options 返回一个整数，其值显示不区分大小写模式、多行模式和扩展模式的设置。

不区分大小写模式

默认情况下，regexp 是区分大小写的。

/foo/.match('FOO')  # => nil

修饰符 i 启用不区分大小写模式。

/foo/i.match('FOO')
# => #<MatchData "FOO">

方法 Regexp#casefold? 返回该模式是否不区分大小写。

多行模式

Ruby 中的多行模式就是通常所说的“dot-all 模式”。

如果没有 m 修饰符，子表达式 . 不匹配换行符。
```
/a.c/.match("a\nc")  # => nil
```

有了修饰符，它就能匹配。

/a.c/m.match("a\nc") # => #<MatchData "a\nc">

与其他语言不同，修饰符 m 不影响锚点 ^ 和 $。在 Ruby 中，这些锚点始终在行边界处匹配。

扩展模式

修饰符 x 启用扩展模式，这意味着：

模式中的字面空白字符将被忽略。
字符 # 将其包含行中的其余部分标记为注释，该注释也将被忽略以进行匹配。

在扩展模式下，可以使用空白和注释来形成自文档化的 regexp。

未处于扩展模式的Regexp（匹配某些罗马数字）。

pattern = '^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$'
re = /#{pattern}/
re.match('MCMXLIII') # => #<MatchData "MCMXLIII" 1:"CM" 2:"XL" 3:"III">

处于扩展模式的Regexp。

pattern = <<-EOT
  ^                   # beginning of string
  M{0,3}              # thousands - 0 to 3 Ms
  (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 Cs),
                      #            or 500-800 (D, followed by 0 to 3 Cs)
  (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 Xs),
                      #        or 50-80 (L, followed by 0 to 3 Xs)
  (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 Is),
                      #        or 5-8 (V, followed by 0 to 3 Is)
  $                   # end of string
EOT
re = /#{pattern}/x
re.match('MCMXLIII') # => #<MatchData "MCMXLIII" 1:"CM" 2:"XL" 3:"III">

插值模式

修饰符 o 表示，当第一次遇到带有插值的字面量 regexp 时，生成的 Regexp 对象会被保存并用于该字面量 regexp 的所有未来评估。没有修饰符 o，生成的 Regexp 不会被保存，因此每次对字面量 regexp 的评估都会生成一个新的 Regexp 对象。

没有修饰符 o

def letters; sleep 5; /[A-Z][a-z]/; end
words = %w[abc def xyz]
start = Time.now
words.each {|word| word.match(/\A[#{letters}]+\z/) }
Time.now - start # => 15.0174892

带有修饰符 o

start = Time.now
words.each {|word| word.match(/\A[#{letters}]+\z/o) }
Time.now - start # => 5.0010866

请注意，如果字面量 regexp 没有插值，则 o 的行为是默认行为。

编码

默认情况下，仅包含 US-ASCII 字符的 regexp 具有 US-ASCII 编码。

re = /foo/
re.source.encoding # => #<Encoding:US-ASCII>
re.encoding        # => #<Encoding:US-ASCII>

包含非 US-ASCII 字符的正则表达式假定使用源编码。这可以用以下修饰符之一覆盖。

/pat/n：如果仅包含 US-ASCII 字符，则为 US-ASCII，否则为 ASCII-8BIT。

/foo/n.encoding     # => #<Encoding:US-ASCII>
/foo\xff/n.encoding # => #<Encoding:ASCII-8BIT>
/foo\x7f/n.encoding # => #<Encoding:US-ASCII>

/pat/u：UTF-8。
```
/foo/u.encoding # => #<Encoding:UTF-8>
```

/pat/e：EUC-JP。

/foo/e.encoding # => #<Encoding:EUC-JP>

/pat/s：Windows-31J。

/foo/s.encoding # => #<Encoding:Windows-31J>

当以下任一条件满足时，regexp 可以与目标字符串匹配：

它们具有相同的编码。
Regexp 的编码是固定编码，并且字符串仅包含 ASCII 字符。方法 Regexp#fixed_encoding? 返回 regexp 是否具有固定编码。

如果尝试不兼容编码的匹配，则会引发 Encoding::CompatibilityError 异常。

示例

re = eval("# encoding: ISO-8859-1\n/foo\\xff?/")
re.encoding                 # => #<Encoding:ISO-8859-1>
re =~ "foo".encode("UTF-8") # => 0
re =~ "foo\u0100"           # Raises Encoding::CompatibilityError

可以通过在 Regexp.new 的第二个参数中包含 Regexp::FIXEDENCODING 来显式固定编码。

# Regexp with encoding ISO-8859-1.
re = Regexp.new("a".force_encoding('iso-8859-1'), Regexp::FIXEDENCODING)
re.encoding  # => #<Encoding:ISO-8859-1>
# Target string with encoding UTF-8.
s = "a\u3042"
s.encoding   # => #<Encoding:UTF-8>
re.match(s)  # Raises Encoding::CompatibilityError.

超时

当 regexp 源或目标字符串来自不受信任的输入时，恶意值可能导致拒绝服务攻击；为防止此类攻击，设置超时是明智的。

Regexp 有两个超时值：

一个类默认超时，用于实例超时为 nil 的 regexp；此默认值最初为 nil，可以通过方法 Regexp.timeout= 设置。
```
Regexp.timeout # => nil
Regexp.timeout = 3.0
Regexp.timeout # => 3.0
```
一个实例超时，默认值为 nil，可以在 Regexp.new 中设置。
```
re = Regexp.new('foo', timeout: 5.0)
re.timeout # => 5.0
```

当 regexp.timeout 为 nil 时，超时会“贯穿”到 Regexp.timeout；当 regexp.timeout 非 nil 时，该值控制超时。

| regexp.timeout Value | Regexp.timeout Value |            Result           |
|----------------------|----------------------|-----------------------------|
|         nil          |          nil         |       Never times out.      |
|         nil          |         Float        | Times out in Float seconds. |
|        Float         |          Any         | Times out in Float seconds. |

优化

对于模式和目标字符串的某些值，匹配时间会相对于输入大小呈多项式或指数级增长；由此产生的潜在漏洞是正则表达式拒绝服务（ReDoS）攻击。

Regexp 匹配可以应用优化来防止 ReDoS 攻击。当应用优化时，匹配时间相对于输入大小呈线性增长（而不是多项式或指数级），并且不会发生 ReDoS 攻击。

如果模式满足以下条件，则应用此优化：

没有反向引用。
没有子表达式调用。
没有嵌套环视锚点或原子分组。
没有嵌套的计数量词（即没有嵌套的 {n}、{min,}、{,max} 或 {min,max} 样式的量词）。

您可以使用方法 Regexp.linear_time? 来确定模式是否满足这些条件。

Regexp.linear_time?(/a*/)     # => true
Regexp.linear_time?('a*')     # => true
Regexp.linear_time?(/(a*)\1/) # => false

但是，即使该方法返回 true，不受信任的源也可能不安全，因为优化使用了记忆化（这可能会导致大量内存消耗）。

参考

阅读

Jeffrey E.F. Friedl 的Mastering Regular Expressions。
Jan Goyvaerts & Steven Levithan 的Regular Expressions Cookbook。

探索，测试

Rubular：交互式在线编辑器。

Constants

EXTENDED: 请参阅Regexp.options 和 Regexp.new。
FIXEDENCODING: 请参阅Regexp.options 和 Regexp.new。
IGNORECASE: 请参阅Regexp.options 和 Regexp.new。
MULTILINE: 请参阅Regexp.options 和 Regexp.new。
NOENCODING: 请参阅Regexp.options 和 Regexp.new。

Public Class Methods

compile (*args)

方法 Regexp.new 的别名。

escape(string) → new_string

Source

static VALUE
rb_reg_s_quote(VALUE c, VALUE str)
{
    return rb_reg_quote(reg_operand(str, TRUE));
}

返回一个新字符串，该字符串转义了在正则表达式中具有特殊含义的任何字符。

s = Regexp.escape('\*?{}.')      # => "\\\\\\*\\?\\{\\}\\."

对于任何字符串 s，此调用将返回一个 MatchData 对象。

r = Regexp.new(Regexp.escape(s)) # => /\\\\\\\*\\\?\\\{\\\}\\\./
r.match(s)                       # => #<MatchData "\\\\\\*\\?\\{\\}\\.">

json_create (object)

Source

# File ext/json/lib/json/add/regexp.rb, line 9
def self.json_create(object)
  new(object['s'], object['o'])
end

请参阅as_json。

last_match → matchdata or nil

last_match(n) → string or nil

last_match(name) → string or nil

Source

static VALUE
rb_reg_s_last_match(int argc, VALUE *argv, VALUE _)
{
    if (rb_check_arity(argc, 0, 1) == 1) {
        VALUE match = rb_backref_get();
        int n;
        if (NIL_P(match)) return Qnil;
        n = match_backref_number(match, argv[0]);
        return rb_reg_nth_match(n, match);
    }
    return match_getter();
}

不带参数时，返回 $~ 的值，这是最近一次模式匹配的结果（请参阅Regexp 全局变量）。

/c(.)t/ =~ 'cat'  # => 0
Regexp.last_match # => #<MatchData "cat" 1:"a">
/a/ =~ 'foo'      # => nil
Regexp.last_match # => nil

使用非负整数参数 n，返回 matchdata 中的第 _n_ 个字段（如果有），否则返回 nil。

/c(.)t/ =~ 'cat'     # => 0
Regexp.last_match(0) # => "cat"
Regexp.last_match(1) # => "a"
Regexp.last_match(2) # => nil

使用负整数参数 n，从最后一个字段开始倒数。

Regexp.last_match(-1)       # => "a"

使用字符串或符号参数 name，返回命名捕获的字符串值（如果有）。

/(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ 'var = val'
Regexp.last_match        # => #<MatchData "var = val" lhs:"var"rhs:"val">
Regexp.last_match(:lhs)  # => "var"
Regexp.last_match('rhs') # => "val"
Regexp.last_match('foo') # Raises IndexError.

linear_time?(re)

linear_time?(string, options = 0)

Source

static VALUE
rb_reg_s_linear_time_p(int argc, VALUE *argv, VALUE self)
{
    struct reg_init_args args;
    VALUE re = reg_extract_args(argc, argv, &args);

    if (NIL_P(re)) {
        re = reg_init_args(rb_reg_alloc(), args.str, args.enc, args.flags);
    }

    return RBOOL(onig_check_linear_time(RREGEXP_PTR(re)));
}

当针对 re 进行匹配时，返回 true，表示匹配可以在相对于输入字符串的线性时间内完成。

Regexp.linear_time?(/re/) # => true

请注意，这是 Ruby 解释器的属性，而不是参数正则表达式的属性。相同的 regexp 可能或可能无法在线性时间内运行，这取决于您的 Ruby 二进制文件。不能保证此方法的返回值具有向前或向后的兼容性。我们当前的算法是（*1），但这可能会在未来发生变化。替代实现也可能表现不同。它们可能总是对所有内容返回 false。

(*1)：doi.org/10.1109/SP40001.2021.00032

new(string, options = 0, timeout: nil) → regexp

new(regexp, timeout: nil) → regexp

Source

static VALUE
rb_reg_initialize_m(int argc, VALUE *argv, VALUE self)
{
    struct reg_init_args args;
    VALUE re = reg_extract_args(argc, argv, &args);

    if (NIL_P(re)) {
        reg_init_args(self, args.str, args.enc, args.flags);
    }
    else {
        reg_copy(self, re);
    }

    set_timeout(&RREGEXP_PTR(self)->timelimit, args.timeout);

    return self;
}

当参数是 string 时，返回一个具有给定字符串和选项的新正则表达式。

r = Regexp.new('foo') # => /foo/
r.source              # => "foo"
r.options             # => 0

可选参数 options 是以下之一：

一个选项的 String。

Regexp.new('foo', 'i')  # => /foo/i
Regexp.new('foo', 'im') # => /foo/im

一个或多个常量 Regexp::EXTENDED、Regexp::IGNORECASE、Regexp::MULTILINE 和 Regexp::NOENCODING 的位或运算。

Regexp.new('foo', Regexp::IGNORECASE) # => /foo/i
Regexp.new('foo', Regexp::EXTENDED)   # => /foo/x
Regexp.new('foo', Regexp::MULTILINE)  # => /foo/m
Regexp.new('foo', Regexp::NOENCODING)  # => /foo/n
flags = Regexp::IGNORECASE | Regexp::EXTENDED |  Regexp::MULTILINE
Regexp.new('foo', flags)              # => /foo/mix

nil 或 false，将被忽略。
任何其他真值，在这种情况下，正则表达式将不区分大小写。

如果提供了可选关键字参数 timeout，其浮点值将覆盖类 Regexp.timeout 的超时间隔。如果将 nil 作为 +timeout 传递，则使用类 Regexp.timeout 的超时间隔。

当参数是 regexp 时，返回一个新的正则表达式。源、选项、超时与 regexp 相同。options 和 n_flag 参数无效。超时可以通过 timeout 关键字覆盖。

options = Regexp::MULTILINE
r = Regexp.new('foo', options, timeout: 1.1) # => /foo/m
r2 = Regexp.new(r)                           # => /foo/m
r2.timeout                                   # => 1.1
r3 = Regexp.new(r, timeout: 3.14)            # => /foo/m
r3.timeout                                   # => 3.14

escape(string) → new_string

Source

static VALUE
rb_reg_s_quote(VALUE c, VALUE str)
{
    return rb_reg_quote(reg_operand(str, TRUE));
}

返回一个新字符串，该字符串转义了在正则表达式中具有特殊含义的任何字符。

s = Regexp.escape('\*?{}.')      # => "\\\\\\*\\?\\{\\}\\."

对于任何字符串 s，此调用将返回一个 MatchData 对象。

r = Regexp.new(Regexp.escape(s)) # => /\\\\\\\*\\\?\\\{\\\}\\\./
r.match(s)                       # => #<MatchData "\\\\\\*\\?\\{\\}\\.">

timeout → float or nil

Source

static VALUE
rb_reg_s_timeout_get(VALUE dummy)
{
    double d = hrtime2double(rb_reg_match_time_limit);
    if (d == 0.0) return Qnil;
    return DBL2NUM(d);
}

它返回当前 Regexp 匹配的默认超时间隔（以秒为单位）。nil 表示没有默认超时配置。

timeout = float or nil

Source

static VALUE
rb_reg_s_timeout_set(VALUE dummy, VALUE timeout)
{
    rb_ractor_ensure_main_ractor("can not access Regexp.timeout from non-main Ractors");

    set_timeout(&rb_reg_match_time_limit, timeout);

    return timeout;
}

它设置 Regexp 匹配的默认超时间隔（以秒为单位）。nil 表示没有默认超时配置。此配置是进程全局的。如果您想为每个 Regexp 设置超时，请使用 Regexp.new 的 timeout 关键字。

Regexp.timeout = 1
/^a*b?a*$/ =~ "a" * 100000 + "x" #=> regexp match timeout (RuntimeError)

try_convert(object) → regexp or nil

Source

static VALUE
rb_reg_s_try_convert(VALUE dummy, VALUE re)
{
    return rb_check_regexp_type(re);
}

如果 object 是一个正则表达式，则返回 object。

Regexp.try_convert(/re/) # => /re/

否则，如果 object 响应 :to_regexp，则调用 object.to_regexp 并返回结果。

如果 object 不响应 :to_regexp，则返回 nil。

Regexp.try_convert('re') # => nil

除非 object.to_regexp 返回一个正则表达式，否则会引发异常。

union(*patterns) → regexp

union(array_of_patterns) → regexp

Source

static VALUE
rb_reg_s_union_m(VALUE self, VALUE args)
{
    VALUE v;
    if (RARRAY_LEN(args) == 1 &&
        !NIL_P(v = rb_check_array_type(rb_ary_entry(args, 0)))) {
        return rb_reg_s_union(self, v);
    }
    return rb_reg_s_union(self, args);
}

返回一个表示给定模式的并集的新的正则表达式。

r = Regexp.union(%w[cat dog])      # => /cat|dog/
r.match('cat')      # => #<MatchData "cat">
r.match('dog')      # => #<MatchData "dog">
r.match('cog')      # => nil

对于每个是字符串的模式，使用 Regexp.new(pattern)。

Regexp.union('penzance')             # => /penzance/
Regexp.union('a+b*c')                # => /a\+b\*c/
Regexp.union('skiing', 'sledding')   # => /skiing|sledding/
Regexp.union(['skiing', 'sledding']) # => /skiing|sledding/

对于每个是正则表达式的模式，原样使用它，包括其标志。

Regexp.union(/foo/i, /bar/m, /baz/x)
# => /(?i-mx:foo)|(?m-ix:bar)|(?x-mi:baz)/
Regexp.union([/foo/i, /bar/m, /baz/x])
# => /(?i-mx:foo)|(?m-ix:bar)|(?x-mi:baz)/

没有参数时，返回 /(?!)/。

Regexp.union # => /(?!)/

如果任何正则表达式模式包含捕获组，则行为未定义。

Public Instance Methods

regexp == object → true or false

如果 object 是另一个正则表达式，其模式、标志和编码与 self 相同，则返回 true，否则返回 false。

/foo/ == Regexp.new('foo')                          # => true
/foo/ == /foo/i                                     # => false
/foo/ == Regexp.new('food')                         # => false
/foo/ == Regexp.new("abc".force_encoding("euc-jp")) # => false

的别名：eql?

regexp === string → true or false

Source

static VALUE
rb_reg_eqq(VALUE re, VALUE str)
{
    long start;

    str = reg_operand(str, FALSE);
    if (NIL_P(str)) {
        rb_backref_set(Qnil);
        return Qfalse;
    }
    start = rb_reg_search(re, str, 0, 0);
    return RBOOL(start >= 0);
}

如果 self 在 string 中找到匹配项，则返回 true。

/^[a-z]*$/ === 'HELLO' # => false
/^[A-Z]*$/ === 'HELLO' # => true

此方法在 case 语句中调用。

s = 'HELLO'
case s
when /\A[a-z]*\z/; print "Lower case\n"
when /\A[A-Z]*\z/; print "Upper case\n"
else               print "Mixed case\n"
end # => "Upper case"

regexp =~ string → integer or nil

Source

VALUE
rb_reg_match(VALUE re, VALUE str)
{
    long pos = reg_match_pos(re, &str, 0, NULL);
    if (pos < 0) return Qnil;
    pos = rb_str_sublen(str, pos);
    return LONG2FIX(pos);
}

返回 self 和 string 第一个匹配项的索引（以字符为单位），如果没有匹配项则返回 nil；同时设置 Regexp 全局变量。

/at/ =~ 'input data' # => 7
$~                   # => #<MatchData "at">
/ax/ =~ 'input data' # => nil
$~                   # => nil

当且仅当 self 是正则表达式字面量时，将命名的捕获组分配给同名的局部变量；请参阅 Regexp 字面量。

是正则表达式字面量；请参阅 Regexp 字面量。
不包含插值；请参阅 Regexp 插值。
位于表达式的左侧。

示例

/(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ '  x = y  '
p lhs # => "x"
p rhs # => "y"

如果未匹配，则赋值为 nil。

/(?<lhs>\w+)\s*=\s*(?<rhs>\w+)/ =~ '  x = '
p lhs # => nil
p rhs # => nil

如果 self 不是正则表达式字面量，则不进行局部变量赋值。

r = /(?<foo>\w+)\s*=\s*(?<foo>\w+)/
r =~ '  x = y  '
p foo # Undefined local variable
p bar # Undefined local variable

如果正则表达式不在左侧，则不发生赋值。

'  x = y  ' =~ /(?<foo>\w+)\s*=\s*(?<foo>\w+)/
p foo, foo # Undefined local variables

正则表达式插值 #{} 也会禁用赋值。

r = /(?<foo>\w+)/
/(?<foo>\w+)\s*=\s*#{r}/ =~ 'x = y'
p foo # Undefined local variable

~ rxp → integer or nil

Source

VALUE
rb_reg_match2(VALUE re)
{
    long start;
    VALUE line = rb_lastline_get();

    if (!RB_TYPE_P(line, T_STRING)) {
        rb_backref_set(Qnil);
        return Qnil;
    }

    start = rb_reg_search(re, line, 0, 0);
    if (start < 0) {
        return Qnil;
    }
    start = rb_str_sublen(line, start);
    return LONG2FIX(start);
}

等同于 rxp =~ $_。

$_ = "input data"
~ /at/ # => 7

as_json (*)

Source

# File ext/json/lib/json/add/regexp.rb, line 28
def as_json(*)
  {
    JSON.create_id => self.class.name,
    'o'            => options,
    's'            => source,
  }
end

可以使用方法 Regexp#as_json 和 Regexp.json_create 来序列化和反序列化 Regexp 对象；请参阅 Marshal。

方法 Regexp#as_json 序列化 self，返回一个表示 self 的两元素哈希。

require 'json/add/regexp'
x = /foo/.as_json
# => {"json_class"=>"Regexp", "o"=>0, "s"=>"foo"}

方法 JSON.create 反序列化这样的哈希，返回一个 Regexp 对象。

Regexp.json_create(x) # => /foo/

casefold?→ true or false

Source

static VALUE
rb_reg_casefold_p(VALUE re)
{
    rb_reg_check(re);
    return RBOOL(RREGEXP_PTR(re)->options & ONIG_OPTION_IGNORECASE);
}

如果 self 中的不区分大小写标志已设置，则返回 true，否则返回 false。

/a/.casefold?           # => false
/a/i.casefold?          # => true
/(?i:a)/.casefold?      # => false

encoding → encoding

Source

VALUE
rb_obj_encoding(VALUE obj)
{
    int idx = rb_enc_get_index(obj);
    if (idx < 0) {
        rb_raise(rb_eTypeError, "unknown encoding");
    }
    return rb_enc_from_encoding_index(idx & ENC_INDEX_MASK);
}

返回一个代表 self 编码的 Encoding 对象；请参阅 Encodings。