Les structures de contrôle
if
La structure de controle if permet de réaliser des tests.
La commande située à droite du if est exécutée.
Si le code retour de la commande ($?) est égal à 0 (vrai), les commandes situées dans le bloc then sont exécutées.
Si le code de retour est supérieur à 0 (faux), ce sont les commandes situées dans le bloc else (optionnel) qui sont exécutées.
Dans le cas où le bloc else n'est pas spécifié, le shell continue à la première commande située sous le fi.
Les différentes syntaxes :
if, then, else, fi
if commande1
then
commande2
commande3
...
else
commande4
...
fi
if, then, fi
if commande1
then
commande2
commande3
...
fi
if, then, elif, else, fi
if commande1
then
commande2
commande3
...
elif commande4
then
commande5
...
else
commande6
...
fi
Le mot clé fi permet de fermer la structure de controle if.
Le mot clé elif n'a pas de fermeture.
Autres syntaxes :
Le mot clé then peut être placé sur la même ligne que le if à condition de les séparer à l'aide d'un point virgule.
if commande1 ; then
commande2
commande3
...
fi
Plusieurs structures de controles if peuvent être imbriquées les unes dans les autres.
if commande1
then
commande2
...
else
if commande3
then
commande4
...
else
commande5
...
fi
fi
Exemple :
Le script suivant vérifie si un argument est passé en paramètre et dans le cas contraire demande une saisie clavier à l'utilisateur.
Le script vérifie ensuite que le user saisi existe bien dans le fichier /etc/passwd.
$ nl user_passwd.sh
1 #!/bin/bash
2 if [[ $# -ne 1 ]]
3 then
4 echo -e "Saisir le nom d'un user : \c"
5 read user
6 else
7 user=$1
8 fi
9 if grep -q "^$user:" /etc/passwd
10 then
11 echo "Le user $user existe"
12 echo "Son UID est le : $(grep "^$user:" /etc/passwd | cut -d":" -f3)"
13 echo "Son GID est le : $(grep "^$user:" /etc/passwd | cut -d":" -f4)"
14 else
15 echo "Le user $user n'existe pas !!!"
16 fi
17 exit 0
$ ./user_passwd.sh root
Le user root existe
Son UID est le : 0
Son GID est le : 0
$ ./user_passwd.sh
Saisir le nom d'un user : www-data
Le user www-data existe
Son UID est le : 33
Son GID est le : 33
$
case
La structure de controle case permet elle aussi d'effectuer des tests.
Elle permet d'orienter la suite du programme en fonction d'un choix de différentes valeurs.
Quand il y a un nombre important de choix, la commande case est plus appropriée que la commande if.
Syntaxe :
case $variable in
modele1) commande1
...
;;
modele2) commande2
...
;;
modele3 | modele4 | modele5 ) commande3
...
;;
esac
Le shell compare la valeur de la variable aux différents modèle renseignés.
Lorsque la valeur correspond au modèle, les commandes faisant partie du bloc sont exécutées.
Les caractères ;; permettent de fermer le bloc et de mettre fin au case.
Le shell continue à la première commande située sous esac.
Il ne faut surtout pas oublier les caractères ;; car cela engendrera une erreur.
Rappel des caractères spéciaux :
| Caractères spéciaux pour modèles de chaines de caractères | Signification |
|---|---|
| Caractères spéciaux valables dans tous les shells : | |
| * | 0 à n caractères |
| ? | 1 caractère quelconque |
| [abc] | 1 caractère parmis ceux inscrits entre les crochets |
| [!abc] | 1 caractère ne faisant pas partie de ceux inscrits entre les crochets |
|
Caractères spéciaux non valides en Bourne Shell. En bash, il faut activer l'option extglob (shopt -s extglob) |
|
| ?(expression) | de 0 à 1 fois l'expression |
| *(expression) | de 0 à n fois l'expression |
| +(expression) | de 1 à n fois l'expression |
| @(expression) | 1 fois l'expression |
| !(expression) | 0 fois l'expression |
|
?(expression1 | expression2 | ...) *(expression1 | expression2 | ...) +(expression1 | expression2 | ...) @(expression1 | expression2 |...) !(expression1 | expression2 | ...) |
alternatives |
Exemple :
Le script suivant permet de créer, modifier, visualiser et supprimer un fichier dans le répertoire d'exécution du script.
Il prend en argument un nom de fichier et affiche un menu.
Utilisation de case avec imbrication de if.
$ nl file.sh
1 #!/bin/bash
2 #set -x
3 # Si le nombre d'arguments est different de 1 on quitte avec code 1
4 if [[ $# -ne 1 ]]
5 then
6 echo "Nombre d'arguments incorrect"
7 echo "Usage : $0 file"
8 exit 1
9 fi
10 # On affiche le menu
11 echo -e "1(Creer) "
12 echo -e "2(Editer) "
13 echo -e "3(Afficher) "
14 echo -e "4(Supprimer)"
15 echo -e "Votre choix : \c"
16 # On recupere la valeur saisi
17 read choix
18 # Si la valeur saisi est differente de 1, 2, 3 ou 4 on quitte avec code 1
19 if [[ "$choix" != [1-4] ]]
20 then
21 echo "Choix incorrect"
22 exit 1
23 fi
24 # En fonction de la valeur saisi on execute les differentes actions
25 case "$choix" in
26 # Si choix = 1 --> creation
27 1) if [[ -e "$1" ]]
28 then
29 if [[ -f "$1" ]]
30 then
31 echo "Fichier $1 deja existant"
32 elif [[ -d "$1" ]]
33 then
34 echo "$1 est un repertoire"
35 fi
36 exit 1
37 else
38 touch "$1"
39 nano "$1"
40 fi
41 ;;
42 # Si choix = 2 --> edition
43 2) if [[ -f "$1" ]]
44 then
45 nano "$1"
46 else
47 if [[ -d "$1" ]]
48 then
49 echo "$1 est un repertoire et ne peut etre edite"
50 else
51 echo "Fichier $1 inexistant"
52 fi
53 exit 1
54 fi
55 ;;
56 # Si choix = 3 --> affichage
57 3) if [[ -f "$1" ]]
58 then
59 more "$1"
60 else
61 if [[ -d "$1" ]]
62 then
63 echo "$1 est un repertoire et ne peut etre visualise"
64 else
65 echo "Fichier $1 inexistant"
66 fi
67 exit 1
68 fi
69 ;;
70 # Si choix = 4 --> suppression
71 4) if [[ -f "$1" ]]
72 then
73 rm "$1"
74 else
75 if [[ -d "$1" ]]
76 then
77 echo "$1 est un repertoire et ne peut etre supprime"
78 else
79 echo "Fichier $1 inexistant"
80 fi
81 exit 1
82 fi
83 ;;
84 # Fin du case
85 esac
86 # Tout c'est bien deroule on quitte avec le code 0
87 exit 0
$ ./file.sh test4
1(Creer)
2(Editer)
3(Afficher)
4(Supprimer)
Votre choix : 1
$
Boucle for
Syntaxe :
La boucle for permet de traiter une liste de valeurs indiquée à droite du mot clé in.
A chaque tour de boucle, la variable var est initialisée avec une des valeurs de la liste.
Elles sont traitées dans l'ordre de leur énumération.
Liste de valeurs citée directement
for var in valeur1 valeur2 valeur3 ... valeurn
do
commande
done
Liste de valeurs contenue dans une variable
for var in $variable
do
commande
done
Liste de valeurs générée par substitution de commande
for var in `commande`
do
commande
done
Liste de valeurs générée par substitution de caractères de génération de noms de fichiers
for var in *.ext
do
commande
done
Liste par défaut : Arguments de la ligne de commande
for var
do
commande
done
for var in $*
do
commande
done
Avec incrémentation d'une variable
for (( var=valeurMin; var<=valeurMax; var++ ))
do
commande
done
Exemple :
Un script compte à rebours
$ nl boucleFor01.sh
1 #!/bin/bash
2 for var in 10 9 8 7 6 5 4 3 2 1 0
3 do
4 echo "$var"
5 done
6 exit 0
$ ./boucleFor01.sh
10
9
8
7
6
5
...
$
Lister les fichiers d'un ou plusieurs dossiers
$ nl boucleFor02.sh
1 #!/bin/bash
2 if [[ $# -lt 1 ]]
3 then
4 echo "Nombre d'argument incorrect"
5 echo "Utilisation $0 dossier1 dossier2 dossiern"
6 exit 1
7 fi
8 for dossier in $*
9 do
10 if [[ -d $dossier ]]
11 then
12 echo "Liste des fichiers du dossier $dossier"
13 for fichier in `ls $dossier`
14 do
15 echo "$fichier"
16 done
17 fi
18 done
19 exit 0
$ ./boucleFor02.sh coucou 24902 25013 25031
Liste des fichiers du dossier coucou
test
Liste des fichiers du dossier 24902
fichier_0
fichier_1
fichier_2
fichier_3
Liste des fichiers du dossier 25013
fichier_0
fichier_1
fichier_2
Liste des fichiers du dossier 25031
fichier_0
fichier_1
fichier_2
fichier_3
$
En utilisant une variable incrémentée :
$ for (( i=0; i <= 10; i++ )); do echo $i; done
0
1
2
3
4
5
6
7
8
9
10
$
Idem avec la syntaxe suivante :
$ for i in {0..10}; do echo $i; done
0
1
2
3
4
5
6
7
8
9
10
$
Boucle while
Syntaxe :
while commande1
do
commande2
...
done
La boucle while permet d'exécuter les commandes présentes entre le do et le done tant que la commande1 placée à droite du while retourne un code vrai.
Exemple :
Le script suivant demande de saisir 53 et continue tant que c'est faux
$ nl boucleWhile01.sh
1 #!/bin/bash
2 nbr=0
3 while ((nbr!=53))
4 do
5 echo -e "Saisir 53 : \c"
6 read nbr
7
8 done
9 exit 0
$ ./boucleWhile01.sh
Saisir 53 : rt
Saisir 53 : 54
Saisir 53 : R4
Saisir 53 : 53
$
Le script suivant affiche le compteur tant qu'il est inférieur à 10
$ nl boucleWhile02.sh
1 #!/bin/bash
2 cpt=0
3 while ((cpt<10))
4 do
5 echo "Le compteur vaut : $cpt"
6 ((cpt+=1))
7 done
8 exit 0
$ ./boucleWhile02.sh
Le compteur vaut : 0
Le compteur vaut : 1
Le compteur vaut : 2
Le compteur vaut : 3
Le compteur vaut : 4
Le compteur vaut : 5
Le compteur vaut : 6
Le compteur vaut : 7
Le compteur vaut : 8
Le compteur vaut : 9
$
Le script suivant effectue une somme des nombres saisis
$ nl boucleWhile03.sh
1 #!/bin/bash
2 somme=0
3 echo "Saisir un nombre, ^d pour afficher la somme"
4 while read nombre
5 do
6 if [[ $nombre != +([0-9]) ]]
7 then
8 echo "$nombre n'est pas un nombre"
9 continue
10 fi
11 ((somme+=nombre))
12 done
13 echo "La somme est de : $somme"
14 exit 0
$ ./boucleWhile03.sh
Saisir un nombre, ^d pour afficher la somme
56
32
89
9.6
9.6 n'est pas un nombre
g8
g8 n'est pas un nombre
54
La somme est de : 231
$
Le mot clé continue permet de remonter aussitôt à la boucle while sans exécuter la commande suivante
Attention aux boucles infinies
Ce script provoqe une boucle infinie car il manque l'incrémentation du compteur
$ nl boucleWhile04.sh
1 #!/bin/bash
2 cpt=0
3 while ((cpt<10))
4 do
5 echo "Le compteur vaut : $cpt"
6 done
7 exit 0
$
Le shell propose également la commande interne : qui renvoie toujours vrai et permet donc de faire une boucle infinie avec un while.
$ nl boucleWhile05.sh
1 #!/bin/bash
2 while :
3 do
4 echo "Boucle infinie"
5 done
6 exit 0
$
En bash et ksh, la commande true propose exactement la même chose.
$ nl boucleWhile05.sh
1 #!/bin/bash
2 while true
3 do
4 echo "Boucle infinie"
5 done
6 exit 0
$
until
Syntaxe :
until commande1
do
commande2
...
done
A l'inverse de while, la commande until exécute les commandes situées entre le do et le done tant que la commande située à droite du until retourne un code faux.
Exemple :
Le script suivant boucle tant que le nombre saisi n'est pas égal à 53
$ nl boucleUntil01.sh
1 #!/bin/bash
2 nbr=0
3 until ((nbr==53))
4 do
5 echo -e "Saisir 53 : \c"
6 read nbr
7 done
8 exit 0
$ ./boucleUntil01.sh
Saisir 53 : 45
Saisir 53 : rt
Saisir 53 : fd
Saisir 53 : 53
$
Le script suivant permet, en tâche de fond, de surveiller un répertoire donné et d'informer l'utilisateur de l'arrivée d'un fichier attendu dans ce répertoire.
Pour plus de sécurité sur l'intégrité du fichier attendu, un fichier témoin devra être créé à la suite du fichier attendu puisque le principal contrôle se fera sur l'existence de ce fichier.
$ nl boucleUntil02.sh
1 #!/bin/bash
2 # Il doit y avoir au minimum 2 paramètres en arguments et un maximum de 3
3 if [[ $# -lt 2 || $# -gt 3 ]]
4 then
5 echo "Utilisation : $0 repertoire fichier [ temoin ]"
6 exit 1
7 fi
8 # Le premier argument doit être un répertoire
9 if [[ ! -d $1 ]]
10 then
11 echo "$1 n'est pas un répertoire"
12 exit 2
13 fi
14 # Nom du fichier témoin par défaut
15 ficTemoin=${3:-temoin}
16 # Exécution de la boucle en attendant l'arrivée du fichier témoin avec une pause toutes les 3 secondes
17 until [[ -e $1/$ficTemoin ]]
18 do
19 sleep 3
20 done
21 # Vérification que le fichier attendu est bien présent
22 if [[ ! -e $1/$2 ]]
23 then
24 echo "Le fichier témoin existe mais le fichier attendu est absent"
25 exit 3
26 fi
27 # Sauvegarde du fichier attendu dans le HOME de l'utilisateur avec horodatage et suppression du fichier témoin
28 date=$(date '+%Y%m%d_%H%M')
29 newFichier=$2.$date
30 mv $1/$2 $HOME/$newFichier
31 rm $1/$ficTemoin
32 # Envoi d'un mail à l'utilisateur
33 mail $LOGNAME <<FIN
34 Le fichier $HOME/$newFichier est bien arrivé.
35 FIN
36 echo "$0 : Vous avez reçu un message !!! "
37 exit 0
$ ./boucleUntil02.sh /tmp monFichier & # Lancement du script en arrière plan grâce à la commande &
[1] 2298
$ touch /tmp/monFichier # Création du fichier attendu
$ touch /tmp/temoin # Création du fichier témoin
$ ./boucleUntil02.sh : Vous avez reçu un message !!! # Message généré par la ligne 36
[1]+ Done ./boucleUntil02.sh /tmp monFichier
$
il ne reste plus qu'à consulter sa boite mail pour lire le message envoyé par le script.
break et continue
Les commandes break et continue peuvent s'utiliser à l'intérieur des boucles for, while, until et select.
La commande break permet de sortir d'une boucle.
La commande continue permet de remonter à la condition d'une boucle.
Syntaxe :
Quitter la boucle de premier niveau
break
Quitter la boucle de niveau n
break n
Remonter à la condition de la boucle de premier niveau
continue
Remonter à la condition de la boucle de niveau n
continue n
Exemple :
$ nl boucleWhile06.sh
1 #!/bin/bash
2 somme=0
3 while true
4 do
5 echo "Saisir un nombre, ^d pour afficher la somme"
6 if read nombre
7 then
8 if [[ $nombre != +([0-9]) ]]
9 then
10 echo "$nombre n'est pas un nombre"
11 continue
12 fi
13 ((somme+=nombre))
14 else
15 break
16 fi
17 done
18 echo "La somme est de : $somme"
19 exit 0
$ ./boucleWhile06.sh
Saisir un nombre, ^d pour afficher la somme
23
Saisir un nombre, ^d pour afficher la somme
56
Saisir un nombre, ^d pour afficher la somme
54
Saisir un nombre, ^d pour afficher la somme
89
Saisir un nombre, ^d pour afficher la somme
La somme est de : 222
$