Expressions régulières de base — les motifs de grep

Un outil pour tester tes regex

Tu peux aussi essayer les motifs de cet article dans le Testeur de regex qui tourne dans le navigateur. Il montre où ton motif correspond dans ton texte d'entrée, sur-le-champ.

Expressions régulières de base — ^ $ . * []

Une expression régulière est une façon de décrire un motif dans du texte. grep interprète la chaîne que tu cherches comme une expression régulière, ce qui te permet de trouver des lignes par des conditions comme « commence par ce caractère » ou « un caractère quelconque ici », et pas seulement par une chaîne fixe. Les 5 symboles à apprendre pour les expressions régulières de base sont ^, $, ., * et [].

^ et $ sont des ancres pour le début et la fin d'une ligne. . correspond à un caractère quelconque, et * signifie zéro répétition ou plus du caractère précédent. [abc] correspond à l'un des caractères entre les crochets, et [a-z] correspond à une minuscule par intervalle. Combine-les pour des recherches flexibles.

echo -e 'cat\ncot\ndog' > words.txt   # crée le matériel
grep '^c' words.txt                       # cat et cot, qui commencent par c
grep 't$' words.txt                       # cat et cot, qui finissent par t
grep 'c.t' words.txt                      # cat et cot qui correspondent à c?t

① Crée un fichier de matériel de 3 lignes avec echo -e 'cat\ncot\ndog' > words.txt.

② Passe à grep un motif avec l'ancre de début de ligne et affiche uniquement les lignes qui commencent par c.

③ Ensuite, avec un motif utilisant l'ancre de fin de ligne, affiche les lignes qui finissent par t.

④ Enfin, avec un motif qui place le symbole du caractère quelconque au milieu, affiche les lignes où il y a un caractère entre c et t. (Lance-le correctement et une explication apparaîtra.)

Répétition et classes de caractères — * et []

* signifie zéro répétition ou plus du caractère précédent. ab*c correspond aux lignes où il y a zéro b ou plus, comme ac, abc et abbc. [] correspond à l'un des caractères entre les crochets, donc [cb]at attrape à la fois cat et bat. Écrire un intervalle comme [a-z] représente une minuscule.

echo -e 'ac\nabc\nabbc\naxc' > rep.txt   # crée le matériel
grep 'ab*c' rep.txt                       # ac abc abbc, avec zéro b ou plus
echo -e 'cat\nbat\nrat' > cls.txt      # crée le matériel
grep '[cb]at' cls.txt                     # les 2 lignes cat et bat

① Crée du matériel pour vérifier la répétition avec echo -e 'ac\nabc\nabbc\naxc' > rep.txt.

② Passe à grep un motif utilisant le symbole de zéro répétition ou plus du caractère précédent, et affiche les lignes où il peut y avoir autant de b que tu veux entre a et c.

③ Crée du matériel pour vérifier les classes de caractères avec echo -e 'cat\nbat\nrat' > cls.txt.

④ Avec un motif utilisant la classe de caractères entre crochets, affiche uniquement cat et bat.

Ou — correspondre à l'un ou l'autre avec \|

Dans les expressions régulières de base, | (ou) est traité tel quel comme un caractère ordinaire.

Pour exprimer l'alternance, ajoute une barre oblique inverse et écris \|, donc grep 'cat\|dog' correspond aux lignes contenant cat ou dog.

Avec grep -E, que tu apprendras plus loin, tu peux écrire | directement au lieu de \|.

echo -e 'cat\ndog\nfox' > sel.txt   # crée le matériel
grep 'cat\|dog' sel.txt              # les 2 lignes contenant cat ou dog

① Crée un fichier de matériel de 3 lignes avec echo -e 'cat\ndog\nfox' > sel.txt.

② Pour exprimer « ou » dans les expressions régulières de base, ajoute une barre oblique inverse à |. Passe à grep le motif 'cat\|dog' et affiche les lignes contenant cat ou dog.

③ Confirme que fox n'est pas affiché car il ne correspond ni à l'un ni à l'autre.

Regex étendues et affichage de la correspondance — grep -E / grep -o

Dans les expressions régulières de base, + | ( ) doivent être échappés, comme \+ \| \( \), mais avec grep -E tu peux les écrire directement. grep -E active les expressions régulières étendues (ERE). Tu peux désormais écrire + (un ou plus), | (ou) et () (groupe) directement, là où la regex de base les exigeait échappés. grep -E 'cat|dog' correspond aux lignes contenant cat ou dog.

grep -o affiche uniquement la sous-chaîne correspondante, et non la ligne entière. S'il y a plusieurs correspondances sur une ligne, il les affiche chacune sur sa propre ligne. C'est pratique quand tu veux extraire d'un log juste les correspondances et les compter.

Des regex plus avancées

grep -P (regex compatible Perl) est une extension de GNU grep. Dans ce cours tu apprends les expressions régulières de base (^ $ . * []), grep -E pour activer les regex étendues, et grep -o pour n'afficher que la correspondance. Ils fonctionnent de la même façon sur n'importe quel Linux.

echo -e 'cat\ndog\nfox' > animals.txt   # crée le matériel
grep -E 'cat|dog' animals.txt              # les 2 lignes cat ou dog
echo -e 'ac\nabc\nabbc' > plus.txt      # crée le matériel
grep -E 'ab+c' plus.txt                    # abc abbc, avec un b ou plus
echo -e 'cat cat dog' > line.txt         # crée le matériel
grep -o cat line.txt                       # affiche chaque cat correspondant sur sa propre ligne

① Crée un fichier de matériel avec echo -e 'cat\ndog\nfox' > animals.txt.

② Ajoute à grep l'option qui active les regex étendues et affiche les lignes contenant soit cat soit dog.

③ Crée du matériel avec echo -e 'ac\nabc\nabbc' > plus.txt, et avec la regex étendue grep -E 'ab+c', affiche les lignes avec un b ou plus.

④ Crée du matériel avec plusieurs mots sur une ligne avec echo -e 'cat cat dog' > line.txt.

⑤ Ajoute à grep l'option qui n'affiche que la correspondance, cherche cat, et confirme que chaque mot correspondant sort sur sa propre ligne.

Filtrer la sortie d'une commande — | grep

grep peut chercher non seulement dans un fichier donné en argument mais aussi dans la sortie d'une autre commande passée par un pipe |.

Canalise le résultat de ls ou de cat dans | grep pour le réduire aux seules lignes dont tu as besoin.

ls cmds | grep '^c' affiche uniquement les noms qui commencent par c dans le listing du répertoire cmds, et cat fichier | grep mot filtre le contenu d'un fichier de la même façon.

mkdir -p cmds                                # petit répertoire de matériel
touch cmds/cat cmds/cut cmds/sort            # prépare 3 noms
ls cmds | grep '^c'                          # cat et cut, qui commencent par c
echo -e 'apple\nbanana\ncherry' > fruit.txt   # crée le matériel
cat fruit.txt | grep an                      # seulement banana, qui contient an

① Prépare un petit répertoire de matériel avec mkdir -p cmds et touch cmds/cat cmds/cut cmds/sort.

② Canalise la sortie de ls cmds dans grep avec | et affiche uniquement les noms qui commencent par c.

③ Crée du matériel de 3 lignes avec echo -e 'apple\nbanana\ncherry' > fruit.txt, puis canalise la sortie de cat fruit.txt dans | grep et affiche uniquement les lignes contenant an.