Ruby 正則表達式 · ZetCode 中文系列教程

# Ruby 正則表達式 > 原文： [https://zetcode.com/lang/rubytutorial/regex/](https://zetcode.com/lang/rubytutorial/regex/) 在 Ruby 教程的這一部分中，我們將討論 Ruby 中的正則表達式。正則表達式用于文本搜索和更高級的文本操作。正則表達式內置在`grep`，`sed`等工具中；諸如 vi，emacs 之類的文本編輯器； Tcl，Perl，Python 等編程語言。 Ruby 也有對正則表達式的內置支持。從另一個角度來看，正則表達式語法構成了用于匹配文本的特定于域的語言。模式是一個正則表達式，用于定義我們正在搜索或操縱的文本。它由文本文字和元字符組成。該模式放置在兩個定界符內。在 Ruby 中，這些是`//`字符。它們通知正則表達式函數模式的開始和結束位置。以下是部分元字符列表： | | | | --- | --- | | `.` | 匹配任何單個字符。 | | `*` | 與前面的元素匹配零次或多次。 | | `[ ]` | 括號表達。與方括號內的字符匹配。 | | `[^ ]` | 匹配方括號中未包含的單個字符。 | | `^` | 匹配字符串中的起始位置。 | | `$` | 匹配字符串中的結束位置。 | | <code>|</code> | 備用運算符。 | `=~`運算符將正則表達式與字符串進行匹配，如果找到匹配項，則返回匹配項與字符串的偏移量，否則返回`nil`。 `Regexp`類用于開發正則表達式。還有兩種創建正則表達式的簡便方法。以下示例將顯示它們。 ```ruby #!/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 ``` 在以上兩行中，我們創建一個`Regexp`對象，其中包含一個簡單的正則表達式文本。使用`match`方法，我們將此正則表達式對象應用于`"Jane is hot"`句子。我們檢查句子中是否包含`"Jane"`一詞。 ```ruby p "Jane is hot" =~ /Jane/ p "Jane is hot".match %r{Jane} ``` 這兩行是相同的。兩個正斜杠//和% r {}字符是更冗長的第一種方式的簡寫。在本教程中，我們將使用正斜杠。這是許多語言的事實上的標準。 ```ruby $ ./regex.rb #<MatchData "Jane"> 0 #<MatchData "Jane"> ``` 在所有三種情況下，都有一個匹配項。 `match`方法返回匹配的數據，如果不匹配，則返回`nil`。 `=~`運算符返回匹配文本的第一個字符，否則返回`nil`。 ## 點字符點字符是正則表達式字符，可與任何單個字符匹配。請注意，必須有一些字符。它可能不會被省略。 ```ruby #!/usr/bin/ruby p "Seven".match /.even/ p "even".match /.even/ p "eleven".match /.even/ p "proven".match /.even/ ``` 在第一個示例中，我們將使用`match`方法對字符串應用正則表達式。 `match`方法成功返回匹配的數據，否則返回`nil`。 ```ruby p "Seven".match /.even/ ``` `"Seven"`是我們稱為`match`方法的字符串。該方法的參數是模式。 `/.even/`常規模式查找以任意字符開頭，后跟`"even"`字符的文本。 ```ruby $ ./dot.rb #<MatchData "Seven"> nil #<MatchData "leven"> nil ``` 從輸出中，我們可以看到哪些字符串匹配，哪些不匹配。就像我們上面說過的，如果有一個點字符，那么必須有一個任意字符。不可省略。如果我們要搜索可能會省略字符的文本怎么辦？換句話說，我們想要一個既有`"Seven"`又有`"even"`的模式。為此，我們可以使用`?`重復字符。 `?`重復字符表明前一個字符可能出現 0 次或 1 次。 ```ruby #!/usr/bin/ruby p "seven".match /.even/ p "even".match /.even/ p "even".match /.?even/ ``` 該腳本使用`?`重復字符。 ```ruby p "even".match /.even/ ``` 該行打印`nil`，因為正則表達式期望在`"even"`字符串之前有一個字符。 ```ruby p "even".match /.?even/ ``` 在這里，我們對正則表達式進行了一些修改。 `.?`代表無字符或一個任意字符。這次有一場比賽。 ```ruby $ ./dot2.rb #<MatchData "seven"> nil #<MatchData "even"> ``` 這是示例輸出。 ## Ruby 正則表達式方法在前兩個示例中，我們使用`match`方法處理正則表達式。除了`match`以外，其他方法也接受正則表達式作為參數。 ```ruby #!/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" ``` 使用`gsub`方法，我們將'board'字符串替換為'land'字符串。 ```ruby p "meet big deep nil need".scan /.[e][e]./ ``` `scan`方法在字符串中查找匹配項。它查找所有事件，而不僅僅是第一次。該行將打印所有與模式匹配的字符串。 ```ruby p "This is Sparta!".split(/\s/) ``` `split`方法使用給定的正則表達式作為分隔符來拆分字符串。 `\s`字符類型代表任何空白字符。 ```ruby $ ./apply.rb 6 911 motherland ["meet", "deep", "need"] ["This", "is", "Sparta!"] ``` 我們看到`apply.rb`腳本的輸出。 ## Ruby 特殊變量使用正則表達式的某些方法會激活一些特殊變量。它們包含最后一個匹配的字符串，最后一個匹配之前的字符串和最后一個匹配之后的字符串。這些變量使程序員的工作更加輕松。 ```ruby #!/usr/bin/ruby puts "Her name is Jane" =~ /name/ p $` p $& p $' ``` 該示例顯示了三個特殊變量。 ```ruby puts "Her name is Jane" =~ /name/ ``` 在這一行中，我們有一個簡單的正則表達式匹配。我們在`"Her name is Jane"`句子中尋找一個`"name"`字符串。我們使用`=~`運算符。該運算符還設置了三個特殊變量。該行返回數字 4，這是比賽開始的位置。 ```ruby p $` ``` `$``特殊變量包含最后一個匹配項之前的文本。 ```ruby p $& ``` `$&`具有匹配的文本。 ```ruby p $' ``` `$'`變量包含最后一個匹配項之后的文本。 ```ruby $ ./svars.rb 4 "Her " "name" " is Jane" ``` 這是示例的輸出。 ## 錨點錨點匹配給定文本內字符的位置。我們介紹了三個錨定字符。 `^`字符與行的開頭匹配。 `$`字符與行尾匹配。 `\b`字符與單詞邊界匹配。 ```ruby #!/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" ``` 我們有兩個句子。 `"Jane"`一詞位于第一個字母的開頭和第二個字母的結尾。 ```ruby p sen1.match /^Jane/ p sen2.match /^Jane/ ``` 在這里，我們查看單詞`"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 $' ``` 我們有一句話。在這句話中，我們尋找一只貓。使用`scan`，我們查找句子中的所有`"cat"`字符串，而不僅僅是第一次出現。 ```ruby text = "The cat also known as the domestic cat is a small, usually furry, domesticated, carnivorous mammal." ``` 問題在于文本內部有三個`"cat"`字符串。除了匹配提到哺乳動物的`"cat"`以外，`/cat/`還匹配`"domesticated"`一詞中的字母 8-10。在這種情況下，這不是我們想要的。 ```ruby $ ./boudaries.rb ["cat", "cat", "cat"] "The cat also known as the domestic cat is a small, \nusually furry, domesti" "cat" "ed, carnivorous mammal." ``` 在下一個示例中，將使用`\b`定位符消除`"domesticated"`上的最后一次匹配。 `\b`字符用于為我們要查找的單詞設置邊界。 ```ruby #!/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 $' ``` 通過包含`\b`元字符來改進示例。 ```ruby p text.scan /\bcat\b/ ``` 通過上面的正則表達式，我們將`"cat"`字符串作為整個單詞來查找。我們不計算子詞。 ```ruby $ ./boudaries2.rb ["cat", "cat"] "The cat also known as the domestic " "cat" " is a small, \nusually furry, domesticated, carnivorous mammal." ``` 這次有兩場比賽。并且特殊變量可以正確顯示最后一次匹配之前和之后的文本。 ## 字符類我們可以使用方括號將字符組合成字符類。字符類與括號中指定的任何字符匹配。 `/[ab]/`模式表示`a`或`b`，而`/ab/`模式表示`a`后跟`b`。 ```ruby #!/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/ ``` 這就是模式。該模式在數組中查找`"fit"`和`"sit"`字符串。我們使用字符集中的`"f"`或`"s"`。 ```ruby $ ./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]} ``` 此行中的正則表達式包含三個字符類。每個都是一個字符。 `[abc]`是`a`，`b`或`c`。 `[a]`只是一個。第三個`[rs]`是`r`或`s`。與`"car"`字符串匹配。 ```ruby p "car".match /[a-r]+/ ``` 我們可以在字符類中使用連字符-字符。連字符是表示以下字符的元字符：此處的`a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q`或`r`。由于字符類僅適用于一個字符，因此我們也使用`+`重復字符。這表示字符集中的前一個字符可以重復一次或多次。 `"car"`字符串滿足這些條件。 ```ruby p "23af 433a 4ga".scan /\b[a-f0-9]+\b/ ``` 在這一行中，我們有一個包含三個子字符串的字符串。使用`scan`方法，我們檢查十六進制數。我們有兩個范圍。第一個`[a-f]`代表從 a 到 f 的字符。第二個字符`[0-9]`代表數字 0 到 9。`+`指定這些字符可以重復多次。最后，`\b`元字符創建邊界，該邊界僅接受僅包含這些字符的字符串。 ```ruby $ ./classes2.rb #<MatchData "car"> #<MatchData "car"> ["23af", "433a"] ``` This is the example output. 如果字符類的第一個字符是插入號`^`，則該類被反轉。它匹配除指定字符以外的任何字符。 ```ruby #!/usr/bin/ruby p "ABC".match /[^a-z]{3}/ p "abc".match /[^a-z]{3}/ ``` 在示例中，我們在字符類中使用插入符號。 ```ruby p "ABC".match /[^a-z]{3}/ ``` 我們尋找一個包含 3 個字母的字符串。這些字母可能不是`a`到`z`的字母。因為所有三個字符均為大寫字符，所以`"ABC"`字符串與正則表達式匹配。 ```ruby p "abc".match /[^a-z]{3}/ ``` 此`"abc"`字符串不匹配。所有三個字符都在搜索范圍之外。 ```ruby $ ./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/ ``` 在該示例中，我們要選擇具有三個字符的單詞。 `\w`字符是文字??字符，`\w{3}`表示之前文字字符的三倍。 ```ruby p "seven dig moon car lot fire".scan /\w{3}/ ``` 第一行只是從每個字符串中剪切前三個字符。這不是我們想要的。 ```ruby p "seven dig moon car lot fire".scan /\b\w{3}\b/ ``` 這是一個改進的搜索。我們將先前的模式放在`\b`邊界元字符之間。現在，搜索將僅找到具有三個字符的單詞。 ```ruby $ ./nchars.rb ["sev", "dig", "moo", "car", "lot", "fir"] ["dig", "car", "lot"] ``` 示例的輸出。 `{n,m}`是具有`n`到`m`個字符的字符串的重復結構。 ```ruby #!/usr/bin/ruby p "I dig moon lottery it fire".scan /\b\w{2,4}\b/ ``` 在上面的示例中，我們選擇了具有兩個，三個或四個字符的單詞。我們再次使用邊界`\b`元字符來選擇整個單詞。 ```ruby $ ./rchars.rb ["dig", "moon", "it", "fire"] ``` 該示例打印具有 2-4 個字符的單詞數組。在下一個示例中，我們將介紹`?`元字符。后面跟有`?`的字符是可選的。形式上，`?`前面的字符可以出現一次或 0 次。 ```ruby #!/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/ ``` 假設我們有一個文本，我們要在其中查找顏色詞。這個詞有兩個不同的拼寫，英語為`"colour"`和美國為`"color"`。我們希望找到這兩種情況，而且我們也希望找到它們的復數形式。 ```ruby p "color colour colors colours".scan /colou?rs/ ``` 顏色模式可以同時找到`"color"`和`"colour"`。 `?`元字符之前的`u`字符是可選的。 ```ruby p "color colour colors colours".scan /colou?rs?/ ``` `colou?rs?`模式串使`u`和`s`字符成為可選字符。因此，我們找到了所有四種顏色組合。 ```ruby 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"] ``` This is the example output. 在本節的最后一個示例中，我們將顯示`+`元字符。它允許將前面的字符重復 1 次或更多次。 ```ruby #!/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 ``` 我們遍歷數組并將正則表達式應用于每個字符串。表達式為`[0-9]+`，代表`0..9`中的任何字符，重復 0 次或多次。默認情況下，正則表達式也會查找子字符串。在`34$34232`中，引擎將 34 視為數字。 `\b`邊界在這里不起作用，因為我們沒有具體的字符并且引擎不知道在哪里停止尋找。這就是為什么我們在塊中包含`if`條件的原因。僅當匹配項等于原始字符串時，該字符串才被視為數字。 ```ruby $ ./numbers.rb 234 1 23 53434 234532453464 23455636 34532452343452 343 2324 24221 ``` 這些值是數字。 ## 不區分大小寫的搜索我們可以執行不區分大小寫的搜索。正則表達式后面可以有一個選項。它是單個字符，以某種方式修改了模式串。如果是不區分大小寫的搜索，我們將應用`i`選項。 ```ruby #!/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 ``` 在這里，我們使用第二個`/`字符后面的`i`選項。我們進行不區分大小寫的搜索。所有三行都匹配。 ```ruby $ ./icase.rb #<MatchData "Jane"> nil nil #<MatchData "Jane"> #<MatchData "Jane"> #<MatchData "Jane"> ``` This is the output of the example. ## 交替下一個示例說明了交替運算符`|`。該運算符使您可以創建具有多種選擇的正則表達式。 ```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 ``` 名稱數組中有 8 個名稱。我們將在該數組中尋找字符串的多個組合。 ```ruby 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)?$/ ``` 我們有以下正則表達式模式：`book(worm)?$`。 `(worm)`是子模式。只有兩個字符串可以匹配：`"book"`或`"bookworm"`。 `?`字符位于子模式之后，這意味著子模式在最終模式中可能會出現 0、1 次。 `$`字符在這里用于字符串的精確末尾匹配。沒有它，`bookstore`和`bookmania`這樣的詞也將匹配。 ```ruby #!/usr/bin/ruby p "book" =~ /book(shelf|worm)?$/ p "bookshelf" =~ /book(shelf|worm)?$/ p "bookworm" =~ /book(shelf|worm)?$/ p "bookstore" =~ /book(shelf|worm)?$/ ``` 子模式經常與交替組合在一起以創建多個單詞組合。例如，`book(shelf|worm)`匹配`"bookshelf"`和`"bookworm"`，`book(shelf|worm)?`匹配`"bookshelf"`，`"bookworm"`和`"book"`。 ```ruby $ ./subpatterns2.rb 0 0 0 nil ``` 最后一個子模式不匹配。請記住，0 并不意味著沒有匹配。對于`=~`運算符，它是匹配字符串的第一個字符的索引。 ## 電子郵件示例在最后一個示例中，我們創建一個用于檢查電子郵件地址的正則表達式模式。 ```ruby #!/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}$/ ``` 這就是模式。這里的第一個`^`和最后一個`$`字符可得到精確的模式匹配。模式前后不允許有字符。電子郵件分為五個部分。第一部分是本地部分。這通常是公司，個人或昵稱的名稱。 `[a-zA-Z0-9._-]+`列出了我們可以在本地部分使用的所有可能字符。它們可以使用一次或多次。第二部分是文字`@`字符。第三部分是領域部分。通常是電子郵件提供商的域名：例如 yahoo 或 gmail。字符集`[a-zA-Z0-9-]+`指定可以在域名中使用的所有字符。 `+`量詞使使用一個或多個這些字符。第四部分是點字符。它前面帶有轉義字符`\`。這是因為點字符是一個元字符，并且具有特殊含義。通過轉義，我們得到一個文字點。最后一部分是頂級域。模式如下：`[a-zA-Z.]{2,5}`頂級域可以包含 2 到 5 個字符，例如`sk, net, info, travel`。還有一個點字符。這是因為某些頂級域名（例如`co.uk`）有兩個部分。 ```ruby $ ./email.rb luke@gmail.com matches andy@yahoocom does not match 23214sdj^as does not match f3444@gmail.com matches ``` 正則表達式將兩個字符串標記為有效的電子郵件地址。在本章中，我們介紹了 Ruby 中的正則表達式。