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
  

  参见部分 方法 match 和 运算符 =~.

• 确定字符串是否匹配给定模式

  re.match?('food') # => true
  re.match?('good') # => false
  

  参见 Method match? 部分。

• 作为其他类和模块中某些方法调用的参数；大多数此类方法接受一个参数，该参数可以是字符串，也可以是（更强大的）正则表达式。

  参见 Regexp Methods。

Regexp 对象¶ ↑

一个正则表达式对象具有

• 一个源代码；参见 Sources。

• 几种模式；参见 Modes。

• 一个超时；参见 Timeouts。

• 一个编码；参见 Encodings。

创建正则表达式¶ ↑

可以使用以下方法创建正则表达式

• 使用斜杠字符的正则表达式字面量（参见 Regexp Literals）

  # This is a very common usage.
  /foo/ # => /foo/
  

• %r 正则表达式字面量（参见 %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

全局变量¶ ↑

某些与正则表达式相关的函数会为全局变量赋值

• #match：参见 Method match。

• #=~：参见 Operator =~。

受影响的全局变量是

• $~: 返回一个 MatchData 对象，或 nil。

• $&: 返回字符串中匹配的部分，或 nil。

• $`: 返回匹配左侧的字符串部分，或 nil。

• $': 返回匹配右侧的字符串部分，或 nil。

• $+: 返回最后一个匹配的组，或 nil。

• $1, $2 等：返回第一个、第二个等匹配的组，或 nil。请注意，$0 非常不同；它返回当前正在执行的程序的名称。

示例

# 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? 不会设置全局变量。

来源¶ ↑

如上所示，最简单的正则表达式使用文字表达式作为其来源

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

丰富的可用子表达式集合赋予正则表达式强大的功能和灵活性

• 特殊字符

• 源文字

• 字符类

• 简写字符类

• 锚点

• 选择

• 量词

• 组和捕获

• Unicode

• POSIX 方括号表达式

• 注释

特殊字符¶ ↑

正则表达式特殊字符，称为元字符，在某些上下文中具有特殊含义；根据上下文，这些有时是元字符

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

要匹配文字元字符，请使用反斜杠转义它

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

要匹配文字反斜杠，请使用反斜杠转义它

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

Method Regexp.escape 返回一个转义的字符串

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

源文字¶ ↑

源文字在很大程度上表现得像双引号字符串；参见 字符串文字。

特别是，源文字可以包含插值表达式

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

普通字符串文字和源文字之间存在差异；参见 简写字符类。

• 普通字符串文字中的 \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：匹配任何字符，包括换行符；参见 多行模式

  /./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">

匹配重置锚点¶ ↑

• \K: 匹配重置：正则表达式中 \K 之前的匹配内容将从结果中排除。例如，以下两个正则表达式几乎等效

  /ab\Kc/.match('abc')    # => #<MatchData "c">
  /(?<=ab)c/.match('abc') # => #<MatchData "c">
  

  它们匹配相同的字符串，并且 $& 等于 'c'，但匹配位置不同。

  以下两个正则表达式也是如此

  /(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 提供了一种方便的方法来构建具有备选的正则表达式。

量词¶ ↑

一个简单的正则表达式匹配一个字符

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

添加的量词指定了需要或允许的匹配次数

• * - 匹配零次或多次

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

• + - 匹配一次或多次

  /\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}及其变体不支持占有匹配。

更多

• 关于贪婪和懒惰匹配，请参见 选择最小或最大重复。

• 关于占有匹配，请参见 消除不必要的回溯。

组和捕获¶ ↑

一个简单的正则表达式最多只有一个匹配项

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">

反向引用¶ ↑

正则表达式本身也可以引用组匹配；这种引用被称为反向引用。

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

此表显示了上述正则表达式中的每个子表达式如何与目标字符串中的子字符串匹配。

| 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'          |

正则表达式可以包含任意数量的组。

• 对于大量的组。

  • 普通的\n符号仅适用于n在范围(1..9)内。

  • MatchData[n]符号适用于任何非负n。

• \0是一个特殊的反向引用，它指的是整个匹配的字符串；它不能在正则表达式本身中使用，但可以在正则表达式之外使用（例如，在替换方法调用中）。

  '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"

当正则表达式包含命名捕获时，没有未命名的捕获。

/\$(?<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">

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

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

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

原子分组¶ ↑

可以使用(?>subexpression)使组成为原子。

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

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

示例（没有原子分组）

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

分析

1. 模式中的前导子表达式"匹配目标字符串中的第一个字符"。

2. 下一个子表达式.*匹配下一个子字符串Quote“（包括尾部的双引号）。

3. 现在目标字符串中没有剩余的内容来匹配模式中的尾随子表达式"；这将导致整体匹配失败。

4. 匹配的子字符串向后回溯一个位置：Quote。

5. 最终的子表达式"现在匹配最终的子字符串"，并且整体匹配成功。

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

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

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

子表达式调用¶ ↑

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

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

模式

1. 在字符串的开头匹配，即第一个字符之前。

2. 进入名为paren的命名组。

3. 匹配字符串中的第一个字符，'('。

4. 再次调用paren组，即递归回到第二步。

5. 重新进入paren组。

6. 匹配字符串中的第二个字符，'('。

7. 尝试第三次调用paren，但失败，因为这样做会阻止整体匹配成功。

8. 匹配字符串中的第三个字符，')'；标记第二次递归调用的结束。

9. 匹配字符串中的第四个字符，')'。

10. 匹配字符串的结尾。

请参阅子表达式调用。

条件¶ ↑

条件结构采用(?(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 属性。

一些常用的属性对应于 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 表情符号。

• /\p{Graph}/：非空白字符（不包括空格、控制字符等）。

• /\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，标题字母.

• Lu，大写字母.

标记

• M，Mark：Mc，Me，或 Mn。

• Mc，间隔标记.

• Me，封闭标记.

• Mn，非间隔标记.

数字

• N，Number：Nd，Nl，或 No。

• Nd，十进制数字.

• Nl，字母数字.

• No，其他数字.

标点符号

• P，Punctuation：Pc，Pd，Pe，Pf，Pi，Po，或 Ps。

• Pc，连接标点符号.

• Pd，破折号标点符号.

• Pe，闭合标点符号.

• Pf，最终标点符号.

• Pi，初始标点符号.

• Po，其他标点符号.

• Ps，打开标点符号.

• S，Symbol：Sc，Sk，Sm，或 So。

• Sc，货币符号.

• Sk，修饰符符号.

• Sm，数学符号.

• So，其他符号.

• Z，Separator：Zl，Zp，或 Zs。

• Zl，行分隔符.

• Zp，段落分隔符.

• Zs，空格分隔符.

• C，Other：Cc，Cf，Cn，Co，或 Cs。

• Cc，控制.

• Cf，格式.

• Cn，未分配.

• Co，专用使用.

• Cs，代理.

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

注释¶ ↑

可以使用 (?#注释) 结构在正则表达式模式中包含注释，其中 注释 是要忽略的子字符串。正则表达式引擎忽略的任意文本

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

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

另请参阅 扩展模式。

模式¶ ↑

这些修饰符中的每一个都为正则表达式设置一个模式

• 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 返回一个整数，其值表示大小写不敏感模式、多行模式和扩展模式的设置。

大小写不敏感模式¶ ↑

默认情况下，正则表达式区分大小写

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

修饰符 i 启用大小写不敏感模式

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

方法 Regexp#casefold? 返回模式是否为大小写不敏感。

多行模式¶ ↑

Ruby 中的多行模式通常称为“点全模式”

• 没有 m 修饰符，子表达式 . 不会匹配换行符

  /a.c/.match("a\nc")  # => nil
  

• 使用修饰符，它会匹配

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

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

扩展模式¶ ↑

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

• 模式中的文字空格将被忽略。

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

在扩展模式下，空格和注释可用于形成自文档正则表达式。

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 对象将被保存并用于该文字正则表达式的所有未来评估。没有修饰符 o，生成的 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

请注意，如果文字正则表达式没有插值，则 o 行为是默认行为。

编码¶ ↑

默认情况下，仅包含 US-ASCII 字符的正则表达式具有 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>
  

当满足以下条件之一时，正则表达式可以与目标字符串匹配：

• 它们具有相同的编码。

• 正则表达式的编码是固定编码，并且字符串仅包含 ASCII 字符。 Method Regexp#fixed_encoding? 返回正则表达式是否具有固定编码。

如果尝试在不兼容的编码之间进行匹配，则会引发 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.

超时¶ ↑

当正则表达式源或目标字符串来自不受信任的输入时，恶意值可能会成为拒绝服务攻击；为了防止此类攻击，明智的做法是设置超时。

正则表达式有两个超时值

• 类默认超时，用于实例超时为 nil 的正则表达式；此默认值最初为 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) 攻击。

正则表达式匹配可以应用优化来防止 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，来自不受信任来源的模式也不一定是安全的，因为优化使用了记忆化（这可能会导致大量内存消耗）。

参考¶ ↑

阅读（在线 PDF 书籍）

• 精通正则表达式 由 Jeffrey E.F. Friedl 撰写。

• 正则表达式手册 由 Jan Goyvaerts 和 Steven Levithan 撰写。

探索，测试（交互式在线编辑器）

• Rubular.