Recherche de site Web

16 exemples d'expressions régulières Bash (RegEx) utilisant les commandes grep, sed et awk

Une expression régulière ou Regex est une séquence de caractères spéciaux qui forment un motif pour trouver des instances correspondantes spécifiques dans un fichier et les manipuler. Elle est principalement utilisée pour rechercher des caractères, des mots, filtrer ou manipuler du texte dans un fichier.

Les expressions régulières sont largement utilisées dans les langages de programmation, y compris dans les scripts Bash sous Linux. Dans ce guide, je vais couvrir comment utiliser les expressions régulières dans Bash, les principales expressions régulières, et comment utiliser divers moteurs de traitement des expressions régulières.

  • Qu'est-ce que Regex
  • Versions Regex
  • Syntax des expressions régulières
  • Composants de la syntaxe Regex
  • 16 exemples d'utilisation des expressions régulières dans Linux
  • Feuille de triche Regex
  • Conclusion

Qu'est-ce que Regex

L'expression régulière ou regex sous Linux est un motif composé de métacaractères spéciaux pour correspondre à un motif spécifique dans une chaîne de caractères ou un fichier texte.

Comprenons cela avec un exemple concret, supposons que vous souhaitiez écrire un code pour trouver certaines variables spécifiques puis les manipuler dans un autre fichier de code, vous pourriez alors avoir besoin d'expressions régulières dans une telle situation.

Versions de Regex

Il existe différentes versions de regex et il est important de noter que toutes les commandes des processeurs de regex ne prennent pas en charge toutes les regex.

  • Expression Régulière de Base (ERB)
  • Expression Régulière Étendue (ERE)
  • Expression Régulière Compatible avec Perl (PCRE)

Le BRE et l'ERE sont classés comme suit :

  • POSIX BRE/ERE
  • GNU BRE/ERE

Les BRE POSIX et les ERE POSIX sont des sous-ensembles des BRE et ERE GNU, et les BRE/ERE GNU sont un sous-ensemble des PCRE.

Syntaxe des expressions régulières

Différentes utilitaires en ligne de commande sont utilisés avec des expressions régulières, tels que :

  • grep
  • sed
  • awk

Ces commandes sont également appelées moteurs regex qui aident à traduire des expressions régulières complexes et à donner le résultat.

Syntaxe Regex avec grep

grep [options] 'pattern' [string/filename]

Syntaxe Regex avec sed

sed [options] '/pattern/' [string/filename]

Syntaxe Regex avec awk

awk [options] '/pattern/' [string/filename]

Composants de la syntaxe Regex

Il y a six composants principaux de la syntaxe des expressions régulières :

  • Personnages
  • Métacaractères
  • Quantificateurs
  • Classes de caractères
  • Regroupement
  • Regarde autour

Caractères : Ces composants forment des motifs en utilisant des caractères uniques ou multiples pour rechercher des motifs exacts dans la chaîne ou le fichier. Par exemple, le caractère H recherchera H dans le fichier, de même, les lettres Linux rechercheront le mot Linux exact dans le fichier. Cependant, le drapeau -i peut être utilisé pour rendre la recherche insensible à la casse.

Métacaractères : Ces composants contiennent des caractères spéciaux et ont une fonctionnalité spécifique. Par exemple, le métacaractère point est utilisé pour trouver le caractère, tandis que ^correspond au début de la ligne et $ correspond à la fin de la ligne. Un autre métacaractère, le pipe a|b, est utilisé pour correspondre à a et b dans le fichier.

Quantificateurs : Ces composants sont utilisés pour déterminer combien de fois un motif spécifique doit être répété. Par exemple, le point d'interrogation ? répète le caractère précédent seulement zéro ou une fois, tandis que l'astérisque trouve le caractère précédent zéro ou plusieurs fois.

Classes de caractères : Les groupes de caractères enfermés dans des crochets ([]) sont connus sous le nom de composants de classe de caractères. Par exemple, [0-9] indique les chiffres de 0 à 9, de même que [A-Z] indique toutes les lettres de A à Z en majuscules.

Regroupement : Ce composant aide à regrouper le motif entre parenthèses(). Il est particulièrement utile pour trouver des séquences répétées comme des numéros de téléphone ou des adresses e-mail.

