Chapitre 5

La programmation shell

I. Rappel
1. Le shell
2. Avantage de la programmation shell
3. Les différents types de commandes
II. Qu’est ce qu'un script shell ?
III. Fonctionnement du shell
IV. Comment exécuter un script shell ?
V. Les caractères spéciaux
1. Les caractères génériques
2. Les méta caractères
VI. Les variables
1. Les variables utilisées par le shell
2. Les variables du shell
3. Les variables utilisateur
a) Affectation
b) Affichage
c) Action par défaut
d) Portée
[Link] commande test
VIII. Les expressions arithmétiques
IX. Les paramètres
X. Les structures de contrôles
1. La structure conditionnelle : if then [elif] [else] fi
2. La structure sélective : case in esac
XI. Les structures itératives
1. La structure : for [ in ] do done
2. La structure while : while do done
3. La structure until : until do done
I. Rappel
1. Le shell
Le shell est un programme qui permet l'interfaçage entre l'utilisateur et le système d'exploitation,
c'est à dire, le fait qu'il est le premier processus d'une session à partir du quelle l'utilisateur peut
lancer des commandes qui vont être prises par le système d'exploitation. C'est pourquoi on pourrait
appeler le shell un interpréteur de commandes.

Le shell est défini aussi comme un langage de programmation, puisque il offre la possibilité de
définir des procédures (scripts) formés éventuellement des variables et des instructions qui
correspond la thématique de ce présent chapitre en utilisant BASH (Bourne Again Shell).

2. Avantage de la programmation shell

Facilite l'automatisation des tâches d'administration.
Réutilisation et adoption des commandes selon les besoins de l'utilisateur.

3. Les différents types de commandes

Sous UNIX/LINUX on distingue trois types de commandes:
Commandes internes : elles sont intégrés au shell, le shell lui même exécute ces commandes sans
crée un sous processus.
Commandes externes : elles sont des fichiers binaires (exécutables) qui existent sur le disque dur
dans des emplacements bien spécifiques tels que (/bin, /usr/bin,...).elles sont traitées par un
processus fils.
Des programmes utilisateurs (script shell) : des fichiers textes qui peuvent être exécutés soit par un
shell fils ou shell courant.

II. Qu'est ce qu'un script shell ?

C’est un fichier texte formé d'un ensemble de commandes shell regroupés dans le but d'accomplire
une tâche spécifique.
Evidemment, l'avantage d'un script shell est le fait qu'il est possible d'intégrer plusieurs éléments
(des variables, des structures de contrôles, structures itératives ) qui lui rendre un véritable
programme qui répond à vos besoins.

III. Fonctionnement du shell

L’illustration suivante explique le fonctionnement du shell, suite à la réception d'une éventuelle
commande, suivant que cette dernière soit interne ou externe.
 Figure 1: fonctionnement du shell

Conformément à ce qu'on à dit précédemment, le shell dispose des commandes internes (builtin)
telle que (cd, echo, exit, pwd,...), et il est capable d'exécuter aussi des commandes externes c'est-à-
dire qui se trouvent dans des répertoires bien spécifiques telles que (/bin, /usr/bin, .....).

Afin d'examiner l'existence de la commande externe reçus, le shell recourt à une variable PATH
(variables d'environnement voir VI. 1. ) qui contient les chemins absolus des répertoires (séparés
par “:'')

Exempel :
PATH=/usr/bin:/bin:/usr/local/bin:/usr/X11R6/bin

Modification de la variable PATH

[etudiant localhost ~]$ PATH=$PATH:/home/etudiant/MesScripts

Remarques :
 L'ordre des répertoires dans la variables PATH est important puisque la recherche est
ordonnée de gauche à droite.
 S'il existe deux versions de la même commande, sera utilisée celle qui est trouvée la
première.
 La valeur VRAI est retournée par le shell en cas d'une exécution réussite

D'ailleurs, de point de vue processus, le shell se trouve à l'état attente d'une commande utilisateur
qui sera prise en compte suite à un (retour chariot). Par conséquence, le shell courant crée un
processus fils (shell fils) qui va exécuter la commande reçus de son père.
 Figure 2: fonctionnement du shell
Remarques :
 Pour traiter une commande interne, le shell effectue lui−même un traitement spécifique,
sans créer de sous−processus.
 La création d'un nouveau processus pour exécuter une nouvelle commande permet de
lancer plusieurs commandes en tâches de fond.

IV. Comment exécuter un script shell ?

Il y a plusieurs manière d’exécuter un script shell :

Par le shell courant:

Utiliser la commande interne ’.’, qui permet de lire et d’exécuter les commandes se trouvant dans le
fichier script1, sans créer de sous−processus.
$ . script1

Par un sous shell explicite :

Lance un shell en redirigeant son entrée standard sur le script
$ bash script1

