RegEx : 20 petites étapes pour maîtriser les expressions régulières. Partie 1

L'original de cet article est ici . Il n'y a probablement pas trop de théorie, et je fournirai plusieurs liens vers des documents plus détaillés sur les regex à la fin de l'article. Mais il m'a semblé que commencer à approfondir un sujet comme les expressions régulières serait beaucoup plus intéressant s'il y avait la possibilité non seulement de bachoter, mais aussi de consolider immédiatement les connaissances en accomplissant de petites tâches en cours de route. Commençons. Les opposants à l'utilisation d'expressions régulières (« RegEx » ou simplement « regex ») en programmation citent la citation suivante, attribuée à Jamie Zawinski : « Certaines personnes, confrontées à un problème, pensent : « Je sais, je vais utiliser des expressions régulières ». .'" Maintenant, ils ont deux problèmes". En fait, utiliser des expressions régulières n’est pas encore une bonne ou une mauvaise idée. Et cela en soi n’ajoutera pas de problèmes et n’en résoudra aucun. C'est juste un outil. Et la façon dont vous l’utilisez (bonne ou mauvaise) détermine les résultats que vous obtiendrez. Si vous essayez d'utiliser des expressions régulières, par exemple, pour créer un analyseur HTML, vous rencontrerez probablement des difficultés . Mais si vous souhaitez simplement extraire, par exemple, les horodatages de certaines chaînes, tout ira probablement bien. Pour vous permettre de maîtriser plus facilement les expressions régulières, j'ai élaboré cette leçon qui vous aidera à maîtriser les expressions régulières à partir de zéro en seulement vingt étapes courtes. Ce didacticiel se concentre principalement sur les concepts de base des expressions régulières et aborde des sujets plus avancés uniquement lorsque cela est nécessaire.

Étape 1 : Pourquoi utiliser des expressions régulières

