当前位置：极客教程 > Ruby > Ruby 教程 > Ruby 正则表达式

Ruby 正则表达式

正则表达式用于文本搜索和更高级的文本操作。 正则表达式内置在 grep，sed 等工具中，诸如 vi，emacs 之类的文本编辑器； Tcl，Perl，Python 等编程语言。 Ruby 也有对正则表达式的内置支持。

从另一个角度来看，正则表达式语法构成了用于匹配文本的特定于域的语言。

模式是一个正则表达式，用于定义我们正在搜索或操纵的文本。 它由文本文字和元字符组成。 该模式放置在两个定界符内。 在 Ruby 中，这些是//字符。 它们通知正则表达式函数模式的开始和结束位置。

以下是部分元字符列表：
. 匹配任何单个字符。
* 与前面的元素匹配零次或多次。
[ ] 括号表达。 与方括号内的字符匹配。
[^ ] 匹配方括号中未包含的单个字符。
^ 匹配字符串中的起始位置。
$ 匹配字符串中的结束位置。
| 备用运算符。

=~运算符将正则表达式与字符串进行匹配，如果找到匹配项，则返回匹配项与字符串的偏移量，否则返回 nil。 Regexp类用于开发正则表达式。 还有两种创建正则表达式的简便方法。 以下示例将显示它们。

#!/usr/bin/ruby

re = Regexp.new 'Jane'
p "Jane is hot".match re

p "Jane is hot" =~ /Jane/
p "Jane is hot".match %r{Jane}
Ruby

在第一个示例中，我们展示了在字符串上应用正则表达式的三种方式。

re = Regexp.new 'Jane'
p "Jane is hot".match re
Ruby

在以上两行中，我们创建一个Regexp对象，其中包含一个简单的正则表达式文本。 使用match方法，我们将此正则表达式对象应用于“ Jane is hot”句子。 我们检查句子中是否包含“简”一词。

p "Jane is hot" =~ /Jane/
p "Jane is hot".match %r{Jane}
Ruby

这两行是相同的。 两个正斜杠//和% r {}字符是更冗长的第一种方式的简写。 在本教程中，我们将使用正斜杠。 这是许多语言的事实上的标准。

$ ./regex.rb
#<MatchData "Jane">
0
#<MatchData "Jane">
Ruby

在所有三种情况下，都有一个匹配项。 match方法返回匹配的数据，如果不匹配，则返回nil。 =~运算符返回匹配文本的第一个字符，否则返回nil。

点字符

点字符是正则表达式字符，可与任何单个字符匹配。 请注意，必须有一些字符。 它可能不会被省略。

#!/usr/bin/ruby

p "Seven".match /.even/
p "even".match /.even/
p "eleven".match /.even/
p "proven".match /.even/
Ruby

在第一个示例中，我们将使用match方法对字符串应用正则表达式。 match方法成功返回匹配的数据，否则返回nil。

p "Seven".match /.even/
Ruby

“七个”是我们称为match方法的字符串。 该方法的参数是模式。 /.even/常规模式查找以任意字符开头，后跟“偶数”字符的文本。

$ ./dot.rb
#<MatchData "Seven">
nil
#<MatchData "leven">
nil
Ruby

从输出中，我们可以看到哪些字符串匹配，哪些不匹配。

就像我们上面说过的，如果有一个点字符，那么必须有一个任意字符。 不可省略。 如果我们要搜索可能会省略字符的文本怎么办？ 换句话说，我们想要一个既有“七个”又有“偶数”的模式。 为此，我们可以使用?重复字符。 ?重复字符表明前一个字符可能出现 0 次或 1 次。

#!/usr/bin/ruby

p "seven".match /.even/
p "even".match /.even/
p "even".match /.?even/
Ruby

该脚本使用?重复字符。

p "even".match /.even/
Ruby

该行打印nil，因为正则表达式期望在“偶数”字符串之前有一个字符。

p "even".match /.?even/
Ruby

在这里，我们对正则表达式进行了一些修改。 .?代表无字符或一个任意字符。 这次有一场比赛。

$ ./dot2.rb
#<MatchData "seven">
nil
#<MatchData "even">
Ruby

这是示例输出。

Ruby 正则表达式方法

