4. La programmation

4.1.2.1. Les paramètres positionnels

• $# contient le nombre d'arguments reçus par le script en cours d'exécution.

• $0 représente le nom du script.

• $1, $2, $3 ... $9 les 9 premiers arguments passés au script.

• ${10}, ${11}, ${12} ... les arguments suivants passés au script (uniquement pour bash et ksh).

• $* et $@ contiennent la liste de l'ensemble des arguments passée au script. La différence entre les deux formes si situe au niveau de leur utilisation avec des guillemets : "$*" ne protège pas les éventuels arguments contenant des séparateurs alors que $@ le fait !

4.1.2.2. Les variables d'état

• $? contient le code de retour d'une commande. Ce code est un entier compris entre 0 et 255, et permet de diagnostiquer la réussite (0) ou l'échec d'une commande unix (>0).

• $$ représente le PID du shell en cours d'exécution.

• $! représente le PID du dernier processus lancé en arrière plan.

4.1.2.3. La variable IFS

Cette variable particulière contient en fait les caractères utilisés par le shell comme séparateur (par défaut espace, tabulation et retour à la ligne). Elle peut être modifiée en cours de script.

Exemples d'utilisation :

4.1.3.1. Utilisation des caractères de protection :

Les ' apostrophes ou simples quotes permettent de retirer la signification de tous les caractères spéciaux du shell ; elles doivent être appariées dans une même ligne de commande, et ne se protègent pas elles-mêmes.

Exemples d'utilisation :

Le caractère \ anti-slash permet de retirer la signification du caractère spécial du shell le suivant immédiatement. Pour afficher le caractère \, il faut le doubler !

Exemples d'utilisation :

Les " guillemets ou doubles quotes permettent de retirer la signification de tous les caractères spéciaux du shell sauf $ et ${}, `` et $() et enfin \ ainsi qu'elle-même; à l'instar de ' elles doivent être appariées dans une même ligne de commande, et ne se protègent pas elles-mêmes.

Exemples d'utilisation :

4.1.3.2. Isolation d'un nom de variable :

Il est des cas particulies où il ne sera pas possible, même en utilisation les possibilités d'échappement, d'obtenir le résultat escompté : il faut alors pouvoir isoler le nom de la variable utilisée (c'est à dire forcer le shell à n'utiliser qu'une partie de la commande pour en extraire une valeur de variable). C'est notamment le cas lors de la concaténation du contenu d'une variable à une chaine de caractères débutant par un des caractères appartenant à l'ensemble du jeu de caractères valides pour le nommage d'une variable.

Cette isolation s'obtient en utilisant la syntaxe ${VARIABLE}. Exemple :

On cherche à créer des fichiers nommés FIC001_LISTE.txt à partir d'une variable NUM contenant des valeurs telles que '001', '002'... la syntaxe

touch FIC$NUM_LISTE.txt aboutira à créer un fichier FIC.txt, dans la mesure où le shell considère une variable NUM_LISTE qui n'est pas définie.

La solution passe donc par isoler le nom de la variable NOM : touch FIC${NUM}_LISTE.txt .

4.1.3.3. Substitution de variables :

Sous le terme de substitution de variables, se cache simplement la possibilité d'attribuer une valeur par défaut aux variables (qu'elles soient non initialisées).

• ${variable:-valeur} si la variable n'est pas vide, la substitution retourne sa valeur, sinon elle retourne valeur.

• ${variable:=valeur} si la variable n'est pas vide, la susbtitution retourne sa valeur, sinon elle retourne valeur et variable est également affectée à valeur.

• ${variable:+valeur} si la variable est pas vide, la substitution retourne valeur, sinon elle retourne sa valeur, c'est à dire vide.

• ${variable:?message} si la variable n'est pas vide, la substitution retourne sa valeur, sinon le shell affiche le nom de la variable suivi de la chaine de caractères message. De plus, si cette forme de substitution est utilisée dans un script shell, celui s'arrête immédiatement après l'affichage du message.

Exemples d'utilisation :

4.2.2.1. Les tests

Le shell offre la possibilité d'exécuter des branchements conditionnels dans le flux d'exécution en fonction du résultat d'un ou plusieurs tests qui sont introduits par différentes syntaxes possibles :

