一聚教程网:一个值得你收藏的教程网站

最新下载

热门教程

Ruby 正则表达式学习笔记

时间:2016-10-08 编辑:简简单单 来源:一聚教程网

Ruby 正则表达式的字面构造器:

//
试一下:

>> //.class
=> Regexp
模式匹配有两个部分组成,一个正则表达式(regexp),还有一个字符串。正则表达式预测字符串,字符串要么满足预测,要么不满足。

看看是不是匹配可以使用 match 方法。做个实验:

>> puts "匹配!" if /abc/.match("the alphabet starts with abc.")
匹配!
=> nil
>> puts "匹配!" if "the alphabet starts with abc.".match(/abc/)
匹配!
=> nil
除了 match 方法,还有个模式匹配操作符 =~ ,把它放在字符串与正则表达式的中间用:

>> puts "匹配!" if /abc/ =~ "the alphabet starts with abc."
匹配!
=> nil
>> puts "匹配!" if "the alphabet starts with abc." =~ /abc/
匹配!
=> nil
没有匹配就会返回 nil 。有匹配的话,match 与 =~ 返回的东西不一样。 =~ 返回是匹配开始的字符的数字索引,match 返回的是 MatchData 类的一个实例。做个实验:

>> "the alphabet starts with abc" =~ /abc/
=> 25
>> /abc/.match("the alphabet starts with abc")
=> #
匹配模式

// 中间的东西可不是字符串,它是你对字符串做的预测与限制。

字面字符

正则表达式里的字面字符匹配它自己,比如:

/a/
匹配的就是字母 a 。

有些字符有特别的意思,如果你不想让它表达特别的意思,可以使用 \ 线 escape 一下它:

/\?/
通配符

. 表示除了换行符以外的任意字符。

/h.t/
匹配 hot,hit ...

字符类

字符类会在一组方括号里:

/h[oi]t/
在上面的正则表达式里,那个字符类的意思是匹配 o 或 i 。也就是上面这个模式会匹配 “hot”,“hit”,但不匹配 “h!t” 或其它的东西。

下面这个字符类匹配小写字符 a 到 z :

/[a-z]/
^ 符号在字符类里表示否定:

/[^a-z]/
匹配十六进制数字,在字符类里可能得用几个字符范围:

/[A-Fa-f0-9]/
匹配数字 0 - 9:

/[0-9]/
0 - 9 太常用了,所以还有个简单的形式,d 表示 digit:

/\d/
数字,字符,还有下划线,w 表示 word:

/\w/
空白,比如空格,tab,还有换行符,s 表示 space:

/\s/
大写的表示否定形式:\D,\W,\S。

匹配

给你 yes/no 结果的匹配的操作:

regex.match(string)
string.match(regex)
子匹配

比如我们有行文字是关于一个人的:

Peel,Emma,Mrs.,talented amateur
我想得到人的 last name,还有 title。我们知道字段是用逗号分隔开的,我们也知道顺序:last name,first name,title,occupation 。

首先是一些字母字符,
然后是一个逗号,
然后又是一些字母字符,
接着还是一个逗号
然后是 Mr. 或 Mrs.
匹配上面这种字符器的模式:

/[A-Za-z]+,[A-Za-z]+,Mrs?\./
s? 意思是这个 s 可以有也可以没有。这样 Mrs? 也就会匹配 Mr 或 Mrs 。在 irb 上做个实验:

>> /[A-Za-z]+,[A-Za-z]+,Mrs?\./.match("Peel,Emma,Mrs.,talented amateur")
=> #
我们得到了一个 MatchData 对象。现在我们要 Pell 还有 Mrs 怎么办? 可以使用括号对匹配模式分组:

/([A-Za-z]+),[A-Za-z]+,(Mrs?\.)/
再试试这个匹配模式:

>> /([A-Za-z]+),[A-Za-z]+,(Mrs?\.)/.match("Peel,Emma,Mrs.,talented amateur")
=> #
使用 $1 可以得到第一个分组里的匹配,$2 可以得到第二个分组里的匹配:

>> puts $1
Peel
=> nil
>> puts $2
Mrs.
=> nil
匹配成功与失败

没找到匹配,返回的值就是 nil,试试:

