Bash : Variables, globs étendus, ERb, ERe

• Objet : suite de la série de wiki visant à maîtriser bash via les différents caractère spéciaux.
• Niveau requis :

  avisé
• Commentaires :
• Suivi :
  • Création par Hypathie le 10/04/2014
  • Testé par Hypathie Avril 2014
• Commentaires sur le forum : Lien vers le forum concernant ce tuto ¹⁾

• Vision d'ensemble
• Bash : Détail et caractères
• Bash : les opérateurs lexicographiques
• Bash : les opérateurs de comparaison numérique
• Bash : les symboles dans les calculs
• Bash : les tableaux
• Bash : les caractères de transformation de parametres
• 

Nota : Contributeurs, les sont là pour vous aider, supprimez-les une fois le problème corrigé ou le champ rempli !

La “représentation symbolique”²⁾ de caractères alpha-numériques par des “métacaractères”³⁾ est de deux types.
Et on peut distinguer ces deux types relativement à l'utilisation que l'on en fait :

1. sélectionner des noms de fichiers dans un répertoire ;
   
2. déterminer si une chaîne est conforme à un format désiré.
   

Le premier type de représentation symbolique se fait avec les globs ou patterns simples⁴⁾ ; ils servent aux recherches sur les chaînes de caractères et se font généralement en ligne de commandes.
Il a été donné un simple récapitulatif des caractères utilisés ici : définition usuelle de métacaractère".

Le deuxième type de de représentation symbolique se fait (à partir de bash 2.01) avec les globs étendus ⁵⁾, étudiés ci-dessous ; on les utilise pour effectuer des tests de correspondances simples, en ligne de commandes ou dans des scripts, ou pour modifier les paramètres d'une variable.

• Ce deuxième type de représentation symbolique s'est développé avec Bash 3.0 auquel il a été intégré la possibilité d'une utilisation restreinte des expressions régulières.
  Mais attention, il ne s'agit pas de recherches de noms de fichiers ou de mots (le contexte n'est plus la ligne de commandes), ni de modifications de paramètres.
  On s'en sert uniquement pour la correspondance entre une variable et une expression régulière, jamais pour la substitution ou la correspondance telle que le permet sed et awk.

• On retrouve ce deuxième type de représentation symbolique avec l'usage avancé des expressions régulières.
  Mais elles permettent bien plus que ce que nous allons voir ici. En particulier, la substitution de caractères dans un fichier (exécutable ou non).
  Il est nécessaire pour utiliser les regexp d'en passer par des programmes externes et spécifiques à l'utilisation des expressions régulières (egrep, sed, awk par exemple).
  Ci-dessous l'index 1 donne un simple aperçu des caractères utilisables pour les ERb et ERe des différents programmes externes au shell Bash, et déborde donc du sujet, si ne n'est que le shell Bash permet de les installer puis de les lancer.
  À voir :
  • les-metacaracteres
  • grep
  • sed

Nous allons développer dans cette page le deuxième type de de représentation symbolique, ce qui recouvrira l'utilisation des globs étendus et l'utilisation des expressions régulières spécifiques au shell Bash mais utilisables uniquement dans le contexte de la correspondance avec la chaîne d'une variable.

Puisque tout est bien clair, c'est parti !

On trouve dans man bash, à la fin de la page “Développement des noms de fichiers”, “Motifs génériques”, le tableau suivant :

Comment se servir des caractères de ce tableau ?
Avec la commande interne de bash “shopt -s extglob”, bash prend en charge les motifs étendus (extended globs).
On peut alors définir plusieurs motifs, séparés par le caractère | et regroupés dans des parenthèses.
Le premier caractère placé avant les parenthèses (@, !, +, *, ?), fixe le type de correspondances avec les motifs.
Voir : http://www.linuxjournal.com/content/bash-extended-globbing
Notons l'option shopt -s nocasematch (bash version 3.1) permet de retirer la sensibilité à la case.

mkdir Test && cd Test && touch image.bmp  image.jpg  nom.txt && cd ..

Création d'un fichier de type répertoire nommé “Test”, contenant les fichiers : image.bmp image.jpg nom.txt

shopt -s extglob

Pour les commandes qui suivent, il faut valider toujours dans le même terminal.

ls ~/Test/!(*jpg|*bmp)

Cela signifie : liste-moi le ou les fichiers dont le nom ne comporte pas (!)

soit “zéro ou plein de caractères” (*) puis jpg

soit “zéro ou plein de caractères” (*) puis bmp

retour de la commande

/home/hypathie/Test/nom.txt

C'est le chemin absolu (nom complet) du (ou des) autre(s) fichiers que ceux finissant par jpg ou bmp.

• à propos de cet exemple :

 cd ~/Test/

ls !(*jpg|*bmp)

retour de la commande

nom.txt

C'est le nom simplifié

