Expressions régulières Ruby


L'expression régulière est une séquence spéciale de caractères qui correspond ou trouve un ensemble de chaînes à l'aide d'un modèle avec une syntaxe spécialisée.

Les expressions régulières utilisent des caractères spécifiques prédéfinis et des combinaisons de ces caractères spécifiques pour former une "chaîne de règles". Cette "chaîne de règles" est utilisée pour exprimer une logique de filtrage des chaînes.

Syntaxe

Expression régulière est littéralement un motif entre des barres obliques ou entre des délimiteurs suivant %r , comme indiqué ci-dessous :

/pattern/
/pattern/im    # 可以指定选项
%r!/usr/local! # 使用分隔符的正则表达式

Instance

#!/usr/bin/ruby

line1 = "Cats are smarter than dogs";
line2 = "Dogs also like meat";

if ( line1 =~ /Cats(.*)/ )
  puts "Line1 contains Cats"
end
if ( line2 =~ /Cats(.*)/ )
  puts "Line2 contains  Dogs"
end


Le résultat de l'exécution de l'exemple ci-dessus est :

Line1 contains Cats

Modificateur d'expression régulière

Les expressions régulières peuvent littéralement contenir un modificateur facultatif qui contrôle divers aspects de l’appariement. Le modificateur est spécifié après le deuxième caractère barre oblique, comme indiqué dans l'exemple ci-dessus. Les modificateurs possibles sont répertoriés en indices :

修饰符描述
i当匹配文本时忽略大小写。
o只执行一次 #{} 插值,正则表达式在第一次时就进行判断。
x忽略空格,允许在整个表达式中放入空白符和注释。
m匹配多行,把换行字符识别为正常字符。
u,e,s,n把正则表达式解释为 Unicode(UTF-8)、EUC、SJIS 或 ASCII。如果没有指定修饰符,则认为正则表达式使用的是源编码。

Tout comme les chaînes sont délimitées par %Q, Ruby vous permet de démarrer une expression régulière avec %r, suivi de n'importe quel délimiteur. Ceci est utile lorsque les descriptions contiennent de nombreuses barres obliques auxquelles vous ne souhaitez pas échapper.

# 下面匹配单个斜杠字符,不转义
%r|/|               

# Flag 字符可通过下面的语法进行匹配
%r[</(.*)>]i

Modèle d'expression régulière

À l'exception du caractère de contrôle, (+ ? . * ^ $ ( ) [ ] { } | ), tous les autres caractères correspondent à lui-même. Vous pouvez échapper les caractères de contrôle en plaçant une barre oblique inverse avant le caractère de contrôle.

Le tableau suivant répertorie la syntaxe des expressions régulières disponibles dans Ruby.

