Les expressions régulières sous Linux : introduction, syntaxe et exemples.

Dans le vaste panorama de Linux, un outil se démarque par sa polyvalence et son pouvoir : les expressions régulières. Que vous soyez un novice curieux ou un habitué de l’écosystème Linux, cet article est votre point de départ pour comprendre et maîtriser les expressions régulières.

Introduction

Les Expressions Régulières : Qu’est-ce que c’est ?

Les expressions régulières, souvent appelées « regex » ou « regexp », sont des séquences de caractères qui définissent un modèle de texte. Ce modèle peut être utilisé pour rechercher, extraire et manipuler du texte de manière sophistiquée. Imaginez avoir une loupe spéciale qui vous permet de fouiller dans un océan de données textuelles avec une précision incroyable. Les expressions régulières sont cette loupe.

L’Importance des Expressions Régulières dans le Monde Linux

Dans le monde Linux, où la ligne de commande et la manipulation de texte règnent en maîtres, les expressions régulières sont un atout de premier plan. Elles permettent de rechercher, extraire, valider et transformer le texte avec une précision chirurgicale. Administrateurs système, développeurs, ou enthousiastes de Linux, l’apprentissage des expressions régulières est une voie vers la productivité et la créativité.

Aperçu du Contenu à Venir

Au cours de cet article, nous plongerons dans l’univers des expressions régulières sous Linux, en commençant par les bases cruciales. Nous explorerons la syntaxe fondamentale, les métacaractères clés et la manière dont ces éléments s’emboîtent pour créer des modèles de recherche. Ensuite, nous mettrons ces connaissances en pratique en explorant des exemples concrets, illustrant comment appliquer les expressions régulières dans diverses situations, de la recherche de texte à la transformation avancée.

Cependant, notre exploration ne s’arrêtera pas là. À mesure que nous progresserons, nous plongerons dans des exemples plus avancés, notamment l’utilisation de groupes de capture pour extraire des informations spécifiques, l’application de quantificateurs pour gérer les répétitions et des astuces pour rendre vos expressions régulières encore plus flexibles et puissantes.

Les fondamentaux des expressions régulières

Les expressions régulières sont un outil puissant pour naviguer dans le monde du texte sous Linux. Avant de plonger dans des exemples concrets, il est essentiel de comprendre les bases de leur syntaxe. Dans ce chapitre, nous allons explorer les éléments fondamentaux des expressions régulières à travers des explications claires et des exemples pratiques.

Les Métacaractères : Blocs de Construction des Expressions Régulières

Au cœur des expressions régulières se trouvent les métacaractères, des caractères spéciaux qui permettent de définir des motifs complexes. Voici quelques-uns des métacaractères les plus couramment utilisés :

Les métacaractères les plus courants

Exemples simples d’utilisation des métacaractères

Prenons comme exemple un simple fichier texte brut contenant une liste d’utilisateurs (prénom nom) (liste générée aléatoirement sur base de noms et prénoms francophones):

Emma Dubois
Louis Leroy
Léa Martin
Gabriel Dupont
Clara Rousseau
Adam Chevalier
Chloé Girard
Arthur Lambert
Manon Bernard
Lucas Mercier
Camille Moreau
Hugo Gauthier
Jade Fournier
Léo Martinez
Zoé Lefebvre
Noah Petit
Emma Simon
Théo Laurent
Inès Dubois
Liam Thomas
Lola Dubois
Nathan Roux
Léna Dupuis
Lucas Bonnet
Sarah Leclerc
Enzo Robin
Léa Michel
Mathis Caron
Thomas Marchand
Sacha Giraud
Maëlys Dupont
Ethan Blanc
Manon Martin
Yanis Dubois
Léa Lemoine
Timéo Renaud
Zoé David
Hugo Martinez
Inès Petit
Mathéo Lambert

Exemple n°1

Commençons par extraire les personnes qui se nomment « Thomas » (soit le nom soit le prénom). Pour cela nous allons utiliser la commande grep, je reviendrai plus en détail sur son utilisation ultérieurement.

