Introduction à l'écriture de scripts shell — Partie 2

2.1. for;, do;, done

On écrit le plus souvent un script pour automatiser une tâche répétitive ; par exemple, si vous devez modifier répétitivement une série de fichiers dans un répertoire donné, vous pourriez avoir un script de ce type :

#!/bin/bash

for n in ~/hebdomadaire/*.txt
do
ae $n
done
echo "Fait."

ou de celui-ci :

#!/bin/bash
for n in ~/hebdomadaire/*.txt; do ae $n; done; echo "Fait."

Dans ces scripts, le code fait exactement la même chose, mais la première version est beaucoup plus lisible, en particulier si vous construisez de gros scripts avec plusieurs niveaux. Il est souhaitable, lorsqu'on écrit du code, d'indenter chaque niveau (les commandes à l'intérieur de la boucle) ; cela facilite considérablement la relecture et le suivi de votre code.

La structure de contrôle au-dessus est appelée boucle for : elle cherche des éléments restants dans une liste (c'est-à-dire « y a-t-il encore des fichiers, en plus de ceux que nous avons déjà lus, qui correspondent au motif ~/hebdomadaire/*.txt ? »). Si le test renvoie true, il affecte le nom de l'élément actuel dans la liste à la variable de boucle (n ici) et exécute le corps de la boucle (la partie entre do et done), puis vérifie à nouveau. Une fois que la liste est vide, la boucle for arrête de boucler et passe le contrôle à la ligne suivant le mot-clé done — dans notre exemple, l'instruction echo.

Si vous voulez que for boucle un certain nombre de fois, la syntaxe du script shell peut s'avérer quelque peu fastidieuse :

#!/bin/bash

for i in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
do
    echo $i
done

Très pénible ! Pour itérer par exemple 250 fois, vous devez saisir tout cela au clavier ! Heureusement, il y a un « raccourci », la commande seq, qui affiche une séquence de nombres allant de 1 jusqu'au maximum indiqué, par exemple :

#!/bin/bash

for i in $(seq 15)
do
    echo $i
done

En pratique, il fonctionne comme le précédent script. seq fait partie du paquetage shellutils de GNU et il est probablement déjà installé sur votre système. Vous pouvez également la possibilité de faire ce genre d'itération avec une boucle while, mais c'est un peu plus compliqué.

2.2. while;, do,; done

Souvent, nous avons besoin d'un mécanisme de commande agissant d'après une condition spécifiée, plutôt qu'en itérant dans toute une liste. La boucle while remplit cette exigence :

 
#!/bin/bash

pppd call provider &

while [-n "$(ping -c 1 192.168.0.1|grep 100%)"]
do
    echo "Connexion en cours..."
done

echo "Connexion établie."

Le flux général de ce script est : nous invoquons pppd, puis continuons à boucler jusqu'à ce qu'une connexion véritable soit établie (pour utiliser ce script, remplacez 192.168.0.1 par l'adresse IP attribuée par votre FAI). Voici les détails :

1. La commande ping -c 1 xxx.xxx.xxx.xxx envoie un seul ping à l'adresse IP fournie. Notez qu'elle se doit d'être une adresse IP, non une URL. Autrement, ping échouera immédiatement en raison de l'absence de DNS. S'il n'y a pas de réponse dans les 10 secondes, il affiche un message comme celui-ci :

   PING xxx.xxx.xxx.xxx (xxx.xxx.xxx.xxx): 56 data bytes ping: sendto: Network is unreachable ping: wrote xxx.xxx.xxx.xxx 64 chars, ret=-1 --- xxx.xxx.xxx.xxx ping statistics --- 1 packets transmitted, 0 packets received, 100% packet loss

2. La seule ligne qui nous intéresse ici est celle qui indique le pourcentage de paquets perdus ; avec un seul paquet, ce ne peut être que 0% (c'est-à-dire un ping réussi) ou 100%. En redirigeant la sortie de ping par un tube via la commande grep 100%, nous nous restreignons à cette ligne, si la perte est en effet de 100%. Une perte de 0% ne produira aucune sortie. Notez que La chaîne 100% n'a rien de particulier : nous aurions pu utiliser ret=-1, unreachable ou n'importe quoi d'autre qui est spécifique à une réponse sur erreur.

3. Les crochets qui contiennent l'instruction sont un synonyme de la commande test, qui renvoie 0 ou 1 (true ou false) en fonction de l'évaluation de ce qu'il y a à l'intérieur des crochets. L'opérateur -n retourne true si la longueur d'une chaîne donnée est supérieure à 0. Puisque la chaîne est supposée être contiguë (pas d'espaces) et que la ligne à vérifier ne l'est pas, nous devons mettre la sortie entre guillemets. C'est une technique que vous utiliserez encore et encore pour l'écriture de scripts. Notez bien qu'il faut un espace autour des crochets. Par exemple, [-n $STRING] n'est pas valide, mais [ -n $STRING ] est correct. Pour plus d'informations sur les opérateurs utilisés avec test, saisissez help test ; de nombreuses options très utiles sont disponibles.

4. Tant que le test ci-dessus retourne true (par exemple tant que le ping échoue), la boucle while s'exécute — en affichant la chaîne Connexion en cours... toutes les dix secondes. Dés qu'un simple ping réussit (par exemple, le test retourne false), la boucle while s'arrête et passe le contrôle à l'instruction après done.

2.3. until; do; done

La boucle until est l'inverse de while : elle continue tant que le test est faux, et s'arrête quand il devient vrai. J'ai rarement eu l'occasion de l'employer ; la boucle while et la souplesse des tests disponibles suffisent habituellement. Cette construction est juste du « sucre syntaxique » pour ceux qui préfèrent éviter les inversions logiques.

2.4. if;, then;, [else]; fi

Nous devons à de nombreuses reprises vérifier l'existence d'une condition et exécuter l'instruction selon le résultat. Pour ces occasions, nous avons l'instruction if :

 
...

if [ $PATRON="idiot" ]
then
	echo "Abandonne cet emploi !"
else
	echo "Reste ici ; le salaire est intéressant"
fi

 ...

Si une variable appelée PATRON a été définie en tant qu'« idiot » (les programmeurs de C prennnent note : = et == sont équivalents dans une instruction test — aucune affectation ne se produit), alors la première instruction echo sera exécutée. Dans tous les autres cas, ce sera la seconde instruction echo qui s'exécutera (if $PATRON ="idiot", vous travaillerez toujours là. Dommage !). Notez que l'instruction else est optionnelle, comme dans cet extrait de script :

 
...

if [ -n $ERREUR ]
then
    echo 'Détecté une erreur ; sortie.'
    exit
fi

 ...

Ce sous-programme se terminera à l'évidence si la variable ERREUR est tout sauf vide, mais cela n'affectera pas autrement le déroulement du programme.

2.5. case;, in;, esac

L'outil restant que nous pouvons utiliser pour le branchement conditionnel est essentiellement une instruction if multiple, basée sur l'évaluation d'un test. Si, par exemple, nous savons que les seules sorties possibles d'un programme imagianire appelé intel_cpu_test sont 4, 8, 16, 32, ou 64, alors nous pouvons écrire le code suivant :

  
#!/bin/bash

case $(intel_cpu_test) in
    4) echo "Vous faites tourner Linux sur une calculatrice ?";;
    8) echo "Ce 8088 a passé l'âge de la retraite...";;
    16) echo "Vous êtes un fan du 286, n'est-ce pas ?";;
    32) echo "Encore un de ces gadgets dernier cri !";;
    64) echo "Très bien ce processeur !";;
     *) echo "Mais vous utilisez quoi au juste ?";;
esac

Avant que vous m'inondiez de courrier pour savoir comment faire tourner Linux sur un 8088... vous ne pouvez pas le faire, ni sur une calculatrice :).

Évidemment, le * est un « fourre-tout » : si quelqu'un, dans les laboratoires secrets d'Intel® fait tourner ce programme sur son nouveau processeur (nom de code « UltraSuperPerfectionné »), il faut que le script renvoie une réponse appropriée plutôt qu'un message d'erreur. Notez les points-virgules doubles — ils « ferment » chacun des ensembles « motif/commande » et sont (pour certaines raisons) une source d'erreur communes dans les constructs case/esac. Prêtez une attention spéciale aux vôtres !

2.6. break et continue

Ces instructions interrompent le flux de programme d'une manière particulière. Le break, une fois exécuté, sort immédiatement de la boucle enveloppante ; l'instruction continue ignore l'itération actuelle de la boucle. Ce comportement est utile dans un certain nombre de situations, en particulier dans les longues boucles où l'existence d'une condition donnée rend tous les tests suivants inutiles. Voici un long (mais je l'espère compréhensible) exemple :

 
...

while [ "$surprise_partie" = "vrai" ]
    do
    case $ÉTAT_DES_PROVISIONS
    in
	pommes_chips_englouties) remplacer_les_pommes_chips;;
	cacahuètes_avalées) remplir_une_assiette_de_cacahuètes;;
	bretzels_dévorés) ouvrir_un_nouveau_sachet_de_bretzels;;
	...
	...
    esac


if [ police_sur_place ]
    then
	parler_aux_sympathiques_officiers
	continue
fi

case $ÉTAT_DES_BOISSONS
    in
	coca_évaporé) ouvrir_nouvelle_bouteille_de_coca;;
	jus_fruits) ouvrir_nouvelle_bouteille_de_jus_de_fruits;;
	...
	...
esac

case $ANALYSE_COMPORTEMENT_DES_INVITÉS
    in
	abat-jour_sur_la_tête) echo "Il a bu";;
	parle_aux_plantes) echo "Elle a fumé";;
	parle_avec_les_martiens) echo "Ils ont pris du LSD";;
	objets_volants) echo "Qui a bu ma limonade ??";;
        ...
        ...
        ...
esac
  
done
  
echo "Bien... quel jour sommes-nous ?"

Deux points importants : notez que lors de la vérification de l'état des différentes provisions de la surprise-partie, il aurait été plus judicieux d'écrire plusieurs instructions if — les pommes-chips et les bretzels peuvent manquer au même moment (c'est-à-dire qu'ils ne sont pas mutuellement exclusifs). Dans notre exemple, les pommes-chips ont la plus priorité la plus élevée ; si les deux produits viennent à manquer simultanément, il faudra deux itérations de boucle pour les remplacer.

Nous pouvons continuer à vérifier l'état des provsions en tentant de convaincre les policiers que nous tenons en fait une réunion philatélique (en fait, garder les cacahuètes à flot se révèle le facteur crucial à ce stade), mais nous risquons de faire l'impasse sur l'état des boissons — juste à temps pour voir Jacques ronfler sur le canapé.

L'instruction continue saute la dernière partie de la boucle while tant que la fonction police_sur_place retourne true ;pour l'essentiel, le corps de la boucle est tronqué à ce point. Notez que même si elle est effectivement à l'intérieur du construct if, elle affecte la boucle qui l'entoure : continue et break ne s'appliquent l'une et l'autre qu'aux boucles, c'est-à-dire les constructs for, while et until.