在前两个示例中，我们使用match方法处理正则表达式。 除了 match 以外，其他方法也接受正则表达式作为参数。

#!/usr/bin/ruby

puts "motherboard" =~ /board/
puts "12, 911, 12, 111"[/\d{3}/]

puts "motherboard".gsub /board/, "land"

p "meet big deep nil need".scan /.[e][e]./
p "This is Sparta!".split(/\s/)
Ruby

该示例显示了一些可用于正则表达式的方法。

puts "motherboard" =~ /board/
Ruby

=~是一个运算符，将右侧的正则表达式应用于左侧的字符串。

puts "12, 911, 12, 111"[/\d{3}/]
Ruby

可以在字符串后的方括号之间放置正则表达式。 该行将打印第一个包含三位数的字符串。

puts "motherboard".gsub /board/, "land"
Ruby

使用gsub方法，我们将’board’字符串替换为’land’字符串。

p "meet big deep nil need".scan /.[e][e]./
Ruby

scan方法在字符串中查找匹配项。 它查找所有事件，而不仅仅是第一次。 该行将打印所有与模式匹配的字符串。

p "This is Sparta!".split(/\s/)
Ruby

split方法使用给定的正则表达式作为分隔符来拆分字符串。 \s字符类型代表任何空白字符。

$ ./apply.rb
6
911
motherland
["meet", "deep", "need"]
["This", "is", "Sparta!"]
Ruby

我们看到apply.rb脚本的输出。

Ruby 特殊变量

使用正则表达式的某些方法会激活一些特殊变量。 它们包含最后一个匹配的字符串，最后一个匹配之前的字符串和最后一个匹配之后的字符串。 这些变量使程序员的工作更加轻松。

#!/usr/bin/ruby

puts "Her name is Jane" =~ /name/

p `
p&
p $'
Ruby

该示例显示了三个特殊变量。

puts "Her name is Jane" =~ /name/
Ruby

在这一行中，我们有一个简单的正则表达式匹配。 我们在“她的名字叫简”句子中寻找一个“名字”字符串。 我们使用=~运算符。 该运算符还设置了三个特殊变量。 该行返回数字 4，这是比赛开始的位置。

p $`
Ruby

`$“特殊变量包含最后一个匹配项之前的文本。

p $&
Ruby

$&具有匹配的文本。

p $'
Ruby

$'变量包含最后一个匹配项之后的文本。

$ ./svars.rb
4
"Her "
"name"
" is Jane"
Ruby

这是示例的输出。

锚点

锚点匹配给定文本内字符的位置。 我们介绍了三个锚定字符。 ^字符与行的开头匹配。 $字符与行尾匹配。 \b字符与单词边界匹配。

#!/usr/bin/ruby

sen1 = "Everywhere I look I see Jane"
sen2 = "Jane is the best thing that happened to me"

p sen1.match /^Jane/ 
p sen2.match /^Jane/ 

p sen1.match /Jane/ 
p sen2.match /Jane/
Ruby

在第一个示例中，我们使用^和$锚定字符。

sen1 = "Everywhere I look I see Jane"
sen2 = "Jane is the best thing that happened to me"
Ruby

我们有两个句子。 “简”一词位于第一个字母的开头和第二个字母的结尾。

p sen1.match /^Jane/ 
p sen2.match /^Jane/
Ruby

在这里，我们查看单词“简”是否位于两个句子的开头。

p sen1.match /Jane/ 
p sen2.match /Jane/
Ruby

在这里，我们在句子的末尾查找文本的匹配项。

$ ./anchors.rb
nil
#<MatchData "Jane">
#<MatchData "Jane">
nil
Ruby

这些就是结果。

常见的要求是仅包含整个单词的匹配项。 默认情况下，我们会计算所有匹配项，包括匹配较大或复合词的匹配项。 让我们看一个例子来澄清问题。

#!/usr/bin/ruby

text = "The cat also known as the domestic cat is a small, 
usually furry, domesticated, carnivorous mammal."

p text.scan /cat/

p `
p&
p $'
Ruby

我们有一句话。 在这句话中，我们寻找一只猫。 使用scan，我们查找句子中的所有“ cat”字符串，而不仅仅是第一次出现。

text = "The cat also known as the domestic cat is a small, 
usually furry, domesticated, carnivorous mammal."
Ruby