steve@just-sudo-it:~$ grep -e 'Thomas' users.txt
Liam Thomas
Thomas Marchand
steve@just-sudo-it:~$

Exemple n°2

Si nous ne voulons que les utilisateurs dont le prénom est « Thomas », nous pouvons ici rechercher les lignes qui commencent par « Thomas » et pour cela nous utilisons le métacaractère ^.

steve@just-sudo-it:~$ grep -e '^Thomas' users.txt
Thomas Marchand
steve@just-sudo-it:~$

Exemple n°3

Et inversement nous pouvons choisir que les utilisateurs dont le nom de famille est « Thomas » en sélectionnant les lignes qui terminent par ce même nom grâce au métacaractère $.

steve@just-sudo-it:~$ grep -e 'Thomas$' users.txt
Liam Thomas
steve@just-sudo-it:~$

Exemple n°4

Si nous voulons sélectionner les utilisateurs dont le nom de famille termine par « er », nous pouvons écrire ceci:

steve@just-sudo-it:~$ grep -e '.*er$' users.txt
Adam Chevalier
Lucas Mercier
Hugo Gauthier
Jade Fournier
steve@just-sudo-it:~$

Ici nous avons utilisé plusieurs métacaractères, analysons cette expression régulière morceau par morcea:

• .* : correspond à 0 ou plusieurs occurrence de n’importe quel caractère en dehors d’une nouvelle ligne.
• er : correspond à « er » (difficile de faire plus simple).
• $ : indique que c’est la fin de la ligne.

Exemple n°5

Dernier exemple, si nous voulons sélectionner les utilisateurs dont le prénom commence par un « L » et le nom de famille commence par « Ma », nous pouvons écrire ceci:

steve@just-sudo-it:~$ grep -e '^L.*\sMa.*$' users.txt
Léa Martin
Léo Martinez
steve@just-sudo-it:~$

En détail:

• ^L : signifie que la ligne doit commencer par « L ».
• .* : correspond à 0 ou plusieurs occurrence de n’importe quel caractère en dehors d’une nouvelle ligne.
• \s : correspond à un espace (ou n’importe quel caractère vide)
• Ma : correspond à « Ma » (le début du nom de famille)
• .* : correspond à 0 ou plusieurs occurrence de n’importe quel caractère en dehors d’une nouvelle ligne.
• $ : indique que c’est la fin de la ligne.

Les quantificateurs

Les quantificateurs sont des métacaractères dont le but est de quantifier un élément dans une expression régulière. Nous en avons déjà cité et utilisé certains comme *, + et ?. Mais il est également possible d’utiliser des valeurs numériques pour quantifier un élément dans une regex.

Liste des principaux quantificateurs

Mise en pratique des quantificateurs

Toujours dans notre liste d’utilisateurs, nous pouvons sélectionner les utilisateurs dont le prénom est composé d’au moins 6 lettres:

steve@just-sudo-it:~$ grep -E '^[a-zA-Z]{6,}\s' users.txt
Gabriel Dupont
Arthur Lambert
Camille Moreau
Nathan Roux
Mathis Caron
Thomas Marchand
Maëlys Dupont
Mathéo Lambert
steve@just-sudo-it:~$

Remarque: ici grep a été utilisé avec l’option -E au lie de -e. Sans cette option les quantificateurs ne seraient pas correctement évalués.

De nouveau, analysons cette regex:

• ^[a-zA-Z]{6,} : Correspond à une ligne qui commence par au minimum 6 caractères dans la liste de a à z et A à Z.
• \s : Correspond à un espace.

Notez que ici même si on ne les as pas spécifié dans la séquence [a-zA-Z], les caractères accentués correspondront également.

Les séquences de caractères

Dans le précédent exemple nous avons utilisé une séquence de caractère incluant toutes les lettres de l’alphabet en minuscule et en majuscule que nous avons écrit [a-zA-Z]. Voyons maintenant ce que nous avons à notre disposition pour décrique des séquences de caractères. Il existe des séquences prédéfinies et comme nous l’avons fait juste avant des séquences personnalisées.

Les principales séquences de caractères

Mise en pratique des séquences de caractères

Exemple n°1