Rendre le script exécutable :

$ chmod u+x script1

$ . ./scrip1 # si . Ne figure pas dans PATH
$ script1 # si . Est a été ajouté au PATH
[Link] caractères spéciaux
1. Les caractères génériques
Les caractères génériques qui sont * , le point d'interrogation ? et les crochets [ ] . ils jouent le rôle
de joker dans les noms de fichiers.
* : le caractère étoile remplace n'importe quels caractères y compris la chaîne vide.
? : le point d'interrogation remplace n'importe quel caractère.
[a-z] : il correspond à l'un des caractères {a,b,c,....z}

Exemples:
[0-9] : il correspond à un chiffre de {0,1,...,9}
*[0-9]* : cela signifie toute chaîne qui contient au moins un chiffre
[a-cH-J5-8] cela signifie n'importe quel caractère parmi l'ensemble {a,b,c,H,I,J,5,6,7,8}

2. Les méta-caractères
Les méta-caractères sont des caractères qui ont une signification distinguée des autres caractères
pour le shell Bash et qui sont interprétés autrement. Les méta-caractères se résume dans ce qui suit
en précisant pour chacun son rôle.
# Introduit un caractère.
$ Introduit le nom de la variable.
& Suit une commande qui doit entre exécutée en arrière plan.

; Sépare des commandes pour quelles soient exécutées de façon séquentielle.

' le simple quotte permet de délimiter une chaîne contenant une des espaces, tous
les caractères spéciaux perdent leurs signification à l'exécution elle-même et les
variables de sont pas substituées par leur valeurs
\ l'anti-slash il fait perdre la signification du caractère spécial qu'il précède.

" le double quotte permet de délimiter une chaîne de caractères contenant des
espaces, les caractères spéciaux perdent leur signification exécptés les quatre
suivants ($ \ '' ) alors que les variables sont substituées par leur valeur.
() les parenthèses permettent d'exécuter les commandes entre eux dans un sous shell.

`cmd` l'apostrophe permet d'exécuter et substituer les commandes par leur résultat
touche (alt+7)

Exemples:
$ echo il y a ` ls | wc -l ` fichiers dans `pwd`

$ a=5
$ b='$a'
$ c=''$a''
$ d=\$a
$ echo $a $b $c $d
5 $a 5 $a
VI. Les variables
1. Les variables utilisées par le shell
Appelées aussi variables d'environnement utilisées par le shell pour configurer son
environnement et soient utilisable par des programmes à exécutés. Par convention, elles sont en
majuscule.
$ echo $PATH # affichage de son contenue
$ PATH=$PATH:. # modification de son contenue en lui ajoutant ''.'' (sans espaces)

Les plus importantes sont :

HOME Spécifie le « home directory » le répertoire d'accueil

PATH Définit la liste de répertoires où une commande (ou programme ) à exécuter

doit être recherchée.

PS1 (prompt string) spécifie le texte de la sollicitation du shell.

Exemple : $ PS1="[\u@\h \W]\$"
donnera pour l’utilisateur étudiant sur la machine localhost dans le répertoire
$HOME/bin
[etudiant@localhost etudiant/bin]$
Les caractères spéciaux précédés de \ ont pour signification :
\u userid
\h host : nom de l’ordinateur
\W working directory : répertoire courant
\d date
\t heure

Exemple :
$ PS1="[\u]\$ "
[etudiant]$ PS1="[\t]\$"
[09:05:16]$ PS1="[\d]\$ "
[Sat Sep 22]$ PS1="[\u@\h \W]\$"
[etudiant@localhost etudiant]$
SHELL Le shell utilisé

PWD Répertoire courant

OLDPWD Répertoire précédent le dernier cd

UID uid de l'utilisateur

2. Les variables du shell

Le shell offre des variables spéciales initialisées à chaque exécution d'une commande. on les
appelle aussi les variables prédéfinies

$? code retour de la dernière commande

$0 nom du shell-script
$1,$2,...$9 Premier, deuxième,.... argument passé au script (voir les paramètres XI )
$* liste regroupe les paramètres sous forme '' $1 $2 ...$9''
 $@ liste regroupe les paramètres sous forme neuf chaîne de caractères ''$1'',''
$2'' ...''$9''
$$ numéro de processus du shell courant
$# Nombre de paramètres transmis à l'appel du script
$! Numéro du dernier processus exécuté en arrière plan

Attention : ces variables ne doivent pas être affecter via le symbole d’affectation = , elles sont
modifiables seulement par le shell ou via la commande set.

3. Les variables utilisateur

Comme pour tout langage de programmation, une variable est utilisée pour stocké des valeurs
intermédiaires
a) Affectation
En programmation shell, la définition n'est pas explicite, mais elle est assurée soit par
affectation ou par la commande read
$ var=125 # sans espaces au l'entour de ''=''
$ read var # toute la ligne saisie qui précède (entrer) sera affecter a var
Attention
La notion de type n'existe pas en shell, toute est chaîne de caractères.

