Les scripts shell
Oumaya BAALA & Francis TOSSOU
FEMTO-ST/DISC/OMNI
FISE INFO
https://moodle.utbm.fr/course/view.php?id=2634
Le script shell
Variables prédéfinies
Constructions spécifiques
Structures de contrôle
Les scripts shell 2
Le script shell
▶ Deux modes d’utilisation du shell :
▶ Interactif, en ligne commande
▶ Non-interactif, scripts ou batch
▶ Un shell peut exécuter des commandes à partir d’un fichier texte
=⇒ script shell
▶ Un “script shell” est un ensemble de commandes pour le shell,
rassemblées dans un fichier en mode texte
▶ C’est un programme comprenant des commandes internes du
shell, des structures de contrôle, qui est interprété
Les scripts shell 3
Le script shell
▶ Comment lancer un script shell ?
▶ Méthode 1 : lancer la commande suivante
mon_shell nom_script [param_script]
▶ Utiliser le nom de l’interpréteur de commande qui doit exécuter le
script (sh, bash, ...)
▶ Il faut s’assurer de la compatibilité entre le shell spécifié et le langage
du script (i.e. tcsh ̸= bash)
▶ Méthode 2 : rendre exécutable le script, et l’utiliser comme une
commande shell
nom_script [param_script]
▶ Droit d’exécution sur le fichier
▶ La première ligne du fichier indique quel interpréteur de commande
utiliser, à défaut, sh qui sera utilisé
▶ L’exécution du script dépend de sa présence dans l’un des répertoires
décrits dans $PATH
Les scripts shell 4
Le script shell
▶ Exemple très simple
[obaala@localhost ~]$ cat > nom_script
#!/bin/bash
echo "Ceci est une démo pour SY44"
exit 0 # La valeur de retour, 0 = Ok
# Ctrl-C
[obaala@localhost ~]$ chmod u+x nom_script
[obaala@localhost ~]$ ./nom_script Ceci est une liste de paramètres
Ceci est une démo pour SY44
[obaala@localhost ~]$ echo $?
O
[obaala@localhost ~]$
Les scripts shell 5
Variables
▶ Une variable est une suite de caractères alphanumérique
associée éventuellement à une valeur
▶ Une variable doit être de la forme :
[A-Za-z_][A-Za-z0-9_]*
▶ Par exemple, vehicule, ANNEE, Nom_Script, _maxSize sont des
variables
▶ Pas de type de variable en shell, toutes les valeurs sont des
chaînes de caractères =⇒ pas de déclaration des variables, pas
de valeur numérique
Les scripts shell 6
Opérations sur une variable
▶ Affectation :
variable=valeur
▶ Lecture :
$variable
# ou
${variable}
▶ Visualisation des variables prédéfinies (utilisateurs et système) :
set
▶ Suppression :
unset variable
▶ Protection en écriture :
readonly variable
▶ Liste des variables protégées en écriture :
readonly
Les scripts shell 7
Le script shell
Variables prédéfinies
Constructions spécifiques
Structures de contrôle
Les scripts shell 8
Variables prédéfinies
▶ Les variables de substitution
$0 Nom du script ou pathname.
$1 à $9 Les 8 premiers paramètres passés au script, si
un paramètre est manquant, sa valeur sera vide.
$9 Valeur du 9ème paramètre, qui peut contenir la
liste des paramètres à partir du 9ème.
Avec les interpréteurs de langage de script, ksh
et bash, il est possible d’aller au delà de 9 argu-
ments en utilisant les variables ${10}, ${11}, etc.
Exemple :
# Script nom_script
#!/bin/bash
echo "param=$9"
Exécution :
[obaala@localhost ~]$ ./nom_script a b c d \
e f g h i j k l
param=i j k l
[obaala@localhost ~]$
Les scripts shell 9
Variables prédéfinies
▶ Les variables de substitution
$# Nombre de paramètres passés au
script.
$* Chaîne de caractères combinant ensemble des paramètres position-
tous les paramètres passés au script nels, équivalent à
en une chaîne et séparés par des es- "$1 $2 ... ${n}"
paces, équivalent à :
"$1 $2 $3 $4 $5 $6 $7 $8 $9"
$@ Chaîne de caractères qui traite ensemble des paramètres position-
chaque paramètre comme un élé- nels, équivalent à
ment distinct, chaque paramètre est "$1" "$2" ... "${n}"
préservé comme une chaîne sépa-
rée, même s’il contient des espaces,
équivalent à :
"$1" "$2" "$3" "$4" "$5" "$6" "$7" "$8"
"$9"
Les scripts shell 10
Variables prédéfinies
▶ Et le reste des variables de substitution
▶ $? : code retourné par la dernière commande exécutée
▶ $$ : numéro de processus du shell actif
▶ $! : numéro du dernier processus lancé en arrière plan
▶ $- : flags définis dans l’environnement du shell (set) pour modifier
son comportement
Les scripts shell 11
Le script shell
Variables prédéfinies
Constructions spécifiques
Structures de contrôle
Les scripts shell 12
Constructions spécifiques
▶ Commande interne shift
▶ Modification des paramètres positionnels : décalage des
paramètres d’une ou plusieurs position vers la gauche
▶ shift [n] : décale les paramètres de n positions vers la gauche,
par défaut n = 1
▶ Exemple :
echo $*
shift 2
echo $*
▶ Résultat :
[obaala@localhost shell]$ chmod u+x nom_script.sh
[obaala@localhost shell]$ ./nom_script.sh CM SY44 2025 UTBM Script_shell.tex
CM SY44 2025 UTBM Script_shell.tex
2025 UTBM Script_shell.tex
[obaala@localhost shell]$
Les scripts shell 13
Constructions spécifiques
▶ Commande interne exit
▶ Sortie et code de retour : terminer un script
▶ Sans paramètre, le code de retour est le code de sortie de la
dernière commande du script qui précède exit
▶ $? variable utile pour tester le résultat d’une commande dans un
script
exit [code] Arrête immédiatement l’exécution du script et retourne le
code de retour code
# Un commentaire Permet de commenter un script.
La fin du commentaire correspond au prochain retour à
la ligne
Les scripts shell 14
Constructions spécifiques
▶ Commande interne continue
▶ continue [n] : ignore l’exécution d’un bloc d’instructions,
lorsqu’une condition est remplie, pour passer à la prochaine
occurrence d’une boucle
▶ Revenir au début de la boucle for, while, until (sauter les
instructions du corps de la boucle, continuer à l’itération suivante)
▶ n ≥ 1 : niveau de boucle à partir de la boucle la plus proche de
l’instruction (1 par défaut)
while...
for...
...
...
continue 2 # Renvoie à la prochaine occurrence du while
...
...
done
...
done
...
Les scripts shell 15
Constructions spécifiques
▶ Commande interne break
▶ Break [n] : instruction de rupture de boucle
▶ Sortir d’une ou de n boucle(s) for, while, until, en allant au niveau
n ≥ 1 (1 par défaut)
▶ n = niveau de boucle à partir de la boucle la plus proche de
l’instruction
for...
while...
...
...
break 2
...
...
done
...
done
... # on se retrouve alors ici
Les scripts shell 16
Le script shell
Variables prédéfinies
Constructions spécifiques
Structures de contrôle
Les scripts shell 17
Structures de contrôle
▶ Les structures de contrôle dans les scripts shell sont essentielles
pour gérer le flux d’exécution des commandes en fonction de
conditions spécifiques
▶ Elles permettent d’exécuter des blocs de code de manière
conditionnelle ou répétitive, rendant les scripts plus dynamiques
et efficaces
test Test conditionnel
expr Évaluation d’expression
if...then...else...fi Conditionnelle
case...in...do...esac Choix multiple
for...in...do...done Boucle bornée
while...do...done Boucle non bornée
until...do...done
Les scripts shell 18
Structures de contrôle
▶ Expressions conditionnelles : commande test
▶ Le shell ne reconnaît que le type "chaîne de caractères" et
l’opérateur de concaténation
▶ La commande test est un outil essentiel dans les scripts shell
pour évaluer des conditions et effectuer des comparaisons
▶ Vérification de la validité d’une expression, que ce soit pour des
fichiers, des chaînes de caractères ou des valeurs numériques
▶ Syntaxe de base de la commande
test expression ou [ expression ]
▶ L’argument passé à la commande test est une expression booléenne
▶ Si cette expression est validée, test a pour code de retour 0, 1 sinon
▶ Quelques exemples :
test howto = forge && echo "same"
test 5 -eq 5 && echo "same"
[ "$str1" != "$str2" ]
Les scripts shell 19
Structures de contrôle
▶ Commande test : opérateurs sur des fichiers
Expression
-e fichier Vrai si fichier existe
-f fichier Vrai si fichier existe et est un fichier ordinaire
-d fichier Vrai si fichier existe et est un répertoire
-L fichier Vrai si fichier existe et est un lien symbolique
-r fichier Vrai si fichier existe et on a le droit Read
-w fichier Vrai si fichier existe et on a le droit Write
-x fichier Vrai si fichier existe et on a le droit eXecute
-b fichier Vrai si fichier existe et est un fichier spécial en mode bloc
-c fichier Vrai si fichier existe et est un fichier spécial en mode carac-
tère
-s fichier Vrai si fichier existe et a une taille > 0
fichier1 –nt fichier2 vrai si fichier1 a été modifié plus récemment que fichier2
fichier1 -ot fichier2 vrai si fichier1 a été modifié moins récemment que fichier2
Les scripts shell 20
Structures de contrôle
▶ Commande test : opérateurs sur les chaînes
Expression
-z chaîne strlen(chaîne) == 0
-n chaîne strlen(chaîne) != 0
chaîne1 = chaîne2 strcmp(chaîne1,chaîne2) == 0
chaîne1 != chaîne2 strcmp(chaîne1,chaîne2) != 0
Les scripts shell 21
Structures de contrôle
▶ Commande test : opérateurs logiques et de comparaison
numérique
Expression
!expr vrai si expr est fausse
expr1 –a expr2 ((expr1) && (expr2))
expr1 –o expr2 ((expr1) || (expr2))
expr1 -eq expr2 Vrai si expr1 est égal à expr2
expr1 -neq expr2 Vrai si expr1 est différent de expr2
expr1 -lt expr2 Vrai si expr1 est strictement inférieur à expr2
expr1 -le expr2 Vrai si expr1 est inférieur ou égal à expr2
expr1 -gt expr2 Vrai si expr1 est strictement supérieur à expr2
expr1 -ge expr2 Vrai si expr1 est supérieur ou égal à expr2
Les scripts shell 22
Structures de contrôle
▶ Commande expr
▶ La commande expr est un outil pratique pour évaluer des
expressions arithmétiques et manipuler des chaînes dans les
scripts shell
Syntaxe de base : expr expression
expr $nbr1 opérateur $nbr2
expr $chaine : expression régulière
▶ "expression" peut être une combinaison d’opérateurs arithmétiques
et de valeurs
▶ La commande évalue les arguments comme une expression puis
envoie le résultat sur la sortie standard
▶ Les opérandes peuvent être des nombres ou des chaînes de
caractères
▶ Les opérateurs qui ont une signification particulière pour le shell
doivent être protégés par un antislash !
Les scripts shell 23
Structures de contrôle
▶ Commande expr : opérateurs arithmétiques
Opérateurs arithmétiques Signification
$nb1 + $nb2 Addition
$nb1 - $nb2 Soustraction
$nb1 \* $nb2 Multiplication
$nb1 / $nb2 Division
$nb1 % $nb2 Modulo
Les scripts shell 24
Structures de contrôle
▶ Commande expr : opérateurs de comparaison
Opérateurs de comparaison Signification
$nb1 \> $nb2 VRAI si $nb1 est strictement supérieur à $nb2
$nb1 \>= $nb2 VRAI si $nb1 est supérieur ou égal à $nb2
$nb1 \< $nb2 VRAI si $nb1 est strictement inférieur à $nb2
$nb1 \<= $nb2 VRAI si $nb1 est inférieur ou égal à $nb2
$nb1 = $nb2 VRAI si $nb1 est égal à $nb2
$nb1 != $nb2 VRAI si $nb1 est différent de $nb2
Les scripts shell 25
Structures de contrôle
▶ Commande expr : opérateurs logiques
Opérateurs logiques Signification
$chaine1 \& $chaine2 VRAI si les 2 chaines sont vraies
$chaine1 \| $chaine2 VRAI si l’une des 2 chaines est vrai
Opérateurs divers Signification
-$nb1 Opposé de $nb1
\( expression \) Regroupement
$chaine : expression_reguliere Compare la chaine avec l’expression
régulière
Les scripts shell 26
Structures de contrôle
▶ Commande expr : exemple 1
▶ Les arguments de la commande expr doivent toujours être
séparés par au moins un espace ou une tabulation
[obaala@localhost ~]$ nb=20
[obaala@localhost ~]$ expr $nb + 15
35
[obaala@localhost ~]$ expr $nb \* 3
105
[obaala@localhost ~]$ expr $nb / 5
21
[obaala@localhost ~]$ nb=25
[obaala@localhost ~]$ expr $nb % 4
1
[obaala@localhost ~]$ expr $nb - -6
31
[obaala@localhost ~]$
Les scripts shell 27
Structures de contrôle
▶ Commande expr : exemple 2
▶ Récupérer le résultat dans une variable :
[obaala@localhost ~]$ nb2=`expr $nb - 2`
[obaala@localhost ~]$ echo $nb2
23
[obaala@localhost ~]$
▶ Priorité d’exécution des opérateurs :
[obaala@localhost ~]$ nb=3
[obaala@localhost ~]$ nb2=`expr $nb \* 4 + 5`
[obaala@localhost ~]$ echo $nb2
17
[obaala@localhost ~]$ nb2=`expr $nb \* \( 4 + 5 \)`
[obaala@localhost ~]$ echo $nb2
27
[obaala@localhost ~]$
Les scripts shell 28
Structures de contrôle
▶ Syntaxe de l’instruction if
if [ expression1 ]
then liste_commandes1
[else liste_commandes2]
fi
▶ Une variante pratique pour utiliser plusieurs conditions dans un
bloc if-else
if [ expression1 ]
then liste_commandes1
elif [ expression2 ]
then liste_commandes2
elif [ expression3 ]
then liste_commandes3
else
liste_commandes4
fi
▶ Si expression1 est vraie, alors le bloc liste_commandes1 est
exécuté, etc.
▶ Les listes d’instructions sont des commandes shell qui sont
réalisées en fonction de la valeur booléenne des conditions
Les scripts shell 29
Structures de contrôle
▶ Instruction if : exemple
#!/bin/bash
if [ $# -eq 1 ]; then
echo "Voici le contenu du fichier $1 :"
echo "`cat $1`"
else
echo "Erreur : Il faut passer un paramètre au script"
fi
▶ Ce script affiche le contenu du fichier passé en paramètre
▶ S’il n’y a pas exactement un paramètre, un message d’erreur est
affiché
Les scripts shell 30
Structures de contrôle
▶ Instruction case
case EXPRESSION in
motif-1) instruction ;;
motif-2) instruction ;;
motif-3 | motif-4) instruction ;;
*) instruction ;;
esac
▶ Si EXPRESSION correspond à l’un des motifs, alors l’instruction
correspondante est exécutée (et seulement celle-ci)
▶ EXPRESSION respecte les règles des méta-caractères de
construction des noms de fichiers
▶ L’évaluation des motifs s’arrête dès que l’un d’entre eux correspond
à EXPRESSION
▶ Attention à ne pas oublier les ; ; à la fin de chaque instruction
Les scripts shell 31
Structures de contrôle
▶ Instruction case : 1er exemple
#!/bin/bash
case $var in
0) echo "Démarrage du service..." ;;
1) echo "Arrêt du service..." ;;
*) echo "Valeur invalide"
exit 1 ;;
esac
▶ Ce script initialise la variable avec le chemin courant
▶ Si aucun paramètre n’est donné
▶ Avec le premier paramètre s’il est donné
▶ Ou affiche un message d’erreur dans les autres cas
Les scripts shell 32
Structures de contrôle
▶ Instruction case : 2e exemple
#!/bin/bash
case $1 in
*.jpg|*.jpeg|*.png) display $1 ;;
*.mp3|*.wav) mpg123 $1 ;;
*.txt|*.md) less $1 ;;
*.sh) bash $1 ;;
*) echo "Type de fichier inconnu, impossible d'ouvrir $1"
exit 1 ;;
esac
▶ Ce script lance un logiciel permettant d’afficher le fichier dont le
nom est passé en paramètre
▶ On lui préfèrera la commande xdg-open qui sait le faire pour un
grand nombre de types de fichiers
Les scripts shell 33
Structures de contrôle
▶ Instruction for
for <VARIABLE> in <liste_d_elements>
do
# Commandes à exécuter pour chaque élément
done
▶ La variable identifiée par VARIABLE prend ses valeurs
successivement dans liste_d_elements
▶ Pour chaque valeur prise par la variable VARIABLE, les
commandes sont exécutées
▶ Si liste_d_elements est vide, ce sont les paramètres du script qui
seront utilisés (i.e. $@)
Les scripts shell 34
Structures de contrôle
▶ Instruction for : exemple
#!/bin/bash
for script in `ls *.py`; do
chmod u+x $script
done
▶ Ce script donne le droit d’exécution au propriétaire sur tous les
fichiers du répertoire courant ayant l’extension .py
▶ Attention, s’il y a des espaces dans le nom du script, ça ne
fonctionnera pas (espace est un séparateur de champs)
Les scripts shell 35
Structures de contrôle
▶ Instruction while
while [ CONDITION ]
do
# Instructions à exécuter tant que la condition est vraie
done
▶ Cette structure de contrôle permet d’exécuter la liste d’instructions
tant que l’expression est vérifiée
▶ CONDITION doit être une commande shell fournissant un code de
retour
▶ Évaluée par "vrai" (resp. "faux") si elle est égale à 0 (resp. ̸= 0)
▶ La commande test est généralement utilisée pour vérifier une
condition
Les scripts shell 36
Structures de contrôle
▶ Instruction while : exemple
#!/bin/bash
tentatives=0
max_tentatives=3
while [ $tentatives -lt $max_tentatives ]
do
read -p "Mot de passe : " mdp
if [ "$mdp" == "secret" ]; then
echo "Connexion réussie !"; break
else
echo "Erreur !"; tentatives=`expr $tentatives + 1`
fi
done
▶ Ce script redemande le mot de passe à l’utilisateur tant que le
nombre de tentatives échouées ne dépasse pas 3
Les scripts shell 37
Structures de contrôle
▶ Instruction until
until [ CONDITION ]; do
# Instructions à exécuter jusqu'à ce que la condition
# soit vraie
done
▶ Cette structure de contrôle permet d’exécuter la liste d’instructions
jusqu’à ce que l’expression soit vérifiée
▶ CONDITION doit être une commande shell fournissant un code de
retour
▶ Évaluée par "vrai" (resp. "faux") si elle est égale à 0 (resp. ̸= 0)
▶ La commande test est généralement utilisée pour vérifier une
condition
Les scripts shell 38
Structures de contrôle
▶ Instruction until : exemple
#!/bin/bash
tentatives=0
max_tentatives=3
until [ $tentatives -ge $max_tentatives ]
do
read -p "Mot de passe : " mdp
if [ "$mdp" == "secret" ]; then
echo "Connexion réussie !"; break
else
echo "Erreur !"; tentatives=`expr $tentatives + 1`
fi
done
▶ Ce script redemande le mot de passe à l’utilisateur jusqu’à ce que
le nombre de tentatives échouées dépasse 3
Les scripts shell 39
Structures de contrôle
▶ Fonctions
[ function ] nom_fonction () {
liste_commandes;
[ return code ] ;
liste_commandes;
}
▶ Une fonction est une séquence d’instructions définie par un nom
▶ Contrairement à un script, elle s’exécute dans le shell courant et
non pas dans un shell fils
▶ Une fonction doit être définie avant son appel
▶ Pour appeler une fonction, il suffit d’utiliser son nom sans les
parenthèses
nom_fonction [paramètres]
Les scripts shell 40
Structures de contrôle
▶ Fonctions
▶ Comme pour un script, l’appel d’une fonction peut être
éventuellement suivi d’une liste d’arguments accessibles dans la
fonction à l’aide de paramètres positionnels
▶ A l’intérieur d’une fonction, les variables $1 à ${n}, $#, $* et $@
sont redéfinies pour correspondre aux paramètres de la fonction
(et non plus ceux du script)
▶ La fonction se termine
▶ A sa dernière instruction, située avant l’accolade fermante : code de
retour de la fonction = code de retour de la dernière instruction
▶ Quand elle rencontre l’instruction return (code de retour indiqué en
paramètre ou = 0 par défaut) avant la fin de son appel
▶ Dans les 2 cas, le code de retour de la fonction est affecté au
paramètre $? du shell courant
Les scripts shell 41
Redéfinition des variables de fonction
#!/bin/bash
if [[ $# -ne 2 ]]; then
echo "Syntaxe: $0 param1 param2"
exit 1
fi
function display_param() {
echo "display_param: \$1 = $1, \$2 = $2"
}
echo "Valeur des params dans le Script : \$1 = $1, \$2 = $2"
echo "--> Remarquez l'ordre des paramètres"
echo "Appel fonction display_param $2 $1"
display_param $2 $1
Les scripts shell 42
Résultat
[obaala@localhost ~]$ vim nom_script.sh
[obaala@localhost ~]$ chmod u+x nom_script.sh
[obaala@localhost ~]$ ./nom_script.sh Cours SY44
Valeur des params dans le Script : $1 = Cours, $2 = SY44
--> Remarquez l'ordre des paramètres
Appel fonction display_param SY44 Cours
display_param: $1 = SY44, $2 = Cours
Les scripts shell 43
Structures de contrôle
▶ Fonctions
#!/bin/bash
function convertir_nb() {
if [ -z "$*" ]; then
return 1
else
for image in $@; do
convert "$image" -monochrome "nb_$image"
done
return 0
fi
}
convertir_nb `ls *.jpg`
echo "Code de retour = $?"
Les scripts shell 44