Sélectionnons les utilisateurs dont le prénom commence soit par « A » soit par « C »:

steve@just-sudo-it:~$ grep -E '^[AC]' users.txt
Clara Rousseau
Adam Chevalier
Chloé Girard
Arthur Lambert
Camille Moreau
steve@just-sudo-it:~$

Exemple n°2

Sélectionnons les utilisateurs dont le prénom comporte trois lettres.

steve@just-sudo-it:~$ grep -E '^\w{3}\s' users.txt
Léa Martin
Léo Martinez
Zoé Lefebvre
Léa Michel
Léa Lemoine
Zoé David
steve@just-sudo-it:~$

Quelques exemples pratiques

Extraire des information avec la commande « grep »

Comme nous l’avons déjà expérimenté, grep prend en entrée du texte et fourni en sortie les lignes correspondant à l’expression spécifiée. Nous pouvons l’utiliser directement sur un fichier ou même sur la sortie d’une autre commande à l’aide d’un pipe.

Problème n°1 : Extraire de /etc/passwd les lignes correspondant aux « vrais » utilisateurs

Pour rappel chaque entrée du fichier /etc/passwd (et donc chaque utilisateur) a la structure suivante:

nom_utilisateur:mot_de_passe:id:groupe:nom_complet:home:shell

Nous savons aussi que l’id 0 est réservé à root et que les id 1 à 999 sont réservés pour des utilisateurs du systèmes. Nous avons donc besoin de chercher les lignes qui indiquent un id de 1000 ou plus. Nous ne pouvons pas simplement dire > 1000, par contre nous pouvons décrire la structure d’un nombre de 1000 ou plus. C’est à dire un nombre qui commence par un chiffre entre 1 et 9 suivi d’au moins trois chiffres (0 compris cette fois).

steve@just-sudo-it:~$ grep -E '^.*:x:[1-9][0-9]{3,}' /etc/passwd
nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin
steve:x:1000:1000:Steve De Jongh:/home/steve:/bin/bash
steve@just-sudo-it:~$

En détail:

• ^.*: : Doit commencer par une série de caractères quelconques suivi de :
• x: : Suivi d’un x et de : (x étant le champs du mot de passe, puisque de nos jours les mots de passe ne sont plus stockés dans ce fichier.
• [1-9][0-9]{3,} : suivi d’un chiffre entre 1 et 9 et ensuite d’au moins trois chiffres quelconques.

Problème n°2 : Récupérer les entêtes (Hx) dans une page HTML.

Pour récupérer le contenu d’une page html, nous allons utiliser la commande curl qui permet de faire une requête HTTP et d’en afficher le résultat. Nous utiliserons le site example.com comme exemple !

curl example.com

Vous obtenez alors dans votre terminal l’ensemble du code HTML de la page. Nous pouvons ensuite utiliser un pipe pour récupérer la sortie de curl et l’envoyer à grep.

curl example.com | grep -oP 'expression'

L’utilisation de l’option -o de grep nous permettra de ne récupérer que le partie qui correspond à l’expression, sans le cotenu de la ligne qui ne nous intéresse pas. L’option -P nous permet d’utiliser les expression régulière compatible Perl (donc le \d par exemple).

Nous devons maintenant récupérer une structure qui correspond à la suivante:

<hx>n'importe quoi comme texte</hx>

Si le code HTML est correct, les balises d’ouverture et de fermeture doivent avoir le même niveau.

steve@just-sudo-it:~$ curl -s example.com | grep -oP '<[hH](\d)>.*</[hH]\1>'
<h1>Example Domain</h1>
steve@just-sudo-it:~$

Quelques mots d’explications:

• <[hH](\d)> : représente la balise d’ouverture et correspondra avec n’importe quel niveau (h1, h2, …). Les parenthèses permettent de créer un groupe de capture auquel nous ferons référence plus loin.
• .* : n’importe quel contenu.
• </[hH]\1> : représente la balise de fermeture. Le \1 signifie qu’on veut la même valeur que dans le premier groupe de capture. Donc si on a <h1> on s’attend à avoir </h1>.

D’autres applications des expressions régulières

Bien que grep soit sans doute la commande la plus connue qui utilise les expressions régulières, d’autres outils en tirent profit pour faire leur boulot.

Je ne vais pas rentrer dans les détails des commandes suivantes, mais je voulais toutefois ouvrir quelques portes et vous donner une meilleure vision de l’intérêt des regex.

Filtrer et remplacer avec « sed ».

Pour l’exemple ici, nous repartons sur notre fichier user.txt, et à l’aide de sed, nous allons afficher une nouvelle version des données sous la forme nom;prenom;email. Les addresses mail étant générées depuis les nom et prénoms:

steve@just-sudo-it:~$ sed -E 's/^(\w+)\s(\w+)/\2;\1;\2.\1@example.com/' users.txt
Dubois;Emma;Dubois.Emma@example.com
Leroy;Louis;Leroy.Louis@example.com
Martin;Léa;Martin.Léa@example.com
Dupont;Gabriel;Dupont.Gabriel@example.com
Rousseau;Clara;Rousseau.Clara@example.com
Chevalier;Adam;Chevalier.Adam@example.com
Girard;Chloé;Girard.Chloé@example.com
Lambert;Arthur;Lambert.Arthur@example.com
Bernard;Manon;Bernard.Manon@example.com
Mercier;Lucas;Mercier.Lucas@example.com
Moreau;Camille;Moreau.Camille@example.com
Gauthier;Hugo;Gauthier.Hugo@example.com
Fournier;Jade;Fournier.Jade@example.com
Martinez;Léo;Martinez.Léo@example.com
Lefebvre;Zoé;Lefebvre.Zoé@example.com
Petit;Noah;Petit.Noah@example.com
Simon;Emma;Simon.Emma@example.com
Laurent;Théo;Laurent.Théo@example.com
Dubois;Inès;Dubois.Inès@example.com
Thomas;Liam;Thomas.Liam@example.com
Dubois;Lola;Dubois.Lola@example.com
Roux;Nathan;Roux.Nathan@example.com
Dupuis;Léna;Dupuis.Léna@example.com
Bonnet;Lucas;Bonnet.Lucas@example.com
Leclerc;Sarah;Leclerc.Sarah@example.com
Robin;Enzo;Robin.Enzo@example.com
Michel;Léa;Michel.Léa@example.com
Caron;Mathis;Caron.Mathis@example.com
Marchand;Thomas;Marchand.Thomas@example.com
Giraud;Sacha;Giraud.Sacha@example.com
Dupont;Maëlys;Dupont.Maëlys@example.com
Blanc;Ethan;Blanc.Ethan@example.com
Martin;Manon;Martin.Manon@example.com
Dubois;Yanis;Dubois.Yanis@example.com
Lemoine;Léa;Lemoine.Léa@example.com
Renaud;Timéo;Renaud.Timéo@example.com
David;Zoé;David.Zoé@example.com
Martinez;Hugo;Martinez.Hugo@example.com
Petit;Inès;Petit.Inès@example.com
Lambert;Mathéo;Lambert.Mathéo@example.com
steve@just-sudo-it:~$

Manipuler des données avec « awk » ou « gawk »

Utilisons une dernière fois notre fichier user.txt. Cette fois nous voulons n’afficher que le nom de famille des utilisateurs dont le prénom commence par « C ». awk nous permet de traiter des données structurées et de les manipuler comme un tableau. Ici nos données sont les prénoms et noms comme si nous avions un tableau de deux colonnes.

Nous pouvons donc demander à awk de sélectionner uniquement les lignes qui commencent par « C » et de n’afficher que la deuxième « colonne ».

steve@just-sudo-it:~$ awk '/^([C])/{print $2}' users.txt
Rousseau
Girard
Moreau
steve@just-sudo-it:~

Conclusion

Comme nous l’avons vu les expressions régulières répondent à un besoin précis: identifier des chaines de caractères en fonction d’une sorte de canvas. Que vous deviez extraire des adresses mail d’un fichier, que vous vouliez valider le format d’encodage de données ou même encore faire de la recherche et du remplacement, les expressions régulières sont un outil précieux une fois que nous nous y sommes habitué.