Correspondance d'expressions régulières en Bash

Introduction

Ce tutoriel vous présente les expressions régulières (regex) dans Bash. Les regex sont un outil puissant pour trouver des motifs dans le texte. En apprenant les regex, vous améliorerez considérablement vos compétences en script shell, vous permettant de traiter le texte, d'extraire des données et d'automatiser des tâches plus efficacement. Ce tutoriel est conçu pour les débutants, donc aucune expérience préalable en regex n'est nécessaire. Nous commencerons par les bases et développerons progressivement vos connaissances.

Skills Graph

Comprendre les expressions régulières de base et la correspondance

Commençons par les concepts fondamentaux des expressions régulières. Une expression régulière est une séquence de caractères qui définit un motif de recherche. Imaginez - la comme un moyen très puissant de rechercher du texte.

Voici les éléments de base :

• Caractères littéraux : La plupart des caractères correspondent simplement à eux - mêmes. Par exemple, l'expression régulière abc correspondra exactement à la chaîne "abc".
• Métacaractères : Ce sont des caractères spéciaux qui ont une signification spécifique en regex. Examinons quelques - uns d'entre eux clés :
  • . (point) : Correspond à n'importe quel caractère unique (sauf un saut de ligne). Ainsi, a.c correspondrait à "abc", "axc", "a1c", etc.
  • * (astérisque) : Correspond au caractère précédent zéro ou plusieurs fois. ab*c correspondrait à "ac", "abc", "abbc", "abbbc", etc.
  • ^ (caret) : Correspond au début d'une ligne. ^hello correspondrait à une ligne qui commence par "hello".
  • $ (signe dollar) : Correspond à la fin d'une ligne. world$ correspondrait à une ligne qui se termine par "world".
  • [] (crochets carrés) : Définit une classe de caractères. Elle correspond à n'importe lequel des caractères à l'intérieur des crochets. [abc] correspondrait à "a", "b" ou "c". [0 - 9] correspond à n'importe quel chiffre unique.

Maintenant, créons un script Bash pour tester notre compréhension. Créez un fichier nommé regex_test.sh en utilisant la commande touch :

cd ~/project
touch regex_test.sh

Ensuite, ouvrez regex_test.sh avec un éditeur de texte (comme nano ou vim) et ajoutez le code suivant :

#!/bin/bash

string="Hello World"
if [[ "$string" =~ ^Hello ]]; then
  echo "The string starts with Hello"
else
  echo "The string does not start with Hello"
fi

Enregistrez le fichier et rendez - le exécutable :

chmod +x regex_test.sh

Enfin, exécutez le script :

./regex_test.sh

La sortie devrait indiquer que la chaîne commence par "Hello".

Travailler avec des ensembles de caractères dans un script

Les ensembles de caractères, définis à l'aide de crochets carrés [], vous permettent de faire correspondre un caractère à partir d'un groupe spécifique. Cela est très utile pour créer des motifs plus flexibles.

• Plages de caractères : À l'intérieur de [], vous pouvez utiliser un tiret (-) pour spécifier une plage. [a-z] correspond à n'importe quelle lettre minuscule, [A-Z] correspond à n'importe quelle lettre majuscule, et [0-9] correspond à n'importe quel chiffre. Vous pouvez les combiner : [a-zA-Z0-9] correspond à n'importe quel caractère alphanumérique.
• Négation : Si vous placez un ^ comme premier caractère à l'intérieur de [], il négatifie la classe. [^0-9] correspond à n'importe quel caractère qui n'est pas un chiffre.

Modifions notre script regex_test.sh pour utiliser des ensembles de caractères. Ouvrez regex_test.sh avec un éditeur de texte et remplacez son contenu par le suivant :

#!/bin/bash

string="cat"
if [[ "$string" =~ c[a-z]t ]]; then
  echo "Match found!"
else
  echo "No match."
fi

Enregistrez le fichier et exécutez - le :

./regex_test.sh

La sortie devrait indiquer "Match found!". En effet, c[a-z]t correspond à n'importe quelle chaîne de trois lettres commençant par 'c' et se terminant par 't', où le caractère du milieu est une lettre minuscule.

