• Objet : suite de la série de wiki visant à maîtriser bash via les différents caractère spéciaux.
• Niveau requis : avise
• Débutant, à savoir : Utiliser GNU/Linux en ligne de commande, tout commence là !.
• Suivi : a-placer
  • Création par Hypathie 10/04/2014
  • Testé par <Hypathie> le <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
• 

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 plus alors de recherches de noms de fichiers ou de mots, 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 telle que le permet l'utilisation avancée des expressions régulières.

• 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 INDEX 1 et INDEX 2donnent un simple aperçu des caractères utilisables pour REGEXP 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 :
  • 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 (restreintes) spécifiques au shell Bash.

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

/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)

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 :

#!/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ée 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 cadres des scripts.

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

Cet opérateur =~ permet :

• de vérifier la correspondre 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, tous les caractères ci-dessous, ont la signification décrite pour le shell bash uniquement dans ce contexte de correspondance de motif entre variable et ERb et ERe.
Ne pas confondre la signification de certains des caractères présentés par ce tableau qui ont une signification différentes pour le shell dans le contexte de la ligne de commandes.
Le tableau rappelle aussi la signification des caractères pour lesquels la confusion est possible.

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

#!/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 :

#!/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 

#!/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 tout 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”

#!/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.

Les caractères utilisés pour créer des regexp avec sed

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