Lookarounds : Ce composant est utilisé pour effectuer une recherche positive et négative autour d'un motif précédé ou suivi d'un autre motif. Par exemple, a(?=b) cherchera tous les a s'ils se trouvent avant b.

16 exemples d'utilisation des expressions régulières dans Linux

Les exemples suivants couvrent l'utilisation de divers métacaractères, quantificateurs, groupes et certains motifs uniques.

Exemple 1 : Utilisation de l'expression par point (.)

Le point est le métacaractère de base des expressions régulières utilisé pour correspondre à un seul caractère. Par exemple :

Utilisation de grep : 

grep 'U.untu' mytextfile.txt

Utilisation de sed : 

sed -n '/U.untu/p' mytextfile.txt

Utiliser awk :

awk '/U.untu/' mytextfile.txt

Exemple 2 : Utilisation de l'expression Caret (^)

Le métacaractère ^ est utilisé pour trouver toutes les lignes commençant par le motif donné. Par exemple :

Utiliser grep :

grep '^K' mytextfile.txt

Utiliser sed :

sed -n '/^K/p' mytextfile.txt

Utiliser awk :

awk '/^K/' mytextfile.txt

Les commandes ci-dessus impriment toutes les entrées dans le fichier à partir de K.

Exemple 3 : Utilisation de l'expression Dollar ($)

Ce métacaractère est utilisé pour trouver toutes les chaînes qui se terminent par un caractère spécifique. Par exemple :

Utiliser grep :

grep 'u$' mytextfile.txt

Utiliser sed :

sed -n '/u$/p' mytextfile.txt

Utiliser awk :

awk '/u$/' mytextfile.txt

Les commandes ci-dessus donnent toutes les chaînes dans le fichier se terminant par u.

Exemple 4 : Utilisation de l'expression astérisque (*)

Le quantificateur astérisque * correspond à l'occurrence des caractères précédents dans la chaîne zéro ou plusieurs fois. Il est équivalent à {0,}. Par exemple :

Utiliser grep :

grep 'tu*' mytextfile.txt

Utiliser sed :

sed -n '/tu*/p' mytextfile.txt

Utiliser awk :

awk '/tu*/' mytextfile.txt

Exemple 5 : Utilisation de l'expression avec un point d'interrogation (?)

Le quantificateur de point d'interrogation (?) est utilisé pour rechercher si le caractère précédent apparaît zéro ou une seule fois. Il agit comme un qualificateur optionnel.

Utiliser grep :

grep -E 'Ub?' mytextfile.txt

Le -E dans la commande ci-dessus est pour les expressions régulières étendues.

Utiliser sed :

sed -nE '/Ub?/p' mytextfile.txt

Le -E dans la commande ci-dessus est pour les expressions régulières étendues.

Utiliser awk :

awk '/Ub/' mytextfile.txt

La différence entre les quantificateurs astérisque et point d'interrogation est mentionnée dans l'image ci-dessous :

L'astérisque recherche tous les caractères correspondant au caractère précédent, tandis que le point d'interrogation du caractère précédent ne correspond qu'une seule fois.

Exemple 6 : Utilisation de l'expression avec backslash (\)

Ce métacaractère de barre oblique inversée \ est utilisé pour représenter le caractère spécial. Par exemple, l'astérisque * lui-même est un caractère spécial ; pour utiliser l'astérisque de manière littérale, nous utiliserons la barre oblique inversée.

Trouvons toutes les distributions Linux dans le fichier mytextfile.txt qui ont un espace dans leurs noms.

Utiliser grep :

grep '\s' mytextfile.txt

Utiliser sed :

sed -n '/\s/p' mytextfile.txt

Utiliser awk :

awk '/\s/' mytextfile.txt

De plus, le barre oblique inversé est également utilisé avec d'autres caractères d'échappement variés.

Exemple 7 : Créer un groupe de motifs en utilisant des parenthèses()

Les parenthèses() sont utilisées pour correspondre au groupe d'expressions à l'intérieur. Comprenons cela avec un exemple :

Utiliser grep :

grep -E '(untu)' mytextfile.txt

Utiliser sed :

sed -nE '/(untu)/p' mytextfile.txt

Utiliser awk :