Utilisation des quantificateurs pour répéter des motifs dans un script

Les quantificateurs contrôlent le nombre de fois qu'un caractère ou un groupe doit être répété. Cela ajoute un pouvoir considérable à vos motifs d'expressions régulières.

• + (plus) : Correspond au caractère précédent une ou plusieurs fois. ab+c correspond à "abc", "abbc", "abbbc", etc., mais pas à "ac".
• ? (point d'interrogation) : Correspond au caractère précédent zéro ou une fois (c'est - à - dire qu'il rend le caractère précédent facultatif). ab?c correspond à "ac" et "abc", mais pas à "abbc".
• * (astérisque) : Correspond au caractère précédent zéro ou plusieurs fois. Nous avons vu cela précédemment.
• {n} : Correspond au caractère précédent exactement n fois. a{3} correspond à "aaa".
• {n,} : Correspond au caractère précédent n fois ou plus. a{2,} correspond à "aa", "aaa", "aaaa", etc.
• {n,m} : Correspond au caractère précédent entre n et m fois (inclus). a{1,3} correspond à "a", "aa" ou "aaa".

Modifions notre script regex_test.sh pour utiliser des quantificateurs. Ouvrez regex_test.sh avec un éditeur de texte et remplacez son contenu par le suivant :

#!/bin/bash

string="abbbc"
if [[ "$string" =~ ab+c ]]; then
  echo "Match found!"
else
  echo "No match."
fi

Enregistrez le fichier et exécutez - le :

./regex_test.sh

La sortie devrait indiquer "Match found!". En effet, ab+c correspond à une chaîne commençant par 'a', suivie d'un ou plusieurs 'b', et se terminant par 'c'.

Extraction de données avec des groupes de capture dans un script

Les parenthèses () sont utilisées pour regrouper des parties d'une expression régulière. Cela est utile pour appliquer des quantificateurs à plusieurs caractères et pour capturer le texte correspondant.

Lorsque vous utilisez des parenthèses, Bash stocke le texte correspondant à cette partie de l'expression régulière dans un tableau spécial appelé BASH_REMATCH. BASH_REMATCH[0] contient la chaîne entière correspondante, BASH_REMATCH[1] contient le texte correspondant au premier groupe, BASH_REMATCH[2] celui du deuxième groupe, et ainsi de suite.

Modifions notre script regex_test.sh pour extraire des données à l'aide de groupes de capture. Ouvrez regex_test.sh avec un éditeur de texte et remplacez son contenu par le suivant :

#!/bin/bash

string="apple123"
if [[ "$string" =~ ^([a-z]+)([0-9]+)$ ]]; then
  fruit="${BASH_REMATCH[1]}"
  number="${BASH_REMATCH[2]}"
  echo "Fruit: $fruit"
else
  echo "No match."
fi

Enregistrez le fichier et exécutez - le :

./regex_test.sh

La sortie devrait inclure "Fruit: apple". Ce script extrait le nom du fruit de la chaîne à l'aide de groupes de capture.

Remplacement de texte avec sed dans un script

Créons un nouveau script appelé sed_test.sh pour pratiquer l'utilisation de sed.

cd ~/project
touch sed_test.sh
chmod +x sed_test.sh

Ouvrez sed_test.sh avec un éditeur de texte et ajoutez ce qui suit :

#!/bin/bash

string="apple123"
echo "$string" | sed 's/[0-9]/X/g'

Enregistrez le fichier et exécutez - le :

./sed_test.sh

La sortie devrait être : appleXXX. Ce script utilise sed pour remplacer tous les chiffres dans la chaîne par la lettre "X".

Résumé

Ce tutoriel vous a présenté les expressions régulières (regex) dans Bash. Vous avez appris les concepts de base des regex, les classes de caractères, les quantificateurs, le regroupement, la capture et comment utiliser les regex avec sed. En écrivant et en exécutant des scripts Bash, vous avez acquis une expérience pratique avec ces outils puissants. N'oubliez pas de pratiquer et d'expérimenter avec différents motifs de regex pour consolider votre compréhension.