b) Affichage
est assurée par $
$ echo $var # ou encore echo ${var}

c) Action par défaut

{var:-mot} Si var indéfinie ou vide on retourne mot sans affectation

{var:=mot} Si var indéfinie ou vide on affecte mot à var

{var:?mot} Si var indéfinie ou vide on affiche le message mot et interrompe

l'exécution.

{var:+mot} Si var et non vide on retourne mot

Exemple :
a=paf Trace d'exécution
echo ${a:-pif}
paf
echo $a
paf
echo ${a:=paf}
paf
echo $a
paf
a=pouf
pouf
echo ${a:=paf}
crac
echo ${a:+crac}
#rien
a=
echo ${a:+crac}
 d) Portée
Par défaut, une variable est définie dans un contexte local. Ceci signifie qu'une variable
définie dans un contexte (shell père) n'est pas visible dans le contexte shell fils.
Pour quelle soit visible, elle doit être exportable avec la commande export ce qui permet la
copie du nom et le contenu dans tous les processus fils.
Contenu des fichiers Trace d'exécution
$ cat ANCETRE
a=bonjour; b=salut; c=bonsoir
export a
./PERE $ bash ANCETRE
echo ''ANCETRE : $a $b $c $d'' PERE1 : bonjour
$ cat PERE PERE 2: moi toi nous vous
echo ''PERE 1 : $a $b $c $d'' FILS : moi vous
a=moi ; b= toi ; c=nous ; d=vous ANCETRE : bonjour salut bonsoir
export d
echo ''PERE 2:$a $b $c $d''
./FILS
$ cat FILS
echo ''FILS :$a $b $c $d''

Attention : export dans un seul sens (du père en fils)

Remarques:
 Pour visualiser les variables exportées on utilise la commande export -p
 Pour supprimer une variable on utilise unset (exp: unset var)

VII. La commande test

C’est une commande interne du shell qui permet l'évaluation des expressions, elle est utilisée avec
les instructions if , while , until . Elle renvoie vrai (0) ou faux(1).

Le contexte d'utilisation du test est :

· Comparaison de deux caractères
· Comparaison mathématique de deux nombres
· Comparaison de chaînes
· test d’un attribut de fichier (pour vérifier la nature d’un fichier)

On peut utiliser [ ] aussi pour les mêmes raisons.

test liste_expressions
ou [ liste_expressions]

tests unaires pour fichier:

test -e fichier vrai si fichier existe

 test liste_expressions
ou [ liste_expressions]

test -d fichier vrai si fichier existe et est un répertoire

test -f fichier vrai si fichier existe et est un fichier ordinaire
test -r fichier vari si fichier existe et est accessible en lecture pour vous
test -w fichier vrai si fichier existe et est accessible en écriture pour vous
test -x fichier vrai si fichier existe et est exécutable
test -s fichier Vrai si fichier est non vide

tests unaires pour chaînes :

test -z $str1 Vrai si chaîne est vide

test -n $str1 Vrai si chaîne est n'est pas vide
test $str1 Vrai si chaîne est n'est pas vide

tests binaires sur chaînes:

test $str1 = $str2 Vrai si les chaînes str1et str2 sont égales
test $str1 != $str2 Vrai si les chaînes str1et str2 sont différentes

tests binaires sur les valeurs entières

test $nb1 -eq $nb2 Vrai si nb1 = nb2
test $nb1 -ne $nb2 Vrai si nb1 != nb2
test $nb1 -gt $nb2 Vrai si nb1 > nb2

test $nb1 -lt $nb2 Vrai si nb1 < nb2

test $nb1 -ge $nb2 Vrai si nb1 >= nb2
test $nb1 -le $nb2 Vrai si nb1 <= nb2

Remarques :
 la liste des expressions est obtenue en utilisant And(-a) Or (-o ) Not (!)
 AND est plus prioritaire que OR

if test $a -eq $b -a $a -gt 0 ;then # équivalente à : si a=b and a >0

if test \( $a -eq $b \) -a \( $a -gt 0 \) # équivalente

VIII. Les expressions arithmétiques

Sous UNIX / LINUX, la réalisation des expressions arithmétiques est réalisée par la commande
expr qui doit être entre apostrophe.
 $ i=3
$ var=`expr $i + 2` ; echo $var
5
$ var=`expr $var \* 2` ; echo $var # \ pour ignorer l'interprétation du shell du *
10
$ var=`expr $var % 3` ; echo $var # reste de la division
1

IX. Les paramètres

il est possible de créer des scripts paramétrés c'est à dire qu'il va accepter des arguments au moment
de l'appel. De ce fait, le shell va initialiser les variables spéciales ( variables du shell voir VI. 2.) .