Les expressions régulières sont utilisées pour rechercher des correspondances dans le texte à l'aide de modèles spécifiés (modèles). En utilisant regex, nous pouvons facilement et simplement extraire des mots du texte, ainsi que des caractères littéraux et méta individuels et leurs séquences qui répondent à certains critères. Voici ce que Wikipédia nous en dit : Les expressions régulières sont un langage formel permettant de rechercher et de manipuler des sous-chaînes dans un texte, basé sur l'utilisation de métacaractères (caractères génériques). Pour la recherche, un exemple de chaîne (modèle anglais, en russe on l'appelle souvent « modèle », « masque ») est utilisé, composé de symboles et de métasymboles et définissant la règle de recherche. Pour manipuler le texte, une chaîne de remplacement est en outre spécifiée, qui peut également contenir des caractères spéciaux. Le modèle peut être aussi simple que le mot dogdans cette phrase :

Le renard brun rapide saute par-dessus le chien paresseux.

Cette expression régulière ressemble à ceci :

chien

... Assez simple, n'est-ce pas ? Le motif peut également être n'importe quel mot contenant la lettre o. Une expression régulière permettant de trouver un tel modèle pourrait ressembler à ceci :

\ Ouah * _

( Vous pouvez essayer cette expression régulière ici .) Vous remarquerez qu'à mesure que les exigences de « correspondance » deviennent plus complexes, l'expression régulière devient également plus complexe. Il existe des formes supplémentaires de notation pour spécifier des groupes de caractères et faire correspondre des motifs répétitifs, que j'expliquerai ci-dessous. Mais dès que nous trouvons une correspondance avec un modèle dans un texte, que pouvons-nous en faire ? Les moteurs d'expressions régulières modernes vous permettent d'extraire des caractères ou des séquences de caractères (sous-chaînes) du texte contenu, de les supprimer ou de les remplacer par un autre texte. En général, les expressions régulières sont utilisées pour analyser et manipuler du texte. Nous pouvons extraire, par exemple, des sous-chaînes qui ressemblent à des adresses IP puis essayer de les vérifier. Ou nous pouvons extraire les noms et les adresses e-mail et les stocker dans une base de données. Vous pouvez également utiliser des expressions régulières pour rechercher des informations sensibles (telles que des numéros de passeport ou des numéros de téléphone) dans les e-mails et alerter l'utilisateur qu'il peut se mettre en danger. Regex est véritablement un outil polyvalent, facile à apprendre mais difficile à maîtriser : « Tout comme il y a une différence entre bien jouer un morceau de musique et créer de la musique, il y a une différence entre connaître les expressions régulières et les comprendre. » - Jeffrey E. F. Friedl, Maîtriser les expressions régulières

Étape 2 : crochets[]

Les expressions régulières les plus simples et faciles à comprendre sont celles qui recherchent simplement une correspondance caractère par caractère entre le modèle d'expression régulière et la chaîne cible. Essayons par exemple de trouver un chat :

motif : chat
chaîne : Le chat a été coupé lorsqu'il a couru sous la voiture.
correspondances :      ^^^

( Comment ça marche en pratique - voir ici ) Attention ! Toutes les solutions sont présentées ici uniquement à titre de solutions possibles. Dans les expressions régulières, comme dans la programmation en général, vous pouvez résoudre les mêmes problèmes de différentes manières. Cependant, en plus d'une comparaison stricte caractère par caractère, nous pouvons également spécifier des correspondances alternatives à l'aide de crochets :

modèle : ca[rt]
chaîne : Le chat a été coupé lorsqu'il a couru sous la voiture.
correspondances :      ^^^ ^^^

( Comment ça marche ) Les crochets ouvrants et fermants indiquent au moteur d'expression régulière qu'il doit correspondre à l'un des caractères spécifiés, mais à un seul. L'expression régulière ci-dessus ne trouvera pas, par exemple, le cartmot entier, mais n'en trouvera qu'une partie :

modèle : ca[rt]
chaîne : Le chat a été coupé lorsqu'il a couru sous le chariot.
correspondances :      ^^^ ^^^

( Comment ça marche ) Lorsque vous utilisez des crochets, vous indiquez au moteur d'expression régulière de ne faire correspondre qu'un seul des caractères contenus entre les crochets. Le moteur trouve le caractère c, puis le caractère a, mais si le caractère suivant n'est pas rou t, alors la correspondance n'est pas complète. S'il trouve ca, puis soit r, soit t, il s'arrête. Il n'essaiera pas de faire correspondre plus de caractères car les crochets indiquent qu'un seul des caractères contenus doit être mis en correspondance. Lorsqu'il trouve ca, il recherche rle mot suivant cartet s'arrête car il a déjà trouvé une correspondance pour la séquence car.

Objectifs de formation:

Écrivez une expression régulière qui correspond aux 10 modèles haddans Hadcet extrait de jeux de mots intraduisibles dans le dialecte local :

modèle:
chaîne : Jim, là où Bill avait eu "eu" , avait eu "avait eu" . « Avait eu » était correct.
correspondances :                  ^^^ ^^^ ^^^ ^^^ ^^^ ^^^ ^^^ ^^^ ^^^ ^^^

( Voir la solution possible ici ) Qu'en est-il de tous les noms d'animaux dans la phrase suivante ?

modèle:
chaîne : Une chauve-souris, un chat et un rat sont entrés dans un bar...
correspondances :    ^^^ ^^^ ^^^

( Solution possible ) Ou encore plus simple : trouvez les mots barou bat:

modèle:
chaîne : Une chauve-souris, un chat et un rat sont entrés dans un bar...
correspondances :    ^^^ ^^^

( Solution possible ) Maintenant, nous avons déjà appris à écrire des expressions régulières plus ou moins complexes, et nous n'en sommes qu'à l'étape 2 ! Nous allons continuer!

Étape 3 : séquences d'échappement

À l'étape précédente, nous avons découvert les crochets []et comment ils nous aident à trouver des correspondances alternatives à l'aide du moteur d'expression régulière. Mais que se passe-t-il si nous voulons trouver des correspondances sous la forme de crochets ouverts et fermés eux-mêmes []? Lorsque nous avons voulu trouver une correspondance caractère par caractère du mot cat, nous avons fourni au moteur d'expression régulière cette séquence de caractères ( cat). Essayons de trouver les crochets []de la même manière :

pattern : [] 
string : Vous ne pouvez pas faire correspondre [] en utilisant l'expression régulière ! Vous allez le regretter !
allumettes: 

( Voyons ce qui s'est passé ) Quelque chose n'a pas fonctionné, cependant... C'est parce que les caractères entre crochets agissent comme des caractères spéciaux du moteur d'expression régulière qui sont généralement utilisés pour indiquer autre chose, et ne constituent pas un modèle littéral pour les correspondre eux-mêmes. Comme nous nous en souvenons de l'étape 2, ils sont utilisés pour trouver des correspondances alternatives afin que le moteur d'expression régulière puisse faire correspondre n'importe lequel des caractères contenus entre eux. Si vous ne mettez aucun caractère entre eux, cela peut provoquer une erreur. Pour faire correspondre ces caractères spéciaux, il faut les échapper en les faisant précéder d'un caractère barre oblique inverse \. La barre oblique inverse (ou barre oblique inverse) est un autre caractère spécial qui indique au moteur d'expression régulière de rechercher littéralement le caractère suivant, plutôt que de l'utiliser comme métacaractère. Le moteur d'expression régulière ne recherchera que les caractères [et ]littéralement s'ils sont tous deux précédés d'une barre oblique inverse :

modèle: \[\]
string : Vous ne pouvez pas faire correspondre [] en utilisant une expression régulière ! Vous allez le regretter !
correspondances :                  ^^ 

( Voyons ce qui s'est passé cette fois ) OK, et si nous voulons trouver la barre oblique inverse elle-même ? La réponse est simple. Puisque la barre oblique inverse \est également un caractère spécial, il doit également être échappé. Comment? Barre oblique inverse !

modèle: \\
chaîne : C:\Utilisateurs\Tanja\Pictures\Dogs
correspondances :    ^ ^ ^ ^

( Même exemple en pratique ) Seuls les caractères spéciaux doivent être précédés d'une barre oblique inverse. Tous les autres caractères sont interprétés littéralement par défaut. Par exemple, l'expression régulière tne correspond littéralement qu'aux tlettres minuscules :

modèle: t
chaîne : tttt
correspondances : ^ ^ ^ ^

( Exemple ) Cependant, cette séquence \tfonctionne différemment. Il s'agit d'un modèle de recherche d'un caractère de tabulation :

modèle : \t
chaîne : tttt
correspondances :   ^ ^ ^

( Exemple ) Certaines séquences d'échappement courantes incluent \n(sauts de ligne de style UNIX) et \r(utilisés dans les sauts de ligne de style Windows \r\n). \rest un caractère de « retour chariot » et \nun caractère de « saut de ligne », tous deux définis avec la norme ASCII lorsque les téléscripteurs étaient encore largement utilisés. D'autres séquences d'échappement courantes seront abordées plus loin dans ce didacticiel.

En attendant, renforçons le matériel avec quelques énigmes simples :

Essayez d'écrire une expression régulière pour trouver... une expression régulière ;) Le résultat devrait ressembler à ceci :

modèle:
chaîne : ... faire correspondre cette expression régulière ` \[\] ` avec une expression régulière ?
correspondances :                       ^^^^	

( Solution ) Avez-vous réussi ? Bien joué! Essayez maintenant de créer une expression régulière pour rechercher des séquences d'échappement comme celle-ci :

modèle:
chaîne : ` \r `, ` \t ` et ` \n ` sont toutes des séquences d'échappement d'expression régulière.
correspondances :   ^^ ^^ ^^

( Solution )

Étape 4 : recherchez "n'importe quel" caractère à l'aide d'un point.

Lors de l'écriture des solutions de correspondance de séquence d'échappement que nous avons vues à l'étape précédente, vous vous êtes peut-être demandé : « Puis-je faire correspondre la barre oblique inverse, puis tout autre caractère qui le suit ? »... Bien sûr que vous pouvez ! Il existe un autre caractère spécial qui est utilisé pour correspondre à (presque) n'importe quel caractère : le caractère point (point). Voici ce que cela fait :

modèle: .
chaîne : je suis désolé, Dave. J'ai bien peur de ne pas pouvoir faire ça.
correspondances : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^	

( Exemple ) Si vous souhaitez uniquement faire correspondre des modèles qui ressemblent à des séquences d'échappement, vous pouvez faire quelque chose comme ceci :

modèle: \\. 
string : Salut Walmart, c'est mon petit-fils, il s'appelle " \n \r \t ".
correspondances :                                              ^^ ^^ ^^	

( Exemple ) Et, comme pour tous les caractères spéciaux, si vous souhaitez faire correspondre un littéral ., alors vous devez le faire précéder d'un caractère \:

modèle: \. 
chaîne : La guerre est la paix . La liberté est l'esclavage . L'ignorance est une force . 
correspondances :             ^ ^ ^

( Exemple )

Étape 5 : Gammes de caractères

Que se passe-t-il si vous n'avez besoin d'aucun symbole, mais souhaitez uniquement rechercher des lettres dans le texte ? Ou des chiffres ? Ou des voyelles ? La recherche par classes de personnages et leurs gammes nous permettra d'y parvenir.

` \n `, ` \r ` et ` \t ` sont des caractères d'espacement, ` \. `, ` \\ ` et ` \[ ` ne le sont pas .	

Les caractères sont des « espaces » s'ils ne créent pas de marque visible dans le texte. Un espace " " est un espace, un saut de ligne ou une tabulation. Disons que nous voulons trouver des séquences d'échappement qui représentent uniquement des caractères d'espacement \n, \ret \tdans le passage ci-dessus, mais pas d'autres séquences d'échappement. Comment pourrions-nous faire cela ?

motif : \\[nrt] 
chaîne : ` \n `, ` \r ` et ` \t ` sont des caractères d'espacement, ` \. `, ` \\ ` et ` \[ ` ne le sont pas .
correspondances :   ^^ ^^ ^^	

( Exemple ) Cela fonctionne, mais ce n'est pas une solution très élégante. Et si plus tard nous devions faire correspondre la séquence d'échappement pour le caractère "saut de page", \f? (Ce symbole est utilisé pour indiquer des sauts de page dans le texte.)

motif : \\[nrt] 
chaîne : ` \n `, ` \r `, ` \t ` et ` \f ` sont des caractères d'espacement, ` \. `, ` \\ ` et ` \[ ` ne le sont pas .
correspondances :   ^^ ^^ ^^	

( Solution qui ne fonctionne pas ) Avec cette approche, nous devons lister séparément chaque lettre minuscule que nous voulons faire correspondre, entre crochets. Un moyen plus simple de procéder consiste à utiliser des plages de caractères correspondant à n'importe quelle lettre minuscule :

pattern : \\[az] 
chaîne : ` \n `, ` \r `, ` \t ` et ` \f ` sont des caractères d'espacement, ` \. `, ` \\ ` et ` \[ ` ne le sont pas .
correspondances :   ^^ ^^ ^^ ^^	

( Et cela fonctionne déjà ) Les plages de caractères fonctionnent comme on peut s'y attendre, compte tenu de l'exemple ci-dessus. Placez des crochets autour de la première et de la dernière lettre que vous souhaitez faire correspondre, avec un trait d'union entre les deux. Par exemple, si vous souhaitez uniquement rechercher des « ensembles » de barre oblique inverse \et une lettre de aà m, vous pouvez procéder comme suit :

motif : \\[am] 
chaîne : ` \n `, ` \r `, ` \t ` et ` \f ` sont des caractères d'espacement, ` \. `, ` \\ ` et ` \[ ` ne le sont pas .
correspondances :                         ^^	

( Exemple ) Si vous souhaitez faire correspondre plusieurs plages, placez-les simplement bout à bout entre crochets :

motif : \\[a-gq-z] 
chaîne : ` \n `, ` \r `, ` \t ` et ` \f ` sont des caractères d'espacement, ` \. `, ` \\ ` et ` \[ ` ne le sont pas .
correspondances :         ^^ ^^ ^^	

( Exemple ) D'autres plages de caractères courantes incluent : A-Zet0-9

Essayons-les en pratique et résolvons quelques problèmes :

Les nombres hexadécimaux peuvent contenir des chiffres 0-9ainsi que des lettres A-F. Lorsqu'ils sont utilisés pour spécifier des couleurs, les codes hexadécimaux peuvent contenir un maximum de trois caractères. Créez une expression régulière pour rechercher les codes hexadécimaux valides dans la liste ci-dessous :

modèle:
chaîne : 1H8 4E2 8FF 0P1 T8B 776 42B G12
correspondances :      ^^^ ^^^ ^^^ ^^^	

( Solution ) À l'aide de plages de caractères, créez une expression régulière qui sélectionnera uniquement les consonnes minuscules (pas les voyelles, y compris y) dans la phrase ci-dessous :

modèle:chaîne
: Les murs du centre commercial sont totalement , totalement hauts . _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
correspondances :   ^ ^ ^^^ ^ ^^ ^ ^^ ^ ^ ^ ^^^ ^ ^ ^^^ ^ ^^	

( Solution )

Étape 6 : "non", signe circonflexe, signe circonflexe... symbole^

En réalité, il existe plus de 9 000 noms pour ce symbole :) Mais, par souci de simplicité, nous nous concentrerons peut-être sur « non ». Ma solution au dernier problème est un peu longue. Il fallait 17 caractères pour dire « obtenez tout l’alphabet sauf les voyelles ». Bien sûr, il existe un moyen plus simple de procéder. Le signe « non » ^nous permet de spécifier des caractères et des plages de caractères qui ne doivent pas correspondre à ceux spécifiés dans le modèle. Une solution plus simple au dernier problème ci-dessus consiste à trouver des caractères qui ne représentent pas des voyelles :

motif : [ ^ aeiou ] chaîne
:   Les murs du centre commercial sont totalement , totalement hauts . _ _ _ _ _ _ _ _ _ _ 
correspondances : ^^ ^^ ^^^^ ^^^^ ^^ ^^^ ^ ^^ ^ ^^^^^^ ^ ^^^^^ ^^^ 	

( Exemple ) Le signe « non » ^comme caractère le plus à gauche entre crochets []indique au moteur d'expression régulière de faire correspondre un (n'importe quel) caractère qui n'est pas entre crochets. Cela signifie que l'expression régulière ci-dessus correspond également à tous les espaces, points ., virgules ,et majuscules Tau début d'une phrase. Pour les exclure, on peut aussi les mettre entre crochets :

motif : [ ^ aeiou . , T ] chaîne 
: Les murs du centre commercial sont totalement hauts . _ _ _ _ _ _ _ _ _ _ _ _ 
correspondances :   ^ ^ ^^^ ^ ^^ ^ ^^ ^ ^ ^ ^^^ ^ ^ ^^^ ^ ^^	

( Exemple ) noteque dans ce cas, nous n'avons pas besoin d'échapper au point avec une barre oblique inverse, comme nous le faisions auparavant lorsque nous le recherchions sans utiliser de crochets. De nombreux caractères spéciaux entre crochets sont traités littéralement, y compris le caractère entre crochets ouvrant [– mais pas fermant – ](saurez-vous deviner pourquoi ?). Le caractère barre oblique inverse \n'est pas non plus interprété littéralement. Si vous souhaitez faire correspondre une barre oblique inverse littérale \à l'aide de crochets, vous devez l'échapper en la faisant précéder de la barre oblique inverse suivante \\. Ce comportement a été conçu pour que les caractères d'espacement puissent également être placés entre crochets pour la correspondance :

modèle : [\t]
chaîne : tttt
correspondances :   ^ ^ ^

( Exemple ) Le signe « non » ^peut également être utilisé avec des plages. Si je voulais capturer uniquement les caractères a, b, c, et , je pourrais faire quelque chose comme ceci x :yz

modèle : [abcxyz] 
chaîne :   abc defghijklmnopqrstuvw xyz 
correspondances : ^^^ ^^^

( Exemple ) ...ou, je pourrais préciser que je souhaite rechercher tout caractère qui n'est pas compris entre det w:

modèle : [^dw] 
chaîne :   abc defghijklmnopqrstuvw xyz 
correspondances : ^^^ ^^^

( Exemple ) Cependant,sois prudentavec pas" ^. Il est facile de penser "Eh bien, j'ai spécifié [^ b-f], donc je devrais avoir une lettre minuscule aou quelque chose après f. Ce n'est pas le cas. Cette expression régulière correspondra à tout caractère ne figurant pas dans cette plage, y compris les lettres, les chiffres, la ponctuation et les espaces.

modèle : [^dw] 
chaîne :   abc defg h . i , j - klmnopqrstuvw xyz 
correspond : ^^^ ^ ^ ^ ^ ^^^

( Exemple )

Mise à niveau des tâches :

Utilisez le signe « non » ^entre crochets pour faire correspondre tous les mots ci-dessous qui ne se terminent pas pary :

modèle:
chaîne : chien de jour porc foin tourbière baie ray frotter 
correspondances :      ^^^ ^^^ ^^^ ^^^	

( Solution ) Écrivez une expression régulière en utilisant une plage et un signe « non » ^pour trouver toutes les années entre 1977 et 1982 (inclus) :

modèle:
chaîne : 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984
correspondances :            ^^^^ ^^^^ ^^^^ ^^^^ ^^^^ ^^^^

( Solution ) Écrivez une expression régulière pour rechercher tous les caractères qui ne sont pas un signe « non »^ :

modèle:
chaîne :   abc1 ^ 23*() 
correspondances : ^^^^ ^^^^^	

( Solution )

Étape 7 : Classes de personnages

Les classes de caractères sont encore plus simples que les plages de caractères. Différents moteurs d'expressions régulières ont différentes classes disponibles, je ne couvrirai donc ici que les principales. (Vérifiez quelle version de regex vous utilisez, car il peut y en avoir plus - ou elles peuvent être différentes de celles présentées ici.) Les classes de caractères fonctionnent presque comme des plages, mais vous ne pouvez pas spécifier les valeurs « début » et « fin » : La classe de caractères « mot » \west particulièrement utile car ce jeu de caractères est souvent requis pour des identifiants valides (noms de variables, noms de fonctions, etc.) dans divers langages de programmation. Nous pouvons utiliser \wpour simplifier l’expression régulière que nous avons vue plus tôt :

pattern : \\[az] 
chaîne : ` \n `, ` \r `, ` \t ` et ` \f ` sont des caractères d'espacement, ` \. `, ` \\ ` et ` \[ ` ne le sont pas .
correspondances :   ^^ ^^ ^^ ^^	

En utilisant \won peut écrire ainsi :

motif : \\\w 
chaîne : ` \n `, ` \r `, ` \t ` et ` \f ` sont des caractères d'espacement, ` \. `, ` \\ ` et ` \[ ` ne le sont pas .
correspondances :   ^^ ^^ ^^ ^^	

( Exemple )

2 tâches pour la chance :

Comme vous et moi le savons, en Java, un identifiant (nom d'une variable, d'une classe, d'une fonction, etc.) ne peut commencer que par la lettre a- zA- Z, le signe dollar $ou le trait de soulignement _. ( le soulignement est, bien sûr, un mauvais style, mais le compilateur l'ignore, ndlr ). Le reste des caractères doit être des caractères "mots" \w. À l'aide d'une ou plusieurs classes de caractères, créez une expression régulière pour rechercher des identifiants Java valides parmi les séquences de trois caractères suivantes :

modèle:
chaîne :   __e 12 $ .x2 foo Barre de 3 mm
correspondances : ^^^ ^^^ ^^^ ^^^	

( Solution ) Les numéros de sécurité sociale américains (SSN) sont des nombres à 9 chiffres au format XXX-XX-XXXX, où chaque X peut être n'importe quel chiffre [0-9]. À l’aide d’une ou plusieurs classes de caractères, écrivez une expression régulière pour rechercher les SSN correctement formatés dans la liste ci-dessous :

modèle:
chaîne : 113-25=1902 182-82-0192 H23-_3-9982 1I1-O0-E38B
correspondances :              ^^^^^^^^^^^

( Solution ) RegEx : 20 petites étapes pour maîtriser les expressions régulières. Partie 2. 20 petites étapes pour maîtriser les expressions régulières. Partie 3. RegEx : 20 petites étapes pour maîtriser les expressions régulières. Partie 4.