RUBY 正则表达式

# \d
  # 数字。即[0-9]
  puts "aaa0" =~ /\d/  # 3 匹配数字
  puts /\d/ =~ "abc2"  # 3
  puts "kkmm1" =~ /\d/ # 4 匹配数字

  # [\u{4e00}-\u{9fff}]
  # 中文
  puts "abcdef我熬啊" =~ /[\u{4e00}-\u{9fff}]/u   #6  匹配中文
  puts "abcdef我熬啊" =~ /\p{Han}/u  # 6


  # \w
  # 字母和数字。等同于[0-9A-Za-z]。
  puts "-=123a" =~  /\w/ # 2 匹配字母
  puts "-=a3a" =~  /\w/ # 2 匹配字母  

  # \s
  # 空字符。相当于[ \t\n\r\f]
  puts "aaa bbb" =~ /aa\s/ # 1
  puts "aaa bbb" =~ /\s/ # 3

  # ^
  # 行首。与字符串的头部或换行符之后的位置相匹配。
  # \A
  # 字符串头部。与^不同的是，它不受有无换行符的影响 。
  puts "abcd\nefghg" =~ /^e/ # 5
  puts "1\n2\n3\n4" =~ /^3/  # 4
  puts "1\n2\n3\n4" =~ /\A1/ # 0
  puts "abcd\nefghg" =~ /\A/ # 0

  # $
  # 行尾。与字符串的尾部或换行符之前的位置相匹配。不包括换行符本身。
  # \Z
  # 字符串尾部。若字符串以换行符结尾，则匹配换行符前的位置。
  puts "abcd\nefghg" =~ /g$/ # 9
  puts "1\n2\n3\n4" =~ /3$/  # 4
  puts "1\n2\n3\n4" =~ /4\Z/ # 6
  puts "abcd\nefghg" =~ /\Z/ # 10

  # .
  # 匹配除换行符以外的任意一个字符。使用正则表达式选项 m(多行模式。请参考正则表达式字面值) 时，则匹配包括换行符在内的任意一个字符。在匹配多字节字符的正则表达式中，则匹配一个字(非单字节)。
  # 当遇到不完整的多字节字符的一部分(无法判断该字符是多字节字符？二进制？还是ASCII)时，也不会匹配。
  puts /./e =~ "CV--aa" # 0
  puts /./ =~ "あ"  # 0
  /a.*b/.match("a123bcab") #=><MatchData "a123bcab:>


  # \b
  # 在字符范围描述符之外时表示词边界(匹配从\w到\W)。在字符范围描述符之内时表示退格符(0x08)。
  puts "232342eaaabbbddd43452532543" =~ /b/ # 10

  # 从头取出3位数字(数字必须相连)。
  str = "123456 789"
  puts str.scan(/\G\d\d\d/) {|m| p m }


  # [ ]
  # 指定字符范围。请参考字符范围
  puts "1445345abc" =~ /[a-z]/

  # *
  # 前面元素至少出现0次。尽可能匹配较长的部分。
  # *?
  # 负责指定数量(quantifiers)。表示前面元素至少出现0次(尽量匹配短的部分)
  # +
  # 负责指定数量(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 次
  # (尽量匹配短的部分)。
  str = "foofoofoo"
  p str[/f{1}?/] # f
  p str[/(o){2,8}?/] # f

  # ?
  # 负责指定数量(quantifiers)。表示前面元素至多出现1次。
  # ??
  # 负责指定数量(quantifiers)。表示前面元素至多出现1次(尽量匹配短的部分)
  # |
  # 选择(alternative)。
  # ( )
  # 正则表达式的群组化。与括号中的正则表达式相匹配的字符串将被保存下来，供后方参考使用。
  p /(ab)+/=~"123abab"
  p /(ab)+/.match("123abab") #=><MatchData "abab" 1:"ab">
  # \1, \2 ... \n
  # 后方参考(back reference)。请参考后方参考。
  p /((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,\2(或$1,$2)提供服务，是一种单纯的群组功能。
  /(cba)/ =~ "abccba"
  p $1  # cba

  /(?:abc)/ =~ "abc"
  p $1

1.建立正则表达式
使用”//” reg=/ru\/by/ 需要对转义字符转义
使用类方法Regexp.new reg=Regexp.new(“ru/by”) 不需要对转义字符转义
使用%r reg=%r(ru/by) 不需要对转义字符转义
2.正则表达式的一般匹配

/ruby/ =~ "ruby string"
#=>0 返回匹配成功的起始位置
/ruby/.match("string
# 返回匹配成功的字符串

3.匹配行首行尾和字符串首尾
若字符串中有换行符，行尾就是换行符的前面

^ 匹配行首
/^ruby/=~"rubystring"   #=>0
/^ruby/=~"string\nruby" #=>7
$ 匹配行尾
/ruby$/=~"stringruby"        #=>6
/ruby$/=~"stringruby/string" #=>6
\A 匹配字符串首
/\Aruby/=~"rubystring"         #=>0
/\Aruby/=~"string\nrubystring" #=>nil
\Z 匹配字符串尾
/ruby\Z/=~"string\nruby"       #=>7
/ruby\Z/=~"stringruby\nstring" #=>nil

4.指定匹配范围和多选

[ab] 匹配a或b
/[ab]/=~"stringa"     #=>6
[adf] 匹配a、d或f
/[adf]/=~"stringd"    #=>6
[a-z] 匹配a到z
/[a-z]/=~"123r"       #=>3
[A-Za-z] 匹配A到Z和a到z
/[A-Za-z]/=~"123D321" #=>3
[0-9] 匹配0到9
/[0-9]/=~"abc4ef"     #=>3

在[ ]内加入^表示匹配除括号内指定的字符外
[^abc] 匹配除abc之外的字符
/[^abc]/=~"abccb"     #=>nil
/[^abc]/=~"acdf"      #=>2
使用”|”来添加候选字符
/12a|b/.match("123bc")    #=gt;<MatchData "12b">
/12a|b|c/.match("123cd")  #=gt;<MatchData "12c">
5.匹配任意字符
匹配除换行符外地任意字符
/./=~"abc"     #=>0
6.反斜杠字母

\s 匹配空白、换行符、定位字符、换页符
/a\sc/=~"abca c"  #=>3
\S 匹配除空白、换行符、定位符、换页符之外的字符
/a\Sc/=~"a\ncabc" #=>3
\d 匹配数字
/a\dc/=~"abca1c"  #=>3
\D 匹配除数字之外的字符
/a\Dc/=~"a1cabc"  #=>3
\w 匹配数字、字母和"_"
/a\wc/=~"a&cabc"  #=>3
\W 匹配除数字、字母和"_"之外的字符
/a\Wc/=~"abca&c"  #=>3
\b 匹配单词的开始或结尾
/\bis/=~"this ist" #=>5
/is\b/=~"this ist" #=>2
\B 与\b相对
/\Bis/=~"this ist" #=>2
/is\B/=~"this ist" #=>5

7.转义字符的转义
在转义字符”^”,”$”,”["等前面加上"\",就能对转义字符进行转义来表示它自己
/abc\$/=~"abc"   #=>nil
/abc\$/=~"abc$"  #=>0
通过quote方法来将转义字符变成普通字符
reg1=Regexp.new("a*b")
reg2=Regexp.new(Regexp.quote("a*b"))
reg1=~"123a*b"   #=>nil
reg2=~"123a*b"   #=>3
8.反复的匹配

* 出现0次或以上
/a*b/.match("123aaab") #=><MatchData "aaab">
/a*b/.match("123b")    #=><MatchData "b">
+ 出现1次或以上
/a+b/.match("123aaab") #=><MatchData "aaab">
/a+b/.match("123b")    #=>nil
/a+b/.match("123ab")   #=><MatchData "ab">
? 出现0次或1次
/a?b/=~"123aaab"       #=>5
/^a?b/=~"aaab"         #=>nil
/.?b/.match("123b")    #=><MatchData "3b">

ruby的正则表达式匹配时是贪婪匹配，即匹配时尽可能匹配更多的字符
/a.*b/.match("a123bcab") #=><MatchData "a123bcab:>
可通过添加"?"来变成不贪婪匹配
*? 0次或以上的不贪婪匹配
+? 1次或以上的不贪婪匹配
/a.*?b/.match("a123bcab") #=><MatchData "a123b">
使用()群组来反复
/(ab)*/=~"123abab"       #=>0
/(ab)*/.match("123abab") #=><MatchData "" 1:nil>
/(ab)+/=~"123abab"       #=>3
/(ab)+/.match("123abab") #=><MatchData "abab" 1:"ab">
使用{}来为制定的字符取得多次匹配

/a{n}/ 匹配n个a
/a{3}/.match("123aaab")     #=><MatchData "aaa">
/a{n,} 匹配n或n以上个a
/a{3,}/.match("123aaaab")   #=><MatchData "aaaa">
/a{n,m} 匹配n到m个a
/a{1,3}b/=~"123b"           #=>nil
/a{1,3}b/=~"123ab"          #=>3
/a{1,3}b/=~"123aab"         #=>3
/a{1,3}b/=~"123aaab"        #=>3
/a{1,3}b/=~"123aaaab"       #->nil

9.正则表达式的选项

通过直接在添加"/.../"后面，如/Ab/i

i 忽略大小写
/ab/i=~"12AB"               #=>2
m 多行匹配，能让"."匹配换行符
/a.b/m=~"12a\nbc"           #=>2
x 忽略空白、换行符，并忽略"#"后面的字符，这时可使用#来添加注释了
/a b/=~"12ab"               #=>nil
/a b/x=~"12ab"              #=>2
/a b#def/x.match("12abdef") #=><MatchData "ab">
s,e,u,n 指定字符编码，s是Shift-JIS,e是EUC-JP,
u是UTF-8,n是none即不考虑字符编码


通过在字符前面添加选项，选项后面的字符都被选项影响，
而选项前面的字符则不受影响

(?i)
/A(?i)bc/=~"ABC"      #=>0
/A(?i)bc/=~"abc"      #=>nil
/A(?i)b(?-i)c/=~"AbC  #=>nil
/A(?i)b(?-i)c/=~"ABc" #=>0
类似还有(?m),(?x),(?-i)表示不能忽略大小写,
(?-m)表示不能忽略换行符,(?-x)表示不能忽略空白



通过将字符串写入选项内

(?i:)
/A(?i:bc)/=~"ABC"  #=>0
同样，还有(?-i:),(?m:),(?-m:),(?x:),(?-x:)



10.添加注释
除了通过上面所讲，使用x选项来添加注释，还可以使用(?#)
/ab(?#def)/=~"123ab"    #=>3
/\d-(?#这里的"-"不是指范围)\d/=~"ab1-2"  #=>2
11.回溯参照(backreference，反向引用)
回溯参照用来取出字符串中匹配成功的一部分

与正则表达式中的()中所匹配的字符串可用$1,$2,,$3……来取出
取出顺序是从左往右，从外向内
/(a)(.)(b)/.match("123aeb")   #=><MatchData "acb" 1:"a" 2:"e" 3:"b">
p $1 #=>"a"
p $2 #=>"e"
p $3 #=>"c"
/((.)(a))/.match("123abc")    #=><MatchData "3a" 1:"3a" 2:"3" 3:"a">
p $1 #=>"3a"
p $2 #=>"3"
p $3 #->"a"
取出与正则表达式所匹配的字符，匹配的字符的前面，匹配字符的后面
分别用$&,$`(1旁边),$'
/ab/=~"123ab456"     #=>3
p $& #=>"ab"
p $` #=>"123"
p $' #=>"456"
取出MatchData,用$~
/(a)b/=~"123ab"     #=>3
p $` #=>"123"
p $' #=>""
p $& #=>"ab"
p $~ #=><MatchData "ab" 1:"a">
用形如"\num"来匹配群组1，群组2，群组3……群组num的字符
/a(b)\1/=~"abc"      #=>nil
/a(b)\1/=~"abb"      #=>0
/(a)(b)\1\2/=~"abaa" #=>nil
/(a)(b)\1\2/.match("123abab") #=><MatchData "abab" 1:"a" 2:"b">
/(a)(b)\2/=~"abb"    #=>0
/((a)(b))\1/.match("123abab") #=><MatchData "abab" 1:"ab" 2:"a" 3:"b">
/(a|b)\1/=~"ab"      #=>nil
/(a|b)\1/=~"ba"      #=>nil
/(a|b)\1/=~"aa"      #=>0
/(a|b)\1/=~"bb"      #=>0
若要在\num后面添加数字，则必须得给\num添加括号
/a(b)(\1)2/=~"ab12"  #=>nil
/a(b)(\1)2/=~"abb2"  #=>0
使用索引
mat1=/.a/.match("123a")    #=><MatchData "3a">
p mat1[0]   #=>”3a”
p mat1[1]   #nil
mat2=/(.)a/.match(“123a”） #=><MatchData “3a” 1:”3″>
p mat2[0]   #=>”3a”
p mat2[1]   #=>”3″
p mat2[2]   #=>nil
若只想有群组的功能，而没有回溯参照的功能，则可以使用(?:)
/(a)(?:b)(c)/.match(“123abcd”)    #=><MatchData “abc” 1:”a” 2:”c”>

12.(?!exp)和(?=exp)

(?!exp) 匹配后缀不是exp
/ab(?!c)/=~"abc"   #=>nil
/ab(?!c)/=~"abe"   #=>0
(?=exp) 匹配后缀为exp
/ab(?=c)/=~"abc"   #=>0
/ab(?=c)/=~"abe"   #=>nil

13.sub方法和gsub方法
sub方法和gsub方法都是用来取代字符串中字符的方法，
第一个参数指定匹配样式，第二个参数指定想要代入的字符串。
sub方法只会取代第一个匹配成功的字符串，
而gsub方法会取代所有匹配成功的字符串

sub方法，sub!方法
str="abc\n123\456"
str.sub(/\n/,'d')   #=>"abcd123\n456"
gsub方法，gsub!方法
str="abc\n123\n456"
str.gsub(/\n/,'d')  #=>"abcd123d456"

sub方法和gsub方法也可以传入区块
str="ab12ac34ad"
str.gsub(/a./){|mat|
  print "string ",mat,"\n"
  }
#=>
string ab
string ac
string ad
14.scan方法
scan方法会查找字符串中所有匹配的字符,并以数组返回
"12ab34ac56ad".scan(/a./)   #=>["ab","ac","ad"]
scan方法也可以传入区块
"12ab34ac56ad".scan(/a./){|mat|
  print "string ",mat,"\n"
  }
#=&gt
string ab
string ac
string ad
当正则表达式中含有(),则匹配成功的部分会以数组的形式传入区块
"12ab34ac56ad".scan(/(a)(.)/){|mat|
  print mat
  }
#=>
["a","b"]
["a","c"]
["a","d"]
若区块中的变量和正则表达式中的()一样多式，则不会传入数组
"12ab34ac56ad".scan(/(a)(.)/){|m,n|
  print n," after ",m,"\n"
  }
#=>
b after a
c after a
d after a
15.正则表达式的条件判断
if /reg/ =~ "string"
  匹配成功时的动作
else
  匹配失败时的动作
end

16.# Regexp .match(text)
  md = /(\d\d):(\d\d)(..)/.match("12:50am")
  puts "Hour is #$1, minute #$2"
  puts "Hour is #{md[1]}, minute #{md[2]}"
  # Regexp .quote(text) | .escape(text)
  # String .index(Regexp)  | =~

  17.# String .scan(Regexp)
  "abcabcabz".scan(%r{abc}).each {|item| puts item} # 输出2行abc
  puts "2010-11-22 2022-08-25".scan(/\d{4}-\d{2}-\d{2}/)
  puts "2010-11-22 2022-08-25".scan(/(\d{4})-(\d{2})-(\d{2})/)

  18.#String .slice(Regexp)
  string = "Date: 2012-12-23"
  regex = /\d{4}-\d{2}-\d{2}/
  p string.slice(regex) # 2012-12-23

19. #String.split(Regexp)
  p "2012-12-23".split(/-/)

  20.# String.sub | .gsub(Regexp,String)
  str = "ABDADA"
  p str.sub(/A/, "*")   #返回"*BDADA"
  p str.gsub(/A/, "*") #返回"*BD*D*"