问题在于文本内部有三个“ cat”字符串。 除了匹配提到哺乳动物的“猫”以外，/cat/还匹配“驯养”一词中的字母 8-10。 在这种情况下，这不是我们想要的。

$ ./boudaries.rb
["cat", "cat", "cat"]
"The cat also known as the domestic cat is a small, \nusually furry, domesti"
"cat"
"ed, carnivorous mammal."
Ruby

在下一个示例中，将使用\b定位符消除“驯化”上的最后一次匹配。

\b字符用于为我们要查找的单词设置边界。

#!/usr/bin/ruby

text = "The cat also known as the domestic cat is a small, 
usually furry, domesticated, carnivorous mammal."

p text.scan /\bcat\b/

p `
p&
p $'
Ruby

通过包含\b元字符来改进示例。

p text.scan /\bcat\b/
Ruby

通过上面的正则表达式，我们将“ cat”字符串作为整个单词来查找。 我们不计算子词。

$ ./boudaries2.rb
["cat", "cat"]
"The cat also known as the domestic "
"cat"
" is a small, \nusually furry, domesticated, carnivorous mammal."
Ruby

这次有两场比赛。 并且特殊变量可以正确显示最后一次匹配之前和之后的文本。

字符类

我们可以使用方括号将字符组合成字符类。 字符类与括号中指定的任何字符匹配。 /[ab]/模式表示 a 或 b，而/ab/模式表示 a 后跟 b。

#!/usr/bin/ruby

words = %w/ sit MIT fit fat lot pad /

pattern = /[fs]it/

words.each do |word|
   if word.match pattern
       puts "#{word} matches the pattern" 
   else
       puts "#{word} does not match the pattern" 
   end
end
Ruby

我们有六个六个三个字母的单词组成的数组。 我们对具有特定字符集的数组字符串应用正则表达式。

pattern = /[fs]it/
Ruby

这就是模式。 该模式在数组中查找“ fit”和“ sit”字符串。 我们使用字符集中的“ f”或“ s”。

$ ./classes.rb
sit matches the pattern
MIT does not match the pattern
fit matches the pattern
fat does not match the pattern
lot does not match the pattern
pad does not match the pattern
Ruby

有两场比赛。

在下一个示例中，我们将进一步探索字符类。

#!/usr/bin/ruby

p "car".match %r{[abc][a][rs]}
p "car".match /[a-r]+/
p "23af 433a 4ga".scan /\b[a-f0-9]+\b/
Ruby

该示例包含三个带有字符类的正则表达式。

p "car".match %r{[abc][a][rs]}
Ruby

此行中的正则表达式包含三个字符类。 每个都是一个字符。 [abc]是 a，b 或 c。 [a]只是一个。 第三个[rs]是 r 或 s。 与“ car”字符串匹配。

p "car".match /[a-r]+/
Ruby

我们可以在字符类中使用连字符-字符。 连字符是表示以下字符的元字符：此处的 a，b，c，d，e，f，g，h，i，j，k，l，m，n，o，p，q 或 r 。 由于字符类仅适用于一个字符，因此我们也使用+重复字符。 这表示字符集中的前一个字符可以重复一次或多次。 “汽车”琴弦满足这些条件。

p "23af 433a 4ga".scan /\b[a-f0-9]+\b/
Ruby

在这一行中，我们有一个包含三个子字符串的字符串。 使用scan方法，我们检查十六进制数。 我们有两个范围。 第一个[a-f]代表从 a 到 f 的字符。 第二个字符[0-9]代表数字 0 到 9。+指定这些字符可以重复多次。 最后，\b元字符创建边界，该边界仅接受仅包含这些字符的字符串。

$ ./classes2.rb
#<MatchData "car">
#<MatchData "car">
["23af", "433a"]
Ruby

如果字符类的第一个字符是插入号^，则该类被反转。 它匹配除指定字符以外的任何字符。

#!/usr/bin/ruby

p "ABC".match /[^a-z]{3}/
p "abc".match /[^a-z]{3}/
Ruby

在示例中，我们在字符类中使用插入符号。

p "ABC".match /[^a-z]{3}/
Ruby

我们寻找一个包含 3 个字母的字符串。 这些字母可能不是 a 到 z 的字母。 因为所有三个字符均为大写字符，所以“ ABC”字符串与正则表达式匹配。

p "abc".match /[^a-z]{3}/
Ruby

此“ abc”字符串不匹配。 所有三个字符都在搜索范围之外。

$ ./caret.rb
#<MatchData "ABC">
nil
Ruby

这里有示例输出。

量词

标记或组后的量词指定允许该前一个元素出现的频率。

 ?     - 0 or 1 match
 *     - 0 or more
 +     - 1 or more
 {n}   - exactly n
 {n,}  - n or more
 {,n}  - n or less (??)
 {n,m} - range n to m
Ruby

上面是常见量词的列表。

#!/usr/bin/ruby

p "seven dig moon car lot fire".scan /\w{3}/
p "seven dig moon car lot fire".scan /\b\w{3}\b/
Ruby

在该示例中，我们要选择具有三个字符的单词。 \w字符是文字​​字符，\w{3}表示 prevoius 文字字符的三倍。

p "seven dig moon car lot fire".scan /\w{3}/
Ruby

第一行只是从每个字符串中剪切前三个字符。 这不是我们想要的。

p "seven dig moon car lot fire".scan /\b\w{3}\b/
Ruby

这是一个改进的搜索。 我们将先前的模式放在\b边界元字符之间。 现在，搜索将仅找到具有三个字符的单词。

$ ./nchars.rb
["sev", "dig", "moo", "car", "lot", "fir"]
["dig", "car", "lot"]
Ruby

示例的输出。

{n,m}是具有 n 到 m 个字符的字符串的重复结构。

#!/usr/bin/ruby

p "I dig moon lottery it fire".scan /\b\w{2,4}\b/
Ruby

在上面的示例中，我们选择了具有两个，三个或四个字符的单词。 我们再次使用边界\b元字符来选择整个单词。

$ ./rchars.rb
["dig", "moon", "it", "fire"]
Ruby

该示例打印具有 2-4 个字符的单词数组。

在下一个示例中，我们将介绍?元字符。 后面跟有?的字符是可选的。 形式上，?前面的字符可以出现一次或 0 次。

#!/usr/bin/ruby

p "color colour colors colours".scan /colou?rs/
p "color colour colors colours".scan /colou?rs?/

p "color colour colors colours".scan /\bcolor\b|\bcolors\b|\bcolour\b|\bcolours\b/
Ruby

假设我们有一个文本，我们要在其中查找颜色词。 这个词有两个不同的拼写，英语为“ colour”和美国为“ color”。 我们希望找到这两种情况，而且我们也希望找到它们的复数形式。

p "color colour colors colours".scan /colou?rs/
Ruby

颜色模式可以同时找到“颜色”和“颜色”。 ?元字符之前的 u 字符是可选的。

p "color colour colors colours".scan /colou?rs?/
Ruby

颜色？ pattern 使 u 和 s 字符成为可选字符。 因此，我们找到了所有四种颜色组合。

p "color colour colors colours".scan /\bcolor\b|\bcolors\b|\bcolour\b|\bcolours\b/
Ruby

可以使用轮换来写相同的请求。

$ ./qmark.rb
["colors", "colours"]
["color", "colour", "colors", "colours"]
["color", "colour", "colors", "colours"]
Ruby

在本节的最后一个示例中，我们将显示+元字符。 它允许将前面的字符重复 1 次或更多次。

#!/usr/bin/ruby

nums = %w/ 234 1 23 53434 234532453464 23455636
    324f 34532452343452 343 2324 24221 34$34232/

nums.each do |num|
    m = num.match /[0-9]+/

    if m.to_s.eql? num
        puts num
    end              
end
Ruby

在示例中，我们有一个数字数组。 数字可以包含一个或多个数字字符。

nums = %w/ 234 1 23 53434 234532453464 23455636
    324f 34532452343452 343 2324 24221 34$34232/
Ruby

这是一个字符串数组。 其中两个不是数字，因为它们包含非数字字符。 必须将它们排除在外。

nums.each do |num|
    m = num.match /[0-9]+/

    if m.to_s.eql? num
        puts num
    end              
end
Ruby

我们遍历数组并将正则表达式应用于每个字符串。 表达式为[0-9]+，代表 0..9 中的任何字符，重复 0 次或多次。 默认情况下，正则表达式也会查找子字符串。 在 34 $ 34232 中，引擎将 34 视为数字。 \b边界在这里不起作用，因为我们没有具体的字符并且引擎不知道在哪里停止寻找。 这就是为什么我们在块中包含 if 条件的原因。 仅当匹配项等于原始字符串时，该字符串才被视为数字。

$ ./numbers.rb
234
1
23
53434
234532453464
23455636
34532452343452
343
2324
24221
Ruby

这些值是数字。

不区分大小写的搜索

我们可以执行不区分大小写的搜索。 正则表达式后面可以有一个选项。 它是单个字符，以某种方式修改了图案。 如果是不区分大小写的搜索，我们将应用 i 选项。

#!/usr/bin/ruby

p "Jane".match /Jane/
p "Jane".match /jane/
p "Jane".match /JANE/

p "Jane".match /jane/i
p "Jane".match /Jane/i
p "Jane".match /JANE/i
Ruby

该示例显示了区分大小写和不区分大小写的搜索。

p "Jane".match /Jane/
p "Jane".match /jane/
p "Jane".match /JANE/
Ruby

在这三行中，字符必须与模式完全匹配。 只有第一行给出了匹配项。

p "Jane".match /jane/i
p "Jane".match /Jane/i
p "Jane".match /JANE/i
Ruby

在这里，我们使用第二个/字符后面的 i 选项。 我们进行不区分大小写的搜索。 所有三行都匹配。

$ ./icase.rb
#<MatchData "Jane">
nil
nil
#<MatchData "Jane">
#<MatchData "Jane">
#<MatchData "Jane">
Ruby

交替

下一个示例说明了交替运算符|。 该运算符使您可以创建具有多种选择的正则表达式。

#!/usr/bin/ruby

names = %w/Jane Thomas Robert Lucy Beky
    John Peter Andy/

pattern = /Jane|Beky|Robert/ 

names.each do |name|    

    if name =~ pattern
        puts "#{name} is my friend"
    else
        puts "#{name} is not my friend"
    end
end
Ruby

名称数组中有 8 个名称。 我们将在该数组中寻找字符串的多个组合。

pattern = /Jane|Beky|Robert/
Ruby

这是搜索模式。 它说，简，贝基和罗伯特是我的朋友。 如果找到其中任何一个，就找到了我的朋友。

$ ./alternation.rb
Jane is my friend
Thomas is not my friend
Robert is my friend
Lucy is not my friend
Beky is my friend
John is not my friend
Peter is not my friend
Andy is not my friend
Ruby

在这里，我们看到了脚本的输出。

子模式

我们可以使用括号()在样式内创建子模式。

#!/usr/bin/ruby

p "bookworm" =~ /book(worm)?/
p "book" =~ /book(worm)?/
p "worm" =~ /book(worm)?/
p "bookstore" =~ /book(worm)?/
Ruby

我们有以下正则表达式模式：book(worm)?$。 (worm)是子模式。 只有两个字符串可以匹配：“ book”或“ bookworm”。 ?字符位于子模式之后，这意味着子模式在最终模式中可能会出现 0、1 次。 $字符在这里用于字符串的精确末尾匹配。 没有它，书店和 bookmania 这样的词也将匹配。

#!/usr/bin/ruby

p "book" =~ /book(shelf|worm)?/
p "bookshelf" =~ /book(shelf|worm)?/
p "bookworm" =~ /book(shelf|worm)?/
p "bookstore" =~ /book(shelf|worm)?/
Ruby

子模式经常与交替组合在一起以创建多个单词组合。 例如，book(shelf|worm)匹配“ bookshelf”和“ bookworm”，book(shelf|worm)?匹配“ bookshelf”，“ bookworm”和“ book”。

$ ./subpatterns2.rb
0
0
0
nil
Ruby

最后一个子模式不匹配。 请记住，0 并不意味着没有匹配。 对于=~运算符，它是匹配字符串的第一个字符的索引。

电子邮件示例

在最后一个示例中，我们创建一个用于检查电子邮件地址的正则表达式模式。

#!/usr/bin/ruby

emails = %w/ luke@gmail.com andy@yahoo.com 23214sdj^as
    f3444@gmail.com /

pattern = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9-]+\.[a-zA-Z.]{2,5}$/

emails.each do |email| 

    if email.match pattern
        puts "#{email} matches"
    else
        puts "#{email} does not match"
    end

end
Ruby

请注意，此示例仅提供一种解决方案。 它不一定是最好的。

emails = %w/ luke@gmail.com andy@yahoocom 23214sdj^as
    f3444@gmail.com /
Ruby

这是一系列电子邮件。 其中只有两个有效。

pattern = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9-]+\.[a-zA-Z.]{2,5}$/
Ruby

这就是模式。 这里的第一个^和最后一个$字符可得到精确的模式匹配。 模式前后不允许有字符。 电子邮件分为五个部分。

第一部分是本地部分。 这通常是公司，个人或昵称的名称。 [a-zA-Z0-9._-]+列出了我们可以在本地部分使用的所有可能字符。 它们可以使用一次或多次。 第二部分是文字@字符。 第三部分是领域部分。 通常是电子邮件提供商的域名：例如 yahoo 或 gmail。 字符集[a-zA-Z0-9-]+指定可以在域名中使用的所有字符。 +量词使

使用一个或多个这些字符。 第四部分是点字符。 它前面带有转义字符\。 这是因为点字符是一个元字符，并且具有特殊含义。 通过转义，我们得到一个文字点。 最后一部分是顶级域。 模式如下：[a-zA-Z.]{2,5}顶级域可以包含 2 到 5 个字符，例如 sk，net，info 或 travel。 还有一个点字符。 这是因为某些顶级域名（例如 co.uk）有两个部分。

$ ./email.rb
luke@gmail.com matches
andy@yahoocom does not match
23214sdj^as does not match
f3444@gmail.com matches
Ruby

正则表达式将两个字符串标记为有效的电子邮件地址。

您可能也会对以下相关教程感兴趣：正则表达式教程

Python教程

Python 教程

Python 教程
Tkinter 教程

Tkinter 教程
Pandas 教程

Pandas 教程
NumPy 教程

NumPy 教程
Flask 教程

Flask 教程
Django 教程

Django 教程
PySpark 教程

PySpark 教程
wxPython 教程

wxPython 教程
SymPy 教程

SymPy 教程
Seaborn 教程

Seaborn 教程
SciPy 教程

SciPy 教程
RxPY 教程

RxPY 教程
Pycharm 教程

Pycharm 教程
Pygame 教程

Pygame 教程
PyGTK 教程

PyGTK 教程
PyQt 教程

PyQt 教程
PyQt5 教程

PyQt5 教程
PyTorch 教程

PyTorch 教程
Matplotlib 教程

Matplotlib 教程
Web2py 教程

Web2py 教程
BeautifulSoup 教程

BeautifulSoup 教程

Java教程

Java 教程

Java 教程

Web教程

HTML 教程

HTML 教程
CSS 教程

CSS 教程
CSS3 教程

CSS3 教程
jQuery 教程

jQuery 教程
Ajax 教程

Ajax 教程
AngularJS 教程

AngularJS 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程
Laravel 教程

Laravel 教程
Next.js 教程

Next.js 教程
PhantomJS 教程

PhantomJS 教程
Three.js 教程

Three.js 教程
Underscore.JS 教程

Underscore.JS 教程
WebGL 教程

WebGL 教程
WebRTC 教程

WebRTC 教程
VueJS 教程

VueJS 教程

数据库教程

SQL 教程

SQL 教程
MySQL 教程

MySQL 教程
MongoDB 教程

MongoDB 教程
PostgreSQL 教程

PostgreSQL 教程
SQLite 教程

SQLite 教程
Redis 教程

Redis 教程
MariaDB 教程

MariaDB 教程

图形图像教程

Vulkan 教程

Vulkan 教程
OpenCV 教程

OpenCV 教程

大数据教程

R语言 教程

R语言 教程

开发工具教程

Git 教程

Git 教程
VSCode 教程

VSCode 教程
Docker 教程

Docker 教程
Gerrit 教程

Gerrit 教程
Excel 教程

Excel 教程

计算机教程

Go语言 教程

Go语言 教程
C++ 教程

C++ 教程

Ruby 教程

登录

找回密码？

注册