Direction Générale des Etudes Technologiques
Institut Supérieur des Etudes Technologiques de Djerba
Enseignant : Traouli Abdelhakim Classe :L1TI2
TRAVAUX PRATIQUES N° :4
Les Scripts SHELL
Le Shell est un interpréteur de commandes. Lorsque vous tapez une commande, il effectue
différentes opérations et transfert la commande interprétée au noyau du système
d'exploitation pour exécution.
Dans le cas où la commande est simple, il suffit de la taper directement après le prompt (ie :
en ligne de commande). Mais parfois une commande nécessite plusieurs arguments, des tests
et des redirections, auquel cas il est préférable d'écrire un programme.
Ce programme est en fait un simple fichier texte qui contient une suite de commande Unix. Il
doit être exécutable (bit x activé). Cet atelier présente la façon dont est structuré un
programme Shell et les structures auxquelles il fait appel. Plusieurs exemples de programmes
Shell seront proposés afin d'illustrer ces propos. Avant de s'attaquer au problème des scripts,
allons plus loin en ce qui concerne le Shell interactif.
I. Les jokers
Le Shell gère ce que l'on appelle des caractères joker. C'est lui qui a la charge de convertir
ces jokers en noms de fichiers, qu'il passera alors aux commandes invoquées.
Joker rôle exemple
* Remplacement d'une chaîne de ls ab*
0 à n caractères ab1 ab2 ab3 ab4 ab10
abbaye.html about.txt
? Remplacement strict d'un ls ab?
caractère ab1 ab2 ab3 ab4
[xyz] Définit un ensemble (ici x y et ls ab[13578]
z) ab1 ab3
[x-z] Ensemble de x à z ls ab[1-3]?
ab10
[!x-y] Tout sauf l'ensemble de x à y ls ab[!1-3]* ab4 abbaye.html
about.txt
II. Élaboration d'un programme SHELL :
1) Procédures à suivre :
1. Il est bon (mais pas indispensable) de mettre l'instruction suivante en première ligne
du programme :
#!/bin/bash
Cela indique à l'interpréteur que ce qui va suivre est du Shell (en l'occurrence du
Bourne Again Shell - bash).
2. Le fichier contenant le code doit être rendu exécutable avant de lancer le programme.
Ou alors, il faut le lancer en argument d'un Shell
3. Pour lancer le programme, il faut taper la ligne suivante :
DEPARTEMENT INFORMATIQUE PAGE | 1
$ prog si votre variable PATH intègre le chemin du répertoire dans
lequel vous lancez le programme
$ ./prog Sinon...
$ sh ./prog Au cas ou le fichier ne soit pas exécutable....
2) Les arguments :
Comme tous programmes, les scripts acceptent des arguments. Pour récupérer et traiter le
contenu de ces arguments dans vos scripts, vous utiliserez le signe $
$1 contient le premier argument, $2 le second, et ainsi de suite, jusqu'à 9.
$* ou $@ indique tous les arguments...
$0 indique le programme lui-même...
$# renvoie le nombre d'arguments passés à la commande
3) Les variables :
Dans vos programmes, vous aurez parfois besoin de stocker des valeurs. Vous pourrez alors
créer des variables (non typés). Une variable a un nom. L'affection se fait en utilisant
l'opérateur = sans espace autour. L'utilisation du contenu de la variable se fait en ajoutant $
devant.
Il est possible de protéger le nom de la variable grâce aux accolades
$ MOT=chat
$ echo le pluriel de $MOT est ${MOT}s
le pluriel de chat est chats
Si vous voulez affecter une chaîne de plusieurs mots à une variable, protégez-la avec des
guillemets.
$ NOM="Cherrier Sylvain Claude Philippe"
$ echo $NOM
Cherrier Sylvain Claude Philippe
4) La commande read :
Cette commande permet la saisie au clavier (ou plutôt l'entrée standard) pour le
renseignement des variables. La commande read lit la ligne et remplit (selon le séparateur)
toutes les variables. Si le nombre de mot est supérieur au nombre de variable, c'est la dernière
variable qui contient toute la fin de la ligne. S’il y a plus de variable que de réponses, les
variables en trop ne sont pas définies...
$ echo "nom prénom :" ; read nom prenom
nom prenom : CHERRIER Sylvain
$ echo $prenom $nom
Sylvain CHERRIER
$ echo "nom prénom" ; read nom prénom
nom prénom : Baron SALIERE Alphonse Edouard
$ echo $prenom ; echo $nom
SALIERE Alphonse Edouard Baron
5) La commande test :
test expression
ou
[ expression ]
DEPARTEMENT INFORMATIQUE PAGE | 2
La commande test évalue expression, et retourne le résultat de cette expression (vrai ou faux).
Si aucune expression n'est donnée alors le résultat retourné prend la valeur faux.
Dans le cas de l'utilisation avec les crochets, il faut bien penser à mettre des espaces entre
expression et les crochets [ et ].
a) Les tests sur les nombres :
[ i -eq j ] : est vrai si i est égal à j (i et j sont des entiers) equal
[ i -ne j ] : est vrai si i est différent de j never
[ i -gt j ] : est vrai si i est supérieur à j Greater than
[ i -lt j ] : est vrai si i est inférieur à j Less than
[ i -ge j ] : est vrai si i est supérieur ou égal à j Greater or equal
[ i -le j ] : est vrai si i est inférieur ou égal à j Less or equal
b) Les tests sur les chaînes :
test chaîne vrai si chaîne n'est pas la chaîne nulle
test -z chaîne vrai si chaîne est vide (0 caractère)
test chaîne1 = chaîne2 vrai si chaîne1 et chaîne2 sont identiques
test chaîne1 != chaîne2 vrai si chaîne1 et chaîne2 sont différentes
c) Les tests sur les fichiers :
test -w, -r, -x fichier vrai si fichier existe et est autorisé en écriture, lecture ou
est exécutable(respectivement)
test -d fichier vrai si fichier existe et est un répertoire
test -f fichier vrai si fichier existe et n'est pas un répertoire
test -s fichier vrai si fichier existe et a une taille non nulle
6) Les structures de contrôle :
Les structures de contrôles d'un Shell sont des commandes internes qui permettent
d'imbriquer plusieurs commandes et fabriquer ainsi un bloc. Ce bloc est vu ensuite comme
une simple commande. On pourra ainsi rediriger le résultat d'un bloc vers une sortie
quelconque comme on le fait déjà avec une commande unique. Les structures de contrôle,
comme leur nom l’indiquent, permettent d'effectuer des tests (ou contrôles) sur les
arguments passés et réagissent en fonction de ces tests.
a) La structure if :
Syntaxe:
if (test1)
then
commande1
[ elif (test2) then
commande2 ]
[ else
commande3 ]
fi
DEPARTEMENT INFORMATIQUE PAGE | 3
Où test1 et test2 sont des commandes que le Shell évalue avant de faire son choix.
Exemple:
if find /etc/ -name toto
then
echo "il y a bien un fichier toto dans le répertoire /etc/"
else
echo "il n'y a pas de fichier toto dans le répertoire /etc/"
fi
Si le résultat de la commande find est vrai (code retour 0) alors la première ligne est affichée,
sinon c'est la deuxième ligne qui est affichée.
b) La structure for :
Syntaxe:
for var [ in liste ]
do
commande1
commande2
...
done
Où var est le nom d'une variable et liste est la liste des valeurs que prendra cette variable.
Exemple:
ls *.html
essai.html intro.html fin.html
cat prog
#!/bin/bash
for nom in *.html ; do
cp $nom /user/asi98/$1/src/
echo "fichier $nom copié dans $1"
done
$ prog julien
fichier essai.html copié dans julien
fichier intro.html copié dans julien
fichier fin.html copié dans julien
Remarque:
Si la liste n'est pas indiquée, alors c'est la liste des éventuels arguments du programme qui
sera évaluée.
c) La structure while :
Syntaxe :
while commande
do
commande2
commande3
done
DEPARTEMENT INFORMATIQUE PAGE | 4
Tant que commande est bien exécutée (code retour égal à 0) alors commande2 et
commande3 sont exécutées.
while [ "$reponse" != "36412" ] ; do
echo "Entrez le chiffre magique"
read reponse
done
echo "tricheur...
d) La commande exit :
exit [n]
Cette commande permet de sortir du Shell avec un code retour égal à l'entier n spécifié. Si [n]
est omis, le code retour de la sortie est celui de la dernière commande.
e) La commande expr :
Syntaxe :
expr argument
Dans argument il peut y avoir des opérations arithmétiques ou des évaluations entre variables.
La commande test récupère le résultat de ces opérations ou évaluations.
Exemples :
Perimetre = ` expr $L + $l + $L + $l`
echo " le perimetre du rectangle est $perimetre"
Remarque :
Puisque certains caractères utilisés dans les opérateurs arithmétiques ou logiques sont des
caractères reconnus par le Shell, il faudra penser à les inhiber à l'aide du caractère \
surface = ` expr $pi \* $R \* $R `
echo "la surface d'un cercle de rayon $R est $surface"
f) La commande shift
Cette commande permet de décaler le contenu des variables $0 1 2 et ainsi de suite... Si les
variables $1 et $2 contiennent respectivement début et fin, $1 contiendra fin après l'utilisation
de shift (et $2 sera non définie...)
Cette commande est utilisée dans des boucles, ou avec la commande set
III. Applications :
Exercice 1 : Ecrire un script Shell manipulant les quotes (simple, double et anti).
# !/bin/bash
var=exemple
echo contenu de var : $var
echo "contenu de var : $var"
echo 'contenu de var : $var'
echo `echo contenu de var : $var`
echo ceci est l\'exemple type de l\'apostrophe
echo "ceci est l'exemple type de l'apostrophe"
DEPARTEMENT INFORMATIQUE PAGE | 5
Exercice 2 : Ecrire un script Shell permettant l’affichage de plusieurs façons de la liste de ses
paramètres effectifs.
#!/bin/bash
echo "nom du script : $0"
echo -e nombre d\'arguments d\'appel : $#
if test $# -eq 0 ;then
echo "liste de paramètres vide"
else
echo "liste des paramètres obtenus par $* : $*"
echo "liste des paramètres obtenus par $@ : $@"
echo -e "liste des paramètres affichés par une boucle for : \n"
for i ; do
echo -e "$i \c"
done
echo -e "\nliste des paramètres obtenus par une boule while :"
while test $# -ne 0 ; do
echo -e "$1 \c";
shift
done
fi
Exercice 3 : Ecrire un script qui admet un unique paramètre optionnel devant correspondre à
un répertoire. Si ce paramètre est absent, on considérera le répertoire courant. Ce script
affichera la liste des fichiers qui sont inclus dans le répertoire indiqué, si celui-ci est valide.
#!/bin/bash
if test $# -gt 1 ; then
echo "erreur : trop de paramètres"
echo "usage : $0 [directory]"
elif test $# -eq 0 ; then
echo contenu du répertoire courant :
ls
elif test -d $1 ;then
echo contenu du répertoire $1
ls -l $1
else
echo "erreur : $1 n'est pas un répertoire"
echo "usage : $0 [directory]"
fi
Exercice 4 : Ecrire un script qui admet la spécification d’un répertoire comme paramètre et
qui affichera pour chaque fichier qu’il renferme son type. Un total par type de fichiers sera
également affiché.
#!/bin/bash
if [ $# -ne 1 ]; then
echo "erreur: un parametre est attendu"
echo "usage :$0 directory"
exit 1
fi
DEPARTEMENT INFORMATIQUE PAGE | 6
if test -d $1 ; then
nbFich=0
nbRep=0
nbScp=0
cd $1
for i in * ; do
if test -d $i; then
echo "$i est un repertoire"
nbRep=`expr $nbRep + 1`
elif test -f $i ; then
echo "$i est un fichier"
nbFich=`expr $nbFich + 1`
elif (ls $i); then
echo "$i est un fichier special"
nbScp=$(($nbScp + 1))
else
echo "$i inconnue"
fi
done
echo nombre total de repertoires : $nbRep
echo nombre total de fichiers : $nbFich
echo nombre total de fichiers spéciaux : $nbScp
else
echo "$1 n’est pas un repertoire"
fi
Exercice 5 : Ecrire un script qui affiche la liste des sous répertoires d’un ou plusieurs
répertoires passés en paramètres, ainsi que leur total. On testera à chaque fois la validité du
répertoire passé en paramètre.
#!/bin/bash
dir=`pwd`
if test $# -eq 0 ; then
echo "erreur : paramètres manquants"
echo "usage : $0 directory..."
else
for i in $* ; do
echo --------------------------------------
if ! test -d $i ; then
echo erreur : $i n\'est pas un répertoire
else
cd $i
Total=0
echo "liste des sous-répertoires de $i : "
for j in * ; do
if test -d $j ; then
echo $j
Total=`expr $Total + 1`
fi
done
DEPARTEMENT INFORMATIQUE PAGE | 7
echo "Total = $Total"
fi
done
echo --------------------------------------
cd $dir
echo "restitution du chemin initial"
fi
Exercice 6 : Ecrire un script Shell, ayant un fichier et deux nombres n1 et n2 en paramètres,
qui affiche les lignes comprises entre n1 et n2. (Avec n2>=n1)
#!/bin/bash
if [ $# -lt 3 ]; then
echo "erreur : paramètres manquants"
echo "usage : $0 [file] [n1] [n2]"
exit 1
fi
if [ -f $1 ]; then
if [ $2 -lt $3 &>/dev/null ]; then
fin=$(($3-1))
deb=$(($3-$2-1))
head -$fin $1|tail -$deb
else
echo "[n1] doit etre inferieur à [n2]"
fi
else
echo "nom fichier invalide"
fi
Exercice 7 : Ecrire un script qui affiche le menu suivant :
Pour lister les fichiers Tapez 1
Pour lister les répertoires Tapez 2
Pour afficher les droits d'accès du répertoire courant Tapez 3
Pour quitter Tapez 4
Entrez votre choix: 3
Vous avez choisi d'afficher les droits du rép.Rourant
DEPARTEMENT INFORMATIQUE PAGE | 8
