Share
Ruby est l’un des langages les plus utilisés sur le Web. Nous avons commencé ici une nouvelle session sur Nettuts + qui vous présentera Ruby, ainsi que les formidables cadres et outils associés au développement de Ruby. Dans cette leçon, nous verrons comment utiliser l'expression régulière en Ruby..
Si vous connaissez les expressions régulières, sachez que la syntaxe utilisée pour l'écriture des expressions régulières est très semblable à celle que vous connaissez en PHP, JavaScript ou [votre langue ici]..
Si vous n'êtes pas familier avec les expressions régulières, vous voudrez peut-être consulter nos didacticiels Regex ici sur Nettuts + pour vous mettre à jour..
Comme tout le reste de Ruby, les expressions régulières sont des objets réguliers: elles sont des exemples de Regexp classe. Cependant, vous allez généralement créer une expression régulière avec la syntaxe standard, littérale:
/ myregex / / \ (\ d 3 \) \ d 3 - \ d 4 /
Pour commencer, le moyen le plus simple d’utiliser une expression rationnelle est de l’appliquer à une chaîne et de voir s’il existe une correspondance. Les deux chaînes et les objets regexp ont un rencontre méthode qui fait ceci:
"(123) 456-7890" .match / \ (\ d 3 \) \ d 3 - \ d 4 / / \ (\ d 3 \) \ d 3 - \ d 4 /. Match "(123) 456-7890"
Ces deux exemples correspondent, et nous allons donc obtenir un MatchData par exemple de retour (nous allons regarder MatchData objets bientôt). S'il n'y a pas de correspondance, rencontre reviendra néant. Parce qu'un MatchData objet évaluera à vrai, vous pouvez utiliser le rencontre méthode dans les instructions conditionnelles (comme une instruction if), et ignorez simplement que vous obtenez une valeur de retour.
Il existe une autre méthode que vous pouvez utiliser pour faire correspondre regexp avec des chaînes: c'est la = ~ (l'opérateur equals-tilde). Rappelez-vous que les opérateurs sont des méthodes en Ruby. Comme rencontre, cette méthode retourne néant sur aucun match. Cependant, s'il y a correspondance, il renverra la position numérique de la chaîne où la correspondance a commencé. Aussi comme match, les deux chaînes et les expressions régulières ont = ~.
"Ruby For Newbies: Expressions régulières" = ~ / Nouveau / # => 9
Les expressions régulières deviennent plus utiles lorsque nous extrayons des données. Cela se fait généralement avec des groupements: en enveloppant certaines parties de l'expression régulière entre parenthèses. Supposons que nous voulions faire correspondre un prénom, un nom de famille et une profession dans une chaîne, la chaîne étant ainsi formatée:
str1 = "Joe Schmo, plombier" str2 = "Stephen Harper, Premier ministre"
Pour obtenir les trois champs, nous allons créer cette expression rationnelle:
re = / (\ w *) \ s (\ w *), \ s? ([\ w \ s] *) /
Cela correspond à un nombre quelconque de caractères de mots, à certains espaces, à un nombre quelconque de mots, à une virgule, à des espaces optionnels et à un nombre quelconque de caractères ou d'espaces. Comme vous pouvez le deviner, les parties comprenant des caractères de mots font référence aux noms ou à la profession que nous recherchons, elles sont donc entourées de parenthèses..
Alors, exécutons ceci:
match1 = str1.match re match2 = str2.match re
Maintenant, notre match1 et match2 les variables tiennent MatchData objets (parce que nos deux correspondances ont été réussies). Voyons comment nous pouvons utiliser ces MatchData objets.
En passant à travers cela, vous remarquerez qu’il existe différentes façons d’obtenir les mêmes données de nos MatchData objet. Commençons par la chaîne correspondante: si vous voulez voir quelle chaîne a été comparée à l'expression rationnelle, utilisez la commande chaîne méthode. Vous pouvez également utiliser le [] (crochets) et passez le paramètre 0:
match1.string # => "Joe Schmo, plombier" match1 [0] # (identique à match1. [] 0) => "Joe Schmo, plombier"
Qu'en est-il de l'expression régulière elle-même? Vous pouvez trouver cela avec le expression rationnelle méthode.
match1.regex # => wsw, s [ws] (il s'agit du moyen unique utilisé par IRB pour afficher les expressions régulières; il fonctionnera toujours normalement)
Maintenant, que diriez-vous d’obtenir ces groupes appariés qui étaient le but de cet exercice? Tout d'abord, nous pouvons les obtenir avec des index numérotés sur le MatchData l'objet lui-même; bien sûr, ils sont dans l'ordre dans lequel nous les avons mis en correspondance:
match1 [1] # => "Joe" match1 [2] # => "Schmo" match1 [3] # => "Plombier" match2 [1] # => "Stephen" match2 [2] # => "Harper" match2 [3] # => "Premier ministre"
Il y a en fait une autre façon d'obtenir ces captures: c'est avec la propriété array capture; puisqu'il s'agit d'un tableau, il est basé sur zéro.
match1.captures [0] # => "Joe" match2.captures [2] # => "Premier ministre"
Croyez-le ou non, il existe en réalité une troisième façon d'obtenir vos captures. Quand vous exécutez rencontre ou = ~, Ruby remplit une série de variables globales, une pour chacun des groupes capturés dans votre expression rationnelle:
"Andrew Burgess" .match / (\ w *) \ s (\ w *) / # renvoie un objet MatchData, mais nous ignorons que $ 1 # => "Andrew" $ 2 # => "Burgess"
Retour à MatchData objets. Si vous voulez connaître l’index de chaîne d’une capture donnée, transmettez le nombre de captures à la commencer fonction (ici, vous voulez le numéro de capture tel que vous l’utiliseriez avec le [] méthode, pas via capture). Alternativement, vous pouvez utiliser fin pour voir quand cette capture se termine.
m = "Nettuts + est le meilleur" .match / (is) (le) / m [1] # => "est" m.begin 1 # => 8 m [2] # => "fin" m.end 2 # => 14
Il y a aussi le pré-match et post_match méthodes, qui sont plutôt bien nettes: cela vous montre quelle partie de la chaîne est venue avant et après le match, respectivement.
# m d'en haut m.pre_match # => "Nettuts +" m.post_match # => "best"
Cela couvre à peu près les bases du travail avec les expressions régulières en Ruby.
Comme les expressions régulières sont très utiles lors de la manipulation de chaînes, vous trouverez plusieurs méthodes de chaîne qui en tirent parti. Les plus utiles sont probablement les méthodes de substitution. Ceux-ci inclus
Accentsconagua
soussous!gsubgsub!Ce sont pour la substitution et la substitution globale, respectivement. La différence est que gsub remplace toutes les instances de notre modèle, tandis que sous remplace uniquement la première instance de la chaîne.
Voici comment nous les utilisons:
"une chaîne" .sub / chaîne /, "message" # => "un message" "L'homme dans le parc" .gsub / le /, "a" # => "un homme dans un parc"
Comme vous le savez peut-être, les méthodes Bang (celles qui se terminent par un point d'exclamation!) Sont des méthodes destructives: elles modifient les objets chaîne réels au lieu de les renvoyer maintenant. Par exemple:
original = "Mon nom est Andrew." new = original.sub / Mon nom est /, "Bonjour, je suis" original # => Mon nom est Andrew. "nouveau # =>" Bonjour, je suis Andrew "original =" Qui êtes-vous? "original. sub! / Qui sont /, "Et" original # => "Et vous?"
Outre ces exemples simples, vous pouvez faire des choses plus complexes, comme ceci:
"1234567890" .sub / (\ d 3) (\ d 3) (\ d 4) /, '(\ 1) \ 2- \ 3' # => "(123) 456-7890 "
Nous n'obtenons pas MatchData objets ou les variables globales avec les méthodes de substitution; Cependant, nous pouvons utiliser le? backslash-number? motif dans la chaîne de remplacement, si nous l'enveloppons entre guillemets simples. Si vous souhaitez manipuler davantage la chaîne capturée, vous pouvez transmettre un bloc au lieu du deuxième paramètre:
"Que se passe-t-il?". Gsub (/ \ S * /) | s | s.downcase # => "que se passe-t-il?"
Il existe de nombreuses autres fonctions qui utilisent des expressions régulières. si vous êtes intéressé, vous devriez vérifier Chaîne # scan et String # split, pour commencer.
Nous allons que ce sont des expressions régulières en Ruby pour vous. Si vous avez des questions, écoutons-les dans les commentaires..