>> /a/.match("b")
=> nil
如果匹配成功会返回 MatchData 对象,它的布尔值是 true。还有些关于匹配的信息,比如匹配在哪里开始,覆盖了多少字符串,在分组里获得了什么等等。

想使用 MatchData 得先把它存储起来。练习一下:

string = "我的电话号码是 (123) 555-1234."
phone_re = /\((\d{3})\)\s+(\d{3})-(\d{4})/
m = phone_re.match(string)

unless m
  puts "没有匹配"
  exit
end

print "整个字符串:"
puts m.string
print "匹配:"
puts m[0]
puts "三个分组:"
3.times do |index|
  puts "#{index + 1}:#{m.captures[index]}"
end
puts "得到第一个分组匹配的内容:"
puts m[1]
结果是:

整个字符串:我的电话号码是 (123) 555-1234.
匹配:(123) 555-1234
三个分组:
1:123
2:555
3:1234
得到第一个分组匹配的内容:
123
得到捕获的两种方法

从 MatchData 对象里得到匹配模式分组捕获到的内容:

m[1]
m[2]
...
m[0] 得到的是匹配的全部内容。

另一种得到分组捕获内容的方法是使用 captures 方法,它返回的是一个数组,数组里的项目就是捕获的子字符串。

m[1] == m.captures[0]
m[2] == m.captures[1]
再看个例子:

>> /((a)((b)c))/.match("abc")
=> #
命名捕获

>> re = /(?\w+)\s+((?\w\.)\s+)?(?\w+)/
匹配:

>> m = re.match("Samuel L. Jackson")
=> #
>> m[:first]
=> "Samuel"
>> m[:last]
=> "Jackson"
MatchData 的其它信息

接着之前的电话号码的例子:

print "匹配之前的部分:"
puts m.pre_match

print "匹配之后的部分:"
puts m.post_match

print "第二个捕获开始字符:"
puts m.begin(2)

print "第三个捕获结束字符:"
puts m.end(3)
输出的结果是:

匹配之前的部分:我的电话号码是
匹配之后的部分:.
第二个捕获开始字符:14
第三个捕获结束字符:22
begin 与 end 方法待验证。
Quantifiers,Anchors,Modifiers

Quantifiers(限定符),Anchors(标记),Modifiers(修饰符)。

限定符

限定符可以指定在匹配里某个东西要匹配的次数。

零或一

?
例:

/Mrs?/
s 可以出现零次或一次。

零或多

*
例:

/\d*/
一或多

+
例:

/\d+/
Greedy quantifier

*与+ 这两个限定符都很 greedy。意思就是它们会尽可能的匹配更多的字符。

观察下面这个例子里的 .+ 匹配的是什么:

>> string = "abc!def!ghi!"
=> "abc!def!ghi!"
>> match = /.+!/.match(string)
=> #
>> puts match[0]
abc!def!ghi!
=> nil
你可能期望返回的是子字符 "abc!" ,不过我们得到的是 "abc!def!ghi!"。限定符 + 贪婪的吃掉了它能覆盖的所有的字符,一直到最后一个 ! 号结束。

我们可以在 + 与 * 后面添加一个 ? 号,让它们不那么贪婪。再试一下:

>> string = "abc!def!ghi!"
=> "abc!def!ghi!"
>> match = /.+?!/.match(string)
=> #
>> puts match[0]
abc!
=> nil
再做个实验:

>> /(\d+?)/.match("Digits-R-Us 2345")
=> #
>> puts $1
2
=> nil
再看个匹配:

>> /\d+5/.match("Digits-R-Us 2345")
=> #
这样再试一下:

>> /(\d+)(5)/.match("Digits-R-Us 2345")
=> #
具体重复的次数

把次数放到 {} 里。下面匹配的是三个数字,小横线,接着是四个数字:

/\d{3}-\d{4}/
也可能是一个范围,下面匹配的是 1 到 10 个数字:

/\d{1,10}/
大括号里第一个数字是最小值,下面匹配的是 3 个或更多的数字:

/\d{3,}/
括号的限制

>> /([A-Z]){5}/.match("Matt DAMON")
=> #
你期望的匹配可能是 DAMON,但实际匹配的是 N 。如果你想匹配 DAMON ,需要这样做:

>> /([A-Z]{5})/.match("Matt DAMON")
=> #
anchors 与 assertions

anchors(标记,锚) 与 assertions(断言):在处理字符匹配之前先要满足一些条件。

^ 表示行的开始,$ 行的结尾。

Ruby 里的注释是 # 号开头的,匹配它的模式可以像这样:

/^\s*#/
^ 匹配的是行的最开始。

anchors

^:行的开始
$:行的结尾
\A:字符串的开始
\z:字符串的结尾
\Z:字符串的结尾,模式:/from the earth.\Z/,匹配:"from the earth\n"
\b:字边界
lookahead assertions

你想匹配一组数字,它的结尾必须有点,但你不想在匹配的内容里包含这个点,可以这样做:

>> str = "123 456. 789"
=> "123 456. 789"
>> m = /\d+(?=\.)/.match(str)
=> #
lookbehind assertions

我要匹配 Damon,但必须它的前面得有 matt。

模式:

/(?<=Matt )Damon/
试一下:

>> /(?<=Matt )Damon/.match("Matt Damon")
=> #
>> /(?<=Matt )Damon/.match("Matt1 Damon")
=> nil
我要匹配 Damon,但它的前面不能是 matt 。

模式:

/(? 试一下:

>> /(? => nil
>> /(? => #
不捕获

使用:?:

>> str = "abc def ghi"
=> "abc def ghi"
>> m = /(abc) (?:def) (ghi)/.match(str)
=> #
条件匹配

条件表达式:(?(1)b|c) ,如果获取到了 $1,就匹配 b ,不然就匹配的是 c :

>> re = /(a)?(?(1)b|c)/
=> /(a)?(?(1)b|c)/
>> re.match("ab")
=> #
>> re.match("b")
=> nil
>> re.match("c")
=> #
有名字的:

/(?a)?(?()b|c)/
modifiers

i 这个修饰符表示不区分大小写:

/abc/i
m 表示多行:

/abc/m
x 可以改变正则表达式解析器对待空格的看法,它会忽略掉在正则表达式里的空格,除了你用 \ 符号 escape 的空白。

/
 \((\d{3})\)  # 3 digits inside literal parens (area code)
   \s         # One space character
 (\d{3})      # 3 digits (exchange)
    -         # Hyphen
 (\d{4})      # 4 digits (second part of number
/x
转换字符串与正则表达式

string-to-regexp

在正则表达式里使用插值:

>> str = "def"
=> "def"
>> /abc#{str}/
=> /abcdef/
如果字符串里包含在正则表达式里有特别意义的字符,比如点(.):

>> str = "a.c"
=> "a.c"
>> re = /#{str}/
=> /a.c/
>> re.match("a.c")
=> #
>> re.match("abc")
=> #
你可以 escape 这些特殊的字符:

>> Regexp.escape("a.c")
=> "a\\.c"
>> Regexp.escape("^abc")
=> "\\^abc"
这样再试试:

>> str = "a.c"
=> "a.c"
>> re = /#{Regexp.escape(str)}/
=> /a\.c/
>> re.match("a.c")
=> #
>> re.match("abc")
=> nil
也可以:

>> Regexp.new('(.*)\s+Black')
=> /(.*)\s+Black/
这样也行:

>> Regexp.new('Mr\. David Black')
=> /Mr\. David Black/
>> Regexp.new(Regexp.escape("Mr. David Black"))
=> /Mr\.\ David\ Black/
regexp-to-string

正则表达式可以使用字符串的形式表示它自己:

>> puts /abc/
(?-mix:abc)
inspect:

>> /abc/.inspect
=> "/abc/"
使用正则表达式的方法

Ruby 里的一些方法可以使用正则表达式作为它们的参数。

比如在一个数组里,你想找出字符长度大于 10 ,并且包含一个数字的项目:

array.find_all {|e| e.size > 10 and /\d/.match(e) }
String#scan

找到一个字符串里包含的所有的数字:

>> "testing 1 2 3 testing 4 5 6".scan(/\d/)
=> ["1", "2", "3", "4", "5", "6"]
分组:

>> str = "Leopold Auer was the teacher of Jascha Heifetz."
=> "Leopold Auer was the teacher of Jascha Heifetz."
>> violinists = str.scan(/([A-Z]\w+)\s+([A-Z]\w+)/)
=> [["Leopold", "Auer"], ["Jascha", "Heifetz"]]
可以这样用:

violinists.each do |fname,lname|
  puts "#{lname}'s first name was #{fname}."
end
输出的是:

Auer's first name was Leopold.
Heifetz's first name was Jascha.
合并到一块儿:

str.scan(/([A-Z]\w+)\s+([A-Z]\w+)/) do |fname, lname|
  puts "#{lname}'s first name was #{fname}."
end
再做个实验:

"one two three".scan(/\w+/) {|n| puts "Next number: #{n}" }
输出的是:

Next number: one
Next number: two
Next number: three
如果你提供了一个代码块,scan 不会存储把结果存储到一个数组里,它会把每个结果都发送给代码块,然后扔掉结果。也就是你可以 scan 一个很长的东西,不用太担心内存的问题。

StringScanner

StringScanner 在 strscan 扩展里,它里面提供了一些扫描与检查字符串的工具。可以使用位置与指针移动。

>> require 'strscan'
=> true
>> ss = StringScanner.new("Testing string scanning")
=> #
>> ss.scan_until(/ing/)
=> "Testing"
>> ss.pos
=> 7
>> ss.peek(7)
=> " string"
>> ss.unscan
=> #
>> ss.pos
=> 0
>> ss.skip(/Test/)
=> 4
>> ss.rest
=> "ing string scanning"
String#split

split 可以把一个字符串分离成多个子字符串,返回的这些子字符串会在一个数组里。split 可以使用正则表达式或者纯文字作为分隔符。

试一下:

>> "Ruby".split(//)
=> ["R", "u", "b", "y"]
把一个基于文字的配置文件的内容转换成 Ruby 的数据结构。

>> line = "first_name=matt;last_name=damon;country=usa"
=> "first_name=matt;last_name=damon;country=usa"
>> record = line.split(/=|;/)
=> ["first_name", "matt", "last_name", "damon", "country", "usa"]
hash:

>> data = []
=> []
>> record = Hash[*line.split(/=|;/)]
=> {"first_name"=>"matt", "last_name"=>"damon", "country"=>"usa"}
>> data.push(record)
=> [{"first_name"=>"matt", "last_name"=>"damon", "country"=>"usa"}]
split 的第二个参数,可以设置返回的项目数:

>> "a,b,c,d,e".split(/,/,3)
=> ["a", "b", "c,d,e"]
sub/sub! 与 gsub/gsub!

sub 与 gsub,可以修改字符串里的内容。gsub 修改整个字符串,sub 最多只修改一个地方。

sub

>> "hit hit".sub(/i/,"o")
=> "hot hit"
代码块:

>> "hit".sub(/i/) {|s| s.upcase}
=> "hIt"
gsub

>> "hit hit".gsub(/i/,"o")
=> "hot hot"
捕获

>> "oHt".sub(/([a-z])([A-Z])/, '\2\1')
=> "Hot"
>> "double every word".gsub(/\b(\w+)/, '\1 \1')
=> "double double every every word word"
=== 与 grep

===

所有的 Ruby 对象都认识 === 这个信息,如果你没覆盖它的话,它跟 == 是一样的。如果你覆盖了 === ,那它的功能就是新的意思了。

在正则表达式里,=== 的意思是匹配的测试。

puts "Match!" if re.match(string)
puts "Match!" if string =~ re
puts "Match!" if re === string
试一下:

print "Continue? (y/n) "
answer = gets
case answer
when /^y/i
  puts "Great!"
when /^n/i
  puts "Bye!"
  exit
else
  puts "Huh?"
end
grep

>> ["USA", "UK", "France", "Germany"].grep(/[a-z]/)
=> ["France", "Germany"]
select 也可以:

["USA", "UK", "France", "Germany"].select {|c| /[a-z]/ === c }
代码块:

>> ["USA", "UK", "France", "Germany"].grep(/[a-z]/) {|c| c.upcase }
=> ["FRANCE", "GERMANY"]

 

热门栏目