后向引用
字符簇 下面是 ruby 支持的正则表达式符号（元字符）一览表。


不带 \ 的字母和数字不是元字符
带 \ 的符号不是元字符 有如此规则。


^
行首。匹配输入字符串头部或换行符之后的位置。

$
行尾。匹配输入字符串尾部或换行符之前的位置。
p "\n".gsub(/$/, "o") # => "o\no"

.
匹配除换行符之外的任何单个字符（多字节字符的话就不是一个字节而是一个字符）。使用正则表达式选项 m（多行模式。参考正则表达式字面值），则可以匹配含有换行符在内的任意单个字符。
p /./e =~ " あ "[0,1] # => nil

\w
匹配包括下划线的任何字母数字字符。等同于[0-9A-Za-z_]。
中文的全角字符也匹配。

\W
匹配任何非字母数字字符。\w 以外的字符。

\s
匹配任何空字符，包括空格、制表符、换页符等等。等同于[ \t\n\r\f\v]。

\S
匹配任何非空字符。[ \t\n\r\f\v]以外的字符。

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

\D
匹配一个非数字字符。

\A
匹配字符串头部。和 ^ 不同，换行对其无影响。

\Z
匹配字符串尾部。字符串以换行结束的话则匹配换行之前的位置。
p "\n".gsub(/\Z/, "o") # => "o\no"

\z
匹配字符串尾部。与 $ 和 \Z 不同的是换行对其无影响。

\b
匹配字符类指定的单词边界（匹配 \w 和 \W 之间），也就是指单词和空格间的位置。字符类指定为退格符（0x08）。例如，'er\b' 可以匹配 "never" 中的 'er'，但不能匹配 "verb" 中的 'er'。

\B
匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。

\cx
匹配由 x 指明的控制字符。例如，\cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 'c' 字符。

\f
匹配一个换页符。等同于 \x0c 和 \cL。

\n
匹配一个换行符。等同于 \x0a 和 \cJ。

\r
匹配一个回车符。等同于 \x0d 和 \cM。

\t
匹配一个制表符。等同于 \x09 和 \cI。

\v
匹配一个垂直制表符。等同于 \x0b 和 \cK。

\xn
匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，'\x41' 匹配 "A"。'\x041' 则等同于 '\x04' & "1"。正则表达式中可以使用 ASCII 编码。

\num
匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，'(.)\1' 匹配两个连续的相同字符。

\n
标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。

\nm
标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。

\nml
如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。

\un
匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如，\u00A9 匹配版权符号 (?)。

\G
在上次成功匹配的地方（之后）进行匹配（不留间隔）。只有在首次使用时才会匹配到头部（与 \A 相同）。
可以在 scan 和 gsub 中使用。当您想在上次匹配的地方之后再进行匹配的话，可以使用。
# 从头取出 3 位数字（数字必须相连）。 str = "123456 789" str.scan(/\G\d\d\d/) {|m| p m }

[ ]
指定字符簇。请参考字符簇。

*
匹配前面的子表达式零次或多次。尽可能匹配较长的部分。例如，zo* 能匹配 "z" 以及 "zoo"。* 等同于{0,}。

*?
负责指定数量（quantifiers）。表示前面子表达式至少出现零次（尽量匹配短的部分）。

+
负责指定数量（quantifiers）。表示前面子表达式至少出现 1 次

+?
负责指定数量（quantifiers）。表示前面子表达式至少出现 1 次（尽量匹配短的部分）。

{m}
{m,}
{m,n}
指定子表达式重复出现的次数（interval quantifier）。分别表示前面子表达式重复出现


m 次
至少 m 次
至少 m 次，至多 n 次 {,n} 或 {,} 将导致匹配失败。
str = "foofoofoo" p str[/(foo){1}/] # => "foo" p str[/(foo){2,}/] # => "foofoofoo" p str[/(foo){1,2}/] # => "foofoo"
正则表达式 ?、*、+ 分别等同于 {0,1}、{0,}、{1,}。

{m}?
{m,}?
{m,n}?
指定子表达式重复出现的次数（interval quantifier）。分别表示前面子表达式重复出现


m 次
至少 m 次
m 回以上、最大 n 回 （尽量匹配短的部分）。

?
负责指定数量（quantifiers）。表示前面子表达式至多出现 1 次。

??
负责指定数量（quantifiers）。表示前面子表达式至多出现 1 次（尽量匹配短的部分）。

|
选择（alternative）。

( )
正则表达式的群组化。与括号中的正则表达式相匹配的字符串将被保存下来，供后向引用使用。

\1, \2 ... \n
后向引用（back reference）。请参考后向引用。