awk '/(untu)/' mytextfile.txt

Dans les commandes ci-dessus, le moteur saisit les entrées qui correspondent au groupe (untu). Le groupe peut également être utilisé avec un autre motif qui le suit. Par exemple, si nous remplaçons le groupe (untu) par (unt)u, le résultat sera le même.

Exemple 8 : Création de motifs à plage en utilisant l'expression avec des accolades {}

Les accolades {} sont des quantificateurs de répétition. Vous pouvez les utiliser de 3 manières différentes :

{x}: Apparaissant x fois

{x,y} ou {min,max}: Apparaissant x fois mais pas plus de y

{x,}: Apparaissant x fois et plus

Utiliser grep :

grep -E l\{2} mytextfile.txt

Utiliser sed :

sed -nE '/l{2}/p' mytextfile.txt

Utiliser awk :

awk '/l{2}/' mytextfile.txt

La commande ci-dessus trouve des entrées qui contiennent le caractère l deux fois, comme Bill et Skill.

Exemple 9 : Utiliser \d pour trouver des chiffres

L'expression \d est utilisée pour trouver la chaîne contenant des chiffres dans une chaîne ou un fichier. Par exemple :

Utiliser grep :

grep -P '\d' mytextfile.txt

P indique qu'il s'agit d'une expression régulière compatible avec Perl, pour plus de détails lisez ici.

Dans sed et awk, \d ne peut pas être utilisé car sed est une expression régulière POSIX et non Perl PCRE, par conséquent, l'équivalent de \d dans sed et awk est [0-9] ou [[:digit:]].

Utiliser sed :

sed -n '/[0-9]/p' mytextfile.txt

Ou :

sed -n '/[[:digit:]]/' mytextfile.txt

Utiliser awk :

awk '/[0-9]/' mytextfile.txt

Ou :

awk -n '/[[:digit:]]/' mytextfile.txt

Exemple 10 : Utilisation de l'opérateur logique OU |

L'expression régulière fonctionne de la même manière que la porte logique OU. Par exemple, si nous utilisons a|o, alors ce motif trouvera tous les mots contenant soit le caractère a, soit le caractère o.

Utiliser grep :

grep -E 'k|a' mytextfile.txt

Utiliser sed :

sed -nE '/k|a/p' mytextfile.txt

Utiliser awk :

awk '/k|a/' mytextfile.txt

Exemple 11 : Trouver tous les mots avec un nombre spécifique de caractères

Pour trouver tous les mots avec un nombre de caractères spécifique, nous pouvons utiliser un point (.). Le métacaractère point est utilisé pour trouver un caractère, mais il peut aussi être utilisé pour rechercher plusieurs caractères. Pour trouver toutes les lignes avec quatre caractères, utilisez :

Utiliser grep :

grep '^....$' mytextfile.txt

Utiliser sed :

sed -n '/^....$/p' mytextfile.txt

Utiliser awk :

awk '/^....$/' mytextfile.txt

Exemple 12 : Trouver l'adresse IP à partir d'un fichier

L'adresse IP est l'un des éléments clés que vous souhaitez extraire d'un fichier en utilisant des expressions régulières. Puisqu'une adresse IP contient des points, la trouver avec des expressions régulières n'est pas une opération simple : nous devons échapper le point (.) en utilisant une barre oblique. Extrayons les adresses IP du fichier /etc/hosts.

Utiliser grep :

grep -E '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' /etc/hosts

Ou :

grep -E '[[:digit:]]{1,3}\.[[:digit:]]{1,3}\.[[:digit:]]{1,3}\.[[:digit:]]{1,3}' /etc/hosts

Utiliser sed :

sed -nE '/[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/p' /etc/hosts

Utiliser awk :

awk '/[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/' /etc/hosts

Exemple 13 : Trouver les nombres décimaux

Un nombre décimal est un nombre combiné d'un nombre entier et d'une partie fractionnaire qui vient après le point (.). Pour obtenir le nombre décimal à partir d'un fichier en utilisant des expressions régulières, voir la commande donnée ci-dessous :

Utiliser grep :

grep -P '^\d*\.\d+$' mytextfile.txt