Figure 3 : appel d'un script paramètre

Remarques:
La commande shift permet le décalage vers la gauche les valeurs des arguments de point de vue les
variables positionnelles.

Explication:
Avant shift les arguments : a b c d
$1 $2 $3 $4
Après shift les arguments : b c d
$1 $2 $3 $4

X. Les structures de contrôles

1. Conditionnelles : if then [elif] [else] fi

structure simple
if condition # condition soit vrai=0 OU faux=1 À retenir :
then
1. Pour évaluer la condition on
<liste d'instructions_1 >
utilise:
else
 test ,
<liste d'instructions_2 >
 [ ], # attention avec espaces
fi
 ou une commande

2. on peut écrire toute la structure

sur la même ligne
 Avant un mot clé on utilise
un «;»

Exemples

#!/bin/bash #!/bin/bash
echo $i
echo -n "donner i " ; read i if grep -E "^ahmed:" /etc/passwd
if [ $i -eq 5 ] ##### test $i -eq 5 2>/dev/null ;then
then echo L\'utilisateur ahmed existe.
echo '$i = 5' else
echo "$i = 5" echo L\'utilisateur ahmed n\'existe
else pas.
echo "$i != 5" fi
fi
## REMARQUE
## grep -q pour ne pas afficher le
résultat

#!/bin/bash
echo $i;read i;if [ $i -eq 5 ];then echo '$i = 5';echo "$i = 5";else echo "$i != 5";fi

## REMARQUE
## les processus soient exécutés d'une façon :
 séquentielles, # on utilise ;
 conditionnelles
 ET Logique # on utilise &&
 OU Logique # on utilise ||

Structure imbriquée :
if condition_1 À retenir :
then 1. elif regroupe (else et if ) donc il attend une
<liste d'instructions_1 > condition
elif condition_2
then 2. Dans une structure imbriquée on peut avoir
<liste d'instructions_2 > plusieurs elif
else 3. On ne peut avoir qu'un seul else qui se réfère
<liste d'instructions_3 > au dernier elif
fi

Exemple :
Ecrire un script shell qui reçoit deux paramètres noms de fichiers. Il permet de tester si ces deux
fichiers sont liés ou non.
Solution:

if [$# -ne 2 ] ; then # on peut ecrire if ! [ $# -eq 2 ]

echo erreur de paramètres ; exit 1
elif test $1 -ef $2 ; then
echo les deux fichiers sont liés
else
echo les deux fichiers ne sont pas liés
fi

2. La structure sélective : case in esac

À retenir
case expression in
modèle_1) commandes ;; Le modèle peut contenir les syntaxes suivantes :
modèle_2) commandes ;;
..... * N’importe quelle chaîne de caractères
*) commandes;; ? N’importe quel caractère
esac | un OU Logique

Exemples :
echo -n "Entrer le nom d'animal : " case $réponse in
read ANIMAL
echo -n "L'$ANIMAL possède " [yYoO ] ) echo "OK ! valeur valide" ;;
case $ANIMAL in n | N ) echo "aucun traitement" ;;
cheval | chien | chat) echo -n "quatre" ;;
poule | kangourou ) echo -n "deux" ;; *) echo "erreur de saisie! Invalide" ;;
*) echo -n "un nombre inconnu de " ;;
esac esac
echo " pieds."

XI. Les structures itératives

1. La structure : for [ in ] do done
Syntaxe 1: À retenir
for var [in liste...] 1. for peut parcourir toute une liste de valeurs
do
commandes 2. Par défaut, si la liste est optionnelle, si elle est
done omise la variable var prendra les différentes
valeurs des arguments d'appel du script en
## REMARQUE exécution.
## possible sur une seule ligne

Exemples :
x=1 for var in `ls *` # `substitution de commandes
for var in 2 3 4 5 6 7 8 9 do
do echo " $var "
x=`expr $x \* $var` done
done

2. La structure while : while do done

Syntaxe : À retenir
while test expressions tant que test expression est VRAI (0) , la liste
do des commandes est exécutées
liste des commandes
done
## REMARQUE
Remarque:
## possible sur une seule ligne break permet de quitter la boucle
Exemples :

$ i=0; while test $i -ne 10 ;do i=`expr $i+1` ; echo $i ;done

# Saisie d’un nom de fichier
while [ -z $fich ]
do
echo Entrez un nom de fichier
read fich
done
if [ -f $fich ]
then
echo ce fichier existe
else
echo "ce fichier n’existe pas"
fi

3. La structure until :until do done

Syntaxe : À retenir
until test expressions la liste des commandes est exécutée jusqu'à ce
do que test expression donne un VRAI (0)
liste de commandes
done
## REMARQUE
Remarque:
## possible sur une seule ligne break permet de quitter la boucle