(?# )
注释。括号中的任意字符串将被忽视。

(?: )
不具备后向引用功能的群组化。它不为 \1，\2（或 $1，$2）提供服务，是一种单纯的群组功能。
/(abc)/ =~ "abc" p $1 => "abc" /(?:abc)/ =~ "abc" p $1 => nil

(?= )
先行（lookahead）。使用 pattern 指定位置（不留间隔）。
(?=re1)re2
表示同时匹配 re1 和 re2 的正则表达式。
re1(?=re2)
表示在后面紧跟着匹配 re2 字符串的正则表达式 re1。
p /foo(?=bar)/ =~ "foobar" # => 0 p $& # => "foo" （没有 bar 部分的信息）

(?! )
否定先行（negative lookahead）。使用否定的 pattern 来指定位置（不留间隔）。
(?!re1)re2
表示不匹配 re1 匹配 re2 的正则表达式。
# 除 000 以外的 3 位数字 re = /(?!000)\d\d\d/ p re =~ "000" # => nil p re =~ "012" # => 0 p re =~ "123" # => 0 # C 语言标识符（首位是[A-Za-z_]然后是[0-9A-Za-z_]的字符串） /\b(?![0-9])\w+\b/

(?ixm-ixm)
正则表达式中的 i 选项、x 选项、m 选项的开关。请您参考正则表达式字面值来了解选项的详细内容。
re = /A(?i)a(?-i)A/ p re =~ "AaA" # => 0 p re =~ "AAA" # => 0 p re =~ "AAa" # => nil

(?ixm-ixm: )
括号中的 i 选项、x 选项、m 选项的开关。在括号范围内有效。
re = /A(?i:a)A/ p re =~ "AaA" # => 0 p re =~ "AAA" # => 0 p re =~ "AAa" # => nil
后向引用正则表达式 \1 \2 ... \n 表示后向引用。\n 表示将匹配第 n 个括号（正则表达式的()表示群）的内容保存起来，供后面使用。
/((foo)bar)\1\2/
和
/((foo)bar)foobarfoo/
是一样的。
例子：
re = /(foo|bar|baz)\1/ p re =~ 'foofoo' # => 0 p re =~ 'barbar' # => 0 p re =~ 'bazbaz' # => 0 p re =~ 'foobar' # => nil
对应的括号必须位于后向引用表达式的左侧。
若后向引用表达式位于对应的括号中时，匹配常常会失败。当后向引用表达式中的数字是 1 位，且没有对应的括号时，匹配也将失败。
p /(\1)/ =~ "foofoofoo" # => nil p /(foo)\2/ =~ "foo\2" # => nil
虽然可以指定 2 位以上的后向引用表达式，但是不要把它同控制码的 \nnn（对应于八进制数 nnn 的字符）混为一谈。当数字只有 1 位时，通常是后向引用表达式。当指定了一个超过 2 位的数字时，若没有对应括号的话，则被看作是八进制代码。
相反地，若在正则表达式中使用 1 位的八进制代码时，必须以 0 打头，例如 \01 等（不可能存在形如 \0 这样的后向引用表达式，因此不会混淆）。
p /\1/ =~ "\1" # => nil # 无对应括号的后向引用 p /\01/ =~ "\1" # => 0 八进制代码 p /\11/ =~ "\11" # => 0 八进制代码 # 八进制代码（因为没有对应括号） p /(.)\10/ =~ "1\10" # => 0 # 后向引用（因为有对应的括号） p /((((((((((.))))))))))\10/ =~ "aa" # => 0 # 八进制代码（因为没有像 "\0" + "8" -> \08 这样的八进制代码） p /(.)\08/ =~ "1\0008" # => 0 # 如果想在后向引用表达式之后插入数字的话，就必须使用括号加以分隔。 p /(.)(\1)1/ =~ "111" # => 0
字符簇正则表达式 [] 负责指定字符簇。这将匹配 [] 内列出的任何一个字符。
例如 /[abc]/ 表示只要匹配 "a"、"b"、"c" 中任何一个即可。也可以按照 ASCII 代码顺序，在连续的字符串之间插入“-”后写成 /[a-c]/ 也是一样的效果。另外，若开头是“^”的话，表示要匹配指定字符之外的一个字符。
若“^”不在开头的话，表示匹配该字符本身。同时，当“-”出现在头或尾上时，表示匹配该字符本身。
p /[a^]/ =~ "^" # => 0 p /[-a]/ =~ "-" # => 0 p /[a-]/ =~ "-" # => 0 p /[-]/ =~ "-" # => 0
空的字符簇将会引发错误。
p /[]/ =~ "" p /[^]/ =~ "^" # => invalid regular expression; empty character class: /[^]/
当“]”出现在开头（或否定的“^”之后）时，表示“]”本身，而并非字符范围的结尾。这样的“]”推荐使用反斜线符号进行转义。
p /[]]/ =~ "]" # => 0 p /[^]]/ =~ "]" # => nil
可以使用反斜线符号对 "^"、"-"、"]" 以及 "\\"（反斜线符号）进行转义，使其匹配该字符本身。
p /[\^]/ =~ "^" # => 0 p /[\-]/ =~ "-" # => 0 p /[\]]/ =~ "]" # => 0 p /[\\]/ =~ "\\" # => 0
在 [] 中同字符串一样可以使用控制码，以及正则表达式 \w、\W、\s、\S、\d、\D（这些都是表示字符簇的简写法）。
请注意，下面包含否定意味的字符簇也将匹配换行符（正则表达式 \W、\D 也是如此）。
p /[^a-z]/ =~ "\n" # => 0