Le \d est équivalent à [[:digit:]] et [0-9], mais grep prend en charge les expressions régulières PCRE, nous pouvons donc l'utiliser avec le flag -P.

Utiliser sed :

sed -nE '/[[:digit:]]*\.[[:digit:]]+$/p' mytextfile.txt

Utiliser awk :

awk '/[0-9]*\.[0-9]+$/' mytextfile.txt

Vous pouvez remplacer [[:digit:]] par [0-9] dans les commandes ci-dessus.

Exemple 14 : Trouver l'heure au format 12 heures HH:MM

Les expressions régulières peuvent également être utilisées pour trouver l'heure dans un fichier, voyons comment extraire l'heure d'un fichier en utilisant les commandes grep, sed et awk :

Utiliser grep :

grep -E '^(0?[1-9]|1[0-2]):[0-5][0-9]$' mytextfile.txt

Utiliser sed :

sed -nE '/^(0?[1-9]|1[0-2]):[0-5][0-9]$/p' mytextfile.txt

Utiliser awk :

awk '/^(0?[1-9]|1[0-2]):[0-5][0-9]$/' mytextfile.txt

Exemple 15 : Trouver la date au format AAAA-MM-JJ

Pour extraire l'heure d'un fichier, nous utiliserons la regex suivante avec grep :

Utiliser grep :

grep -P '([12]\d{3}:(0[1-9]|1[0-2]):(0[1-9]|[12]\d|3[01]))' mytextfile.txt

Utiliser sed :

sed -nE '/([12][[:digit:]]{3}-(0[1-9]|1[0-2])-(0[1-9]|[12][[:digit:]]|3[01]))/p' mytextfile.txt

Utiliser awk :

awk '/([12][[:digit:]]{3}-(0[1-9]|1[0-2])-(0[1-9]|[12][[:digit:]]|3[01]))/' mytextfile.txt

Exemple 16 : Trouver et Remplacer des Modèles

La substitution est une autre méthode regex utilisée pour trouver et remplacer le motif. Par exemple :

Utiliser sed :

Syntaxe :

sed -i 's/[pattern]/[replacement]/' [filename]

Le fichier texte original est :

Exécutez la commande :

sed -i 's/KaOS/Peepin/' mytextfile.txt

Dans la commande ci-dessus, -i est utilisé pour modifier le fichier original. Sans ce drapeau, le fichier affichera seulement le résultat dans le terminal au lieu de modifier le fichier.

Vérifiez le fichier pour vérification :

La recherche peut être encore améliorée en utilisant g à la fin de l'expression ; le g remplacera toutes les occurrences. Alors que sans lui, seule la première occurrence sera remplacée.

Utiliser awk :

Syntaxe :

awk '{sub([pattern]/[replacement]); print}' [filename] > [new_filename]

Exécutez la commande :

awk '{sub(Peepin/,"KaOS"); print}' mytextfile.txt > newtextfile.txt

Pour vérifier, consultez le nouveau fichier :

Peepin est maintenant retourné à KaOS dans le nouveau fichier.

Il peut également être amélioré en utilisant gsub à la place de sub pour remplacer toutes les occurrences du motif.

Une autre chose importante à considérer, la commande awk affichera uniquement la sortie dans le terminal sans modifier le fichier original. Pour enregistrer le résultat, utilisez l'opérateur de redirection et fournissez le nom du fichier.

Fiche de triche Regex

Les expressions régulières offrent de nombreux métacaractères et quantificateurs pour créer des motifs complexes afin d'améliorer encore la recherche. Énumérons les règles regex couramment utilisées.

Classes de caractères Regex

Quantificateurs et alternance

Ancres

Caractères d'échappement

Groupes et Regardeurs

Conclusion

Les expressions régulières (regex) sont une séquence de caractères utilisée pour créer un motif qui aide à rechercher certaines informations dans un fichier et à les traiter. Il existe différents moteurs de regex sous Linux, tels que grep, sed et awk. Ce guide couvre les expressions régulières de base à avancées en utilisant les trois commandes Linux. Il est important de noter que tous les moteurs de regex Linux ne prennent pas en charge toutes les variantes de regex ; par exemple, sed et awk ne prennent pas en charge le PCRE, tandis que tous les moteurs prennent en charge le BRE, l'ERE et le PCRE.