Motif Description
^ correspond au début d'une ligne.
$ correspond à la fin de la ligne.
. correspond à n'importe quel caractère, à l'exception des sauts de ligne. Lorsque vous utilisez l'option m, elle peut également correspondre aux nouvelles lignes.
[...] correspond à n'importe quel caractère unique entre crochets.
[^...] correspond à tout caractère non placé entre crochets.
re* correspond à la sous-expression précédente zéro ou plusieurs fois.
re+ correspond à la sous-expression précédente une ou plusieurs fois.
re? Correspond à la sous-expression précédente zéro ou une fois.
re{ n} correspond à la sous-expression précédente n fois.
re{ n,} correspond à la sous-expression précédente n fois ou plus.
re{ n, m> Correspond à la sous-expression précédente au moins n fois et au plus m fois.
a| b correspond à a ou b.
(re)Regroupez les expressions régulières et n'oubliez pas de faire correspondre le texte.
(?imx)Activez temporairement l'option i, m ou x dans une expression régulière. S'il est entre parenthèses, seule la partie située à l'intérieur des parenthèses est affectée.
(?-imx)Désactivez temporairement l'option i, m ou x dans une expression régulière. S'il est entre parenthèses, seule la partie située à l'intérieur des parenthèses est affectée.
(?: re) Regroupe les expressions régulières sans mémoriser le texte correspondant.
(?imx: re)Activez temporairement l'option i, m ou x entre parenthèses.
(?-imx: re)Désactivez temporairement les options i, m ou x entre parenthèses.
(?#...)Commentaires.
(?= re)Spécifiez la position à l'aide d'un motif. Il n’y a aucune portée.
(?! re)Précisez la position à l'aide de la négation du motif. Il n’y a aucune portée.
(?> re) correspond à un modèle autonome sans revenir en arrière.
w correspond aux caractères des mots.
W correspond aux caractères autres que des mots.
s correspond aux caractères d'espacement. Équivalent à [tnrf].
S correspond aux caractères autres que des espaces.
dMatch les numéros. Équivalent à [0-9].
D correspond aux non-chiffres.
A correspond au début d'une chaîne.
Z correspond à la fin de la chaîne. Si un caractère de nouvelle ligne existe, correspond uniquement au caractère de nouvelle ligne.
z correspond à la fin de la chaîne.
G Correspond au dernier point où le match est terminé.
b correspond à une limite de mot lorsqu'elle est en dehors des parenthèses et à la touche de retour arrière (0x08) lorsqu'elle est entre parenthèses.
B correspond aux limites autres que les mots.
n, t, etc. correspond aux nouvelles lignes, aux retours chariot, aux tabulations, etc.
1...9correspond à la nième sous-expression groupée.
10S'il correspond déjà, correspond à la nième sous-expression groupée.Sinon, pointe vers la représentation octale du codage des caractères.

Exemple d'expression régulière

Caractère

ExempleDescription
实例描述
/ruby/匹配 "ruby"
¥匹配 Yen 符号。Ruby 1.9 和 Ruby 1.8 支持多个字符。
/ruby/

Match "ruby"

实例描述
/[Rr]uby/匹配 "Ruby" 或 "ruby"
/rub[ye]/匹配 "ruby" 或 "rube"
/[aeiou]/匹配任何一个小写元音字母
/[0-9]/匹配任何一个数字,与 /[0123456789]/ 相同
/[a-z]/匹配任何一个小写 ASCII 字母
/[A-Z]/匹配任何一个大写 ASCII 字母
/[a-zA-Z0-9]/匹配任何一个括号内的字符
/[^aeiou]/匹配任何一个非小写元音字母的字符
/[^0-9]/匹配任何一个非数字字符
¥

correspond au symbole du yen. Ruby 1.9 et Ruby 1.8 prennent en charge plusieurs caractères.

实例描述
/./匹配除了换行符以外的其他任意字符
/./m在多行模式下,也能匹配换行符
/d/匹配一个数字,等同于 /[0-9]/
/D/匹配一个非数字,等同于 /[^0-9]/
/s/匹配一个空白字符,等同于 /[ trnf]/
/S/匹配一个非空白字符,等同于 /[^ trnf]/
/w/匹配一个单词字符,等同于 /[A-Za-z0-9_]/
/W/匹配一个非单词字符,等同于 /[^A-Za-z0-9_]/

实例描述
/ruby?/匹配 "rub" 或 "ruby"。其中,y 是可有可无的。
/ruby*/匹配 "rub" 加上 0 个或多个的 y。
/ruby+/匹配 "rub" 加上 1 个或多个的 y。
/d{3}/刚好匹配 3 个数字。
/d{3,}/匹配 3 个或多个数字。
/d{3,5}/匹配 3 个、4 个或 5 个数字。
Classe de caractères<🎜><🎜>
ExempleDescription
/[Rr]uby/<🎜>Match "Rubis" ou "rubis"<🎜><🎜>< tr>/rub[ye]/<🎜> correspond à "ruby" ou "rube" <🎜><🎜>
/[aeiou]/<🎜> correspond à n'importe quel Une voyelle minuscule <🎜><🎜>
/[0-9]/<🎜> correspond à n'importe quel nombre, ce qui est identique à /[0123456789]/<🎜><🎜>
/[a-z]/<🎜> Correspond à n'importe quelle lettre ASCII minuscule <🎜><🎜>
/[A-Z]/<🎜> Correspond à n'importe quelle lettre ASCII majuscule <🎜 ><🎜>
/[a-zA-Z0-9]/<🎜>correspond à n'importe quel caractère entre parenthèses<🎜><🎜>
/[ ^aeiou]/ <🎜>correspond à tout caractère qui n'est pas une voyelle minuscule<🎜><🎜>
/[^0-9]/<🎜>correspond à tout caractère qui n'est pas une minuscule voyelle Caractères numériques<🎜><🎜><🎜><🎜><🎜>Classes de caractères spéciaux<🎜><🎜>
ExempleDescription
/./<🎜>Faire correspondre n'importe quel caractère à l'exception des sauts de ligne<🎜><🎜>
/./m<🎜>En mode multiligne, il peut également faire correspondre les caractères de nouvelle ligne<🎜><🎜>
/d/<🎜>correspond à un numéro , équivalent à /[0-9]/<🎜><🎜>
/D/<🎜> Correspond à un non-chiffre, équivalent à /[^0-9]/<🎜> <🎜>
/s/<🎜> correspond à un caractère d'espacement, équivalent à /[ trnf]/<🎜><🎜>
/S/<🎜> Correspond à un caractère autre qu'un espace, équivalent à /[^ trnf]/<🎜><🎜>
/w/<🎜> Correspond à un caractère de mot, équivalent à /[A-Za- z0 -9_]/<🎜><🎜>
/W/<🎜> correspond à un caractère autre qu'un mot, équivalent à /[^A-Za-z0-9_]/<🎜> <🎜 ><🎜><🎜><🎜>Répéter<🎜><🎜>
Instance Description
/ruby?/<🎜> Correspond à "rub" ou "ruby". Parmi eux, y est facultatif. <🎜><🎜>
/ruby*/<🎜> Correspond à "rub" plus 0 ou plus y. <🎜><🎜>
/ruby+/<🎜> Correspond à "rub" plus 1 ou plusieurs y. <🎜><🎜>
/d{3}/<🎜> correspond exactement à 3 nombres. <🎜><🎜>
/d{3,}/<🎜> Correspond à 3 nombres ou plus. <🎜><🎜>
/d{3,5}/<🎜>Match 3, 4 ou 5 numéros. <🎜><🎜><🎜><🎜>

Répétition non gourmande

Cela correspondra au nombre minimum de répétitions.

实例描述
/<.*>/贪婪重复:匹配 "<ruby>perl>"
/<.*?>/非贪婪重复:匹配 "<ruby>perl>" 中的 "<ruby>"

Grouper par parenthèses

实例描述
/Dd+/无分组: + 重复 d
/(Dd)+/分组: + 重复 Dd 对
/([Rr]uby(, )?)+/匹配 "Ruby"、"Ruby, ruby, ruby",等等

Référence arrière

Cela correspondra à nouveau au groupe précédemment apparié.

实例描述
/([Rr])uby&1ails/匹配 ruby&rails 或 Ruby&Rails
/(['"])(?:(?!1).)*1/单引号或双引号字符串。1 匹配第一个分组所匹配的字符,2 匹配第二个分组所匹配的字符,依此类推。

remplace

实例描述
/ruby|rube/匹配 "ruby" 或 "rube"
/rub(y|le))/匹配 "ruby" 或 "ruble"
/ruby(!+|?)/"ruby" 后跟一个或多个 ! 或者跟一个 ?

ancre

qui nécessite de préciser la position correspondante.

实例描述
/^Ruby/匹配以 "Ruby" 开头的字符串或行
/Ruby$/匹配以 "Ruby" 结尾的字符串或行
/ARuby/匹配以 "Ruby" 开头的字符串
/RubyZ/匹配以 "Ruby" 结尾的字符串
/bRubyb/匹配单词边界的 "Ruby"
/brubB/B 是非单词边界:匹配 "rube" 和 "ruby" 中的 "rub",但不匹配单独的 "rub"
/Ruby(?=!)/如果 "Ruby" 后跟着一个感叹号,则匹配 "Ruby"
/Ruby(?!!)/如果 "Ruby" 后没有跟着一个感叹号,则匹配 "Ruby"

Syntaxe spéciale pour les parenthèses

实例描述
/R(?#comment)/匹配 "R"。所有剩余的字符都是注释。
/R(?i)uby/当匹配 "uby" 时不区分大小写。
/R(?i:uby)/与上面相同。
/rub(?:y|le))/只分组,不进行 1 反向引用

Rechercher et remplacer

sub et gsub et leurs substitutionssub ! et gsub! sont des méthodes de chaîne importantes lorsque vous travaillez avec des expressions régulières.

Toutes ces méthodes effectuent des opérations de recherche et de remplacement à l'aide de modèles d'expressions régulières. sub et sub! remplacent la première occurrence du motif, et gsub et gsub! remplacent toutes les occurrences du motif.

sub et gsub renvoient une nouvelle chaîne, laissant la chaîne d'origine inchangée, tandis que sub! et gsub! modifiera la chaîne sur laquelle ils sont appelés.

Ce qui suit est un exemple :

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

phone = "138-3453-1111 #这是一个电话号码"

# 删除 Ruby 的注释
phone = phone.sub!(/#.*$/, "")   
puts "电话号码 : #{phone}"

# 移除数字以外的其他字符
phone = phone.gsub!(/\D/, "")    
puts "电话号码 : #{phone}"


Le résultat de l'exemple ci-dessus est :

电话号码 : 138-3453-1111 
电话号码 : 13834531111

Ce qui suit est un autre exemple :

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

text = "rails 是 rails,  Ruby on Rails 非常好的 Ruby 框架"

# 把所有的 "rails" 改为 "Rails"
text.gsub!("rails", "Rails")

# 把所有的单词 "Rails" 都改成首字母大写
text.gsub!(/\brails\b/, "Rails")

puts "#{text}"


Le résultat de sortie de l'exemple ci-dessus est :

Rails 是 Rails,  Ruby on Rails 非常好的 Ruby 框架