Tester une chaîne par rapport à un motif (représentatif) et non par rapport à une constante littérale.
Par exemple :

script

#!/bin/bash
shopt -s extglob
nom=image.jpg
if [ "$nom" == *.jpeg ]         # correspondance vue précédemment
then
  echo "bonne correspondance"
  else 
  echo "mauvaise correspondance"
fi
 
nom=image.jpg
if [[ "$nom" = *.@(jpg|jpeg) ]]  # (ligne 12) 
                                 # emploi de globs (ou motifs) étendus : @ voir tableau ci-dessus
then
  echo "bonne correspondance"
  else 
  echo "mauvaise correspondance"
fi

mauvaise correspondance
bonne correspondance

Bash peut utiliser les expressions régulières mais de façon restreinte ;

• elles ne peuvent pas être utilisées comme modèle de comparaison avec des noms de fichier ou pour effectuer des recherches en ligne de commandes.
• elles ne peuvent pas servir à modifier le contenu d'un fichier.

Elles servent seulement à “matcher” des variables, et elles ne s'utilisent que dans le cadre des scripts.

Depuis Bash 3.0, on peut pour se faire utiliser l'opérateur =~.

Cet opérateur =~ permet :

• de vérifier la correspondance entre une chaîne (valeur d'une variable à gauche) et le modèle regex à droite ;
• ou encore de vérifier la correspondance entre une variable (constituée d'une chaîne de caractères littérales), et une variable constituée d'une regex.

Encore une fois, pour le shell bash, tous les caractères ci-dessous, ont la signification décrite uniquement dans ce contexte de correspondance de motif entre variable et ERb ou ERe.

Ne pas confondre la signification de certains des caractères présentés par ce tableau, avec celle qu'ils ont pour le shell dans le contexte de la ligne de commandes.

Le tableau rappelle pour cette raison, la signification des caractères pour lesquels la confusion est possible avec leur utilisation en ligne de commandes⁶⁾.

Voici les caractères utilisables :

• Référence (ce tableau résume le contenu de ces trois liens) :
  • https://en.wikipedia.org/wiki/Regular_expression#Standards
  • https://en.wikipedia.org/wiki/Regular_expression#Standards#Uses
  • https://en.wikipedia.org/wiki/Regular_expression#Standards#Character%20classes
• Autre référence :
  http://mywiki.wooledge.org/RegularExpression
  Regular Expressions/POSIX

script

#!/bin/bash
for nombre in "1234567" "123478985" "123498761" "12396590"
do 
  if [[ $nombre =~ ^[0-9]{9}$ ]]  # 9 nombres ({ }) compris entre 0 et 9 ([0-9])
  then
      echo "$nombre comporte 9 nombres"
  else
      echo "$nombre ne correspond pas à 9 nombres"
  fi
done

1234567 ne correspond pas à 9 nombres
123478985 comporte 9 nombres
123498761 comporte 9 nombres
12396590 ne correspond pas à 9 nombres

• Ou encore :

script

#!/bin/bash
#REGEX="^[[:upper:]]{1}[[:lower:]]{4}$"
REGEX="^[A-Z]{1}[a-z]{4}$"
var=Hello
if [[ $var =~ $REGEX ]]
then
echo "match"
else
echo "pas de match"
fi

match 

script

#!/bin/bash
regex="^([[:alpha:][:blank:]]*)- ([[:digit:]]*) - ([[:alpha:]]?)(.*)jpg$"
# ou regex="^([[:alpha:][:blank:]]*)- ([[:digit:]]*) - ([[:alpha:]]?)(.*)[a-z]{3}$"
#ou encore regex="^([[:alpha:][:blank:]]*)- ([[:digit:]]*) - ([[:alpha:]]?)(.*)[a-z]\3$"
var="image linux - 01 - pingouin.jpg"
 
if [[ $var =~ $regex ]]
then
echo "Le nom de l'image correspond à l'expression rationnelle."
else
echo "mauvaise regex"
fi

Le nom de l'image correspond à l'expression rationnelle.

• Explication :

^ : début de l'expression

([[:alpha:][:blank:]]*) :

entre parenthèses: première sous-expression,

avec une paire de crochets contenant deux autres paires de crochets [:apha:] et [:blank:],

avec * pour signifier que le groupe [alpha et blank] doivent apparaître 0 ou plusieurs fois ; suivi d'un espace.

- : un tiret avec un espace après comme dans l'expression littérale.

([[:digit:]]*) - ([[:alpha:]]?) : une sous expression faite d'un groupe composé d'un nombre quelconque d'alphanumérique, un espace, un tiret, une autre sous-expression qui apparaît

0 ou 1 fois (?).

La sous-expression (.*) signifie n'importe quel nombre ( * ) de tous caractères (.),

puis littéralement jpg,

puis $ qui signifie fin de l'expression.

Le tout entre ” “ et sans espace autour du égal qui affecte la variable “regex” par la ERE⁷⁾.

Et voilà comment avec le shell bash, on peut dresser une expression rationnelle étendue fonctionnant dans les tests !

• Voici un script “exp.reg1”

script exp.reg1

#!/bin/bash
#Les "echo" les plus à droite sont là pour expliquer lors du retour ce qui s'y passe dans ce script.
 
VAR="$1"
     echo "La valeur de VAR est: $VAR."
     echo "Il y a "$#" paramètres."
     echo "Le paramètre n°1 est "$1" (la 'ER')."
     echo "Le paramètre n°2 est "$2" (deuxième argument, chaine1 à matcher)."
     echo "Le paramètre n°2 est "$3" (le troisième argument, chaine2 à matcher."
     echo " "
shift
     echo "Avec 'shift', on se décale d'un paramètre." 
     echo "Après 'shift', il reste donc: "$#" paramètre(s)." 
     echo "Et ce(s) paramètre(s) sont: "$1", "$2"." 
     echo "("$1": ancien deuxième paramètre devenu paramètre 1 après shift)."
     echo "("$2": ancien troisième paramètre devenu paramètre 2 après shift.)"
     echo " "
     echo "MAIS LA VALEUR DE VAR RESTE la 'ER' : "$VAR"."
for i in "$@"
do
     echo " "
     echo "'for i in \$@': la variable i aura, boucle après boucle, les VALEURS: "$@","
     echo "(attribués à chaque tour de boucle à variable "i".)"
     echo "c'est-à-dire lors de la boucle n°1, elle est identique au paramètre n°1: "$1"."
     echo "puis lors de la boule n°2, elle est identique au paramètre n°2 : "$2"."
     echo " "
     echo "On peut donc donner à grep la chaine:$i comme entrée par le tube," 
     echo "et comme motif le 'ER': $VAR." 
 echo "$i" | grep -E "$VAR" > /dev/null
  if [ $? -eq 0 ]
  then 
    echo " "
    echo " BRAVO ! La ER: $VAR  correspond au motif "$i" "
  else
    echo " "
    echo " ERREUR ! La ER: $VAR ne correspond pas au motif: $i "
    echo " "
  fi
done
 
# ligne 33 (if) : $? (code de retour) -eq (égal à) zéro (pas d'erreur de sortie, donc bonne correspondance)

• Lancez-le comme ci-dessous, explications détaillées dans le retour :
  

./exp.reg1 "^[a-b]" "abc" "ABC" 

La ER comme premier argument de “exp.reg1”, puis le ou les chaînes à vérifier en second, troisième, etc. argument de “exp.reg1”.

Et voilà

Un grand merci à captnfab pour conseils avisés et toutes ses corrections.

Comparez ce qui suit avec Caractères servant aux expressions régulières de correspondance avec une variable.

• Avec sed il faut l'option -r, bien que les classes relèvent des ERb.
• Avec grep, elles ne nécessitent pas l'option -R ou egrep.

man grep fr

egrep en

man sed fr

man awk

Récapitulatif selon deux types d'expressions régulières :

-les expressions régulières basiques ERb
-les expressions régulières étendues ERe

• Exemples :

blabla : chaîne contenant “blabla”

^blabla : chaîne commençant par “blabla”

blabla$ : chaîne finissant par “blabla”

^[A-Z][5-8].$ : chaîne composées de trois caractères, dans l'ordre :
une majuscule, un chiffre compris entre 5 et 8, un caractère quelconque

^$ : chaîne vide

^[ ]*$ : chaîne contenant zéro ou plusieurs espace(s) ou tabulation(s)

\<tout : mot commençant par “tout”, toutefois

\<tout\> : le mot “tout”

→ Le caractère \ donne une signification spéciale aux parenthèses et accolades, au lieu de les rendre littérales.

Excepté (er1)(er2) :

• Tous sont utilisables avec grep -E et egrep
• Tous sont utilisables avec awk
• Certains posent problème avec sed -r

• sed :

• awk :

Pour les PCRE (perl) supportée par egrep (grep -E ; sed et et awk ) voir pcresyntax(3) et [[http://manpages.courier-mta.org/htmlman3/pcresyntax.3.html|pcrepattern(3)]] - Lien Obsolète

Et en français http://www.expreg.com/pcre.php

Un petit rappel non exhaustif des caractères spéciaux qui leur sont communs.

• Référence :
  http://oreilly.com/php/excerpts/php-mysql-javascript/regex-in-php-javascript.html
• Apprendre à utiliser les expressions régulières sous perl :
  https://ensiwiki.ensimag.fr/index.php/Expressions_r%C3%A9guli%C3%A8res
  http://perldoc.perl.org/perlrequick.html
  http://perldoc.perl.org/perlre.html

Voici :

Bash : les caractères de transformation de parametres