• soit par la commande interne [ [val1] op val2 ]

• soit par la commande interne [[ [val1] op val2 ]]

• ou encore par la commande externe test [val1] op val2

• en ce qui concerne les expressions arithmétiques il faut utiliser soit la commande interne (( [val1] op val2 )) ou let

• ou la commande externe expr [val1] op val2

Afin de compléter cette armada de tests, le shell dispose également d'opérateurs permettant d'influer sur un test ou lier logiquement plusieurs tests :

• L'opérateur ! : signifie la négation du test le suivant.

• L'opérateur -a : effectue un ET logique entre deux tests.

• L'opérateur -o : effectue un OU logique entre deux tests.

La syntaxe de la commande [[ ... ]] s'est vue enrichie par rapport à la commande test (ou [ ... ]) basique, et notamment en ce qui concerne les chaines de caractères pour lesquelles l'usage des guillemets n'est plus nécessaire, certains opérateurs ont été rajoutés (cf. tableau) et les opérateurs de négation et de regroupement ont été alignés sur la syntaxe du C :

• L'opérateur ! reste tel quel.

• L'opérateur -a (ET logique) devient && (idem pour la commande(( ... ))).

• L'opérateur -o (OU logique) devient || (idem pour la commande (( ... ))).

• Et les parenthèses de regroupement ne doivent plus être échappées.

Exemples d'utilisation :

4.2.2.2. Les branchements : structures if, elif et case

Les tests peuvent donc permettre d'éxecuter conditionnellement un partie d'un programme en fonction de son résultat. La structure pour procéder à ces branchements dans le code est la structure if : si la condition est vraie, alors le programme exécute un bloc de code. Mais elle peut se compliquer quelque peu en rajoutant les notions de sinon (else) et de sinon, si (elif). La syntaxe est la suivante :

Exemples d'utilisation :

Dans certains cas, il sera possible de remplacer l'utilisation de nombreuses conditions if - elif qui deviennent rapidement illisibles par la structure case. Sa syntaxe est la suivante :

Exemple d'utilisation :

4.2.2.3. Les boucles : structures for, while et until

Les boucles sont des structures de contrôle permettant d'itérer un bloc de code autant de fois que nécessaire. L'itération peut être déterminée soit par le nombre de valeurs d'une liste dans le cas de la boucle for, soit par le résultat d'un commande ou d'un test dans le cas des boucles while et until :

• Le bloc code compris dans un boucle for sera exécuté pour chaque élement de la liste ; la liste peut être fournie explicitement, par substitution de variable, par susbtition de commande ou par évaluation des caractères spéciaux du shell. Si aucune liste n'est fournie, la boucle porte sur les arguments passés dans la ligne de commande (évaluation de la variable $*. Lors de chaque itération, la variable de boucle prend la valeur suivante dans la liste.

• Le bloc code compris dans un boucle while sera exécuté tant que la valeur retournée par la commande de contrôle sera VRAI ; dès qu'elle retournera FAUX, le flux d'exécution passe à la commande suivant immédiatement le mot-clé done.

• Le bloc code compris dans un boucle until sera exécuté tant que la valeur retournée par la commande de contrôle n'est pas VRAI.

Exemples d'utilisation :

Lors de l'exécution d'une boucle, les commandes internes continue et break permettent de modifier le flux de commandes en, respectivement, passant à l'itération suivante et en interrompant le cours de la boucle.

Exemples d'utilisation :

for i in `seq 1 10`
do
	if (( $i == 5 ))
	then
		continue	# n'affichera pas 5
	fi
	if (( $i > 8 ))	# interromp la boucle pour i=9
	then
		break
	fi
	echo $i
done

clear
while true ; do         # boucle infinie 
        echo "Saisissez un nombre (0 non traité - 999 pour terminer)";
        read NOMBRE;
        if [  ! $(echo $NOMBRE | grep "^[ [:digit:] ]*$") ] ; then
                echo "On vous a demandé un nombre !"
                continue
        fi
        if [ $NOMBRE -eq 0 ] ; then
                continue
        elif [ $NOMBRE -eq 999 ] ; then
                break
        else
                echo "Vous avez saisi le nombre $NOMBRE (999 pour terminer)"; 
                sleep 5
                clear
        fi
done;