Scripts

Généralités
Variables et Opérations
Structures de Contrôle
Boucles
Fonctions
Tableaux
Automatisation

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 84

Généralités
• La programmation shell est avant tout une méthode pour automatiser les tâches
répétitives en ligne de commande.
• Le Shell (coquille en anglais) est le composant du système d'exploitation qui permet de
interpréter les commandes tapées au clavier (on l'appelle aussi interpréteur de
commandes).
• Aujourd'hui le Shell est en grande partie remplacé par les programmes fonctionnant avec
une interface graphique mais on s'en sert surtout pour automatiser des tâches grâce à la
programmation.
• Parmi les Shells les plus connus, il y a sous Windows 9X [Link], sous NT et
suivants [Link] et pour la partie graphique [Link].
• Sous Unix il en existe un certain nombre, dont les plus connus sont les suivants : Bourne
Shell, Bourne Again Shell, Z Shell, C Shell, Korn Shell, ...
• A l'heure actuelle, des langages comme Perl, Ruby ou Python prennent la relève des Shells
sans toutefois les remplacer totalement.
2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 85
Généralités
• Le Bash reprend le shell originel de Linux (Bourne Shell) et y intégre des améliorations
provenant d'autres Shells comme le Ksh et le Csh.
• Ce programme est libre (licence GPL) et a été porté sur Windows (Cygwin)
• Quel Shell utilisez-vous ?
• Dans le fichier /etc/passwd, il y a certaines informations concernant les utilisateurs et notamment le
shell qu'ils utilisent
• par exemple : nico:x:1000:1000:nico:/home/nico:/bin/bash
• Pour savoir tous les shells qui sont disponibles sur votre machine, vous pouvez taper : ls /bin | grep sh
• Un script Shell:
• Est un fichier texte dans lequel sont inscrites un certain nombre de commandes compréhensibles par
votre interpréteur de commandes.
• Pas de contrainte concernant le nom du fichier
• La première ligne doit toujours commencer par le nom de l'interpréteur de commandes : #!/bin/bash

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 86

Généralités
• La configuration initiale du script repose sur un shebang bien écrit et le choix d’une
extension appropriée.
• Le shebang (#!/bin/bash) dirige l’interpréteur pour exécuter le script.
• Une extension .sh offre une compatibilité avec divers shells, tandis que .bash cible
exclusivement Bash. Cette distinction permet d’adapter le script à l’environnement.
• Début de script avec shebang
Type de fichier Utilisation Compatibilité Exemple
• Fichier .sh pour compatibilité multi-shell
.sh Général Multi-shell [Link]
• Fichier .bash pour des besoins spécifiques Bash
.bash Spécifique [Link]
• Utilisation de scripts sans extension avec shebang uniquement

Fonction via
Sans extension Bash monScript
shebang

Selon
Personnalisé Variable [Link]
configuration

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 87

Généralités
• Un commentaire est toute phrase précédée par #.
• On peut écrire autant de lignes de commentaires qu’on souhaite.
• Exemple: #!/bin/sh
echo Bonjour # Un commentaire
# Un autre commentaire
• Pour exécuter un script, on doit avoir le droit d’exécution sur le fichier
• On peut vérifier que vous avez le droit d'exécuter ce fichier: ls -l
• On peut ajouter le droit d’exécution: chmod +x monfichier
• On peut l'exécuter en tapant : ./monfichier
• Exemple:
#!/bin/sh
clear
echo -n Vous utilisez le système
uname
echo
echo -n La version de votre noyau est
uname -r

• Ce script va afficher quelque chose comme ça à l'écran :

• Vous utilisez le système Linux
• La version de votre noyau est 2.6.8-2-386

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 88

Variables et Opérations
• Variables prédéfinies par le Bash
• Le bash et le système Linux d'une manière générale utilise ses propres variables pour fonctionner
• Par exemple le nom de l'utilisateur courant est stocké dans une variable nommée $USER.
• Vous pouvez taper echo $ USER pour voir ce qu'elle contient.
• # echo $USER
• root
• Les variables système sont nommées en majuscules pour éviter d'entrer en conflit avec les variables que vous
pourriez créer.
• Ne nommez donc pas vos variables en majuscules !
• Les principales variables prédéfinies sont :
• HOME (équivaut à ~): répertoire de l'utilisateur
• PATH : répertoires contenant des fichiers exécutables
• MAIL : chemin d'accès aux mails de l'utilisateur
• MAILCHECK : temps au bout duquel un mail est traité
• IFS : caractère de séparation des arguments
• TERM : nom du type de terminal
• PS1 : invite principale du shell en mode interpréteur
• PS2 : invite secondaire du shell en mode programmation
• Pour voir toutes les variables d'environnement auxquelles vous pouvez accéder : echo $ (et sans appuyer sur
Enter) <TAB>

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 89

Variables et Opérations
• Déclaration et Utilisation
• Pas besoin de déclarer les variables
• On peut directement affecter une valeur à une variable de cette façon : variable=valeur
• Par exemple : nom=Dupont
• Une variable est identifiée par son nom
• Le contenu de la variable est identifié par le symbole $ placé devant le nom
• Pour utiliser les variables qui ont été affectées, on utilise le signe $.
• echo $nom # Ceci affichera Dupont à l'écran
• Pour définir VARIABLE comme une variable d’environnement: export VARIABLE
• Substitution
• Bash réalisera la substitution du contenu d’une variable lorsqu’il rencontre $ suivi d’un nom de variable
• Deux comportements possibles :
• Substitution vide : La variable n’est pas définie ou la variable est définie mais son contenu est vide
• Substitution du contenu : La variable est définie et son contenu est non nul
$ MSG1="Jean est un " $ MSG1="Jean est un "
$ MSG2="chien fort réputé" $ MSG2="chien fort réputé"
$ echo "$MSG1 $METIER $MSG2" $ METIER="dresseur de"
Jean est un chien fort réputé $ echo "$MSG1 $METIER $MSG2"
2025-2026
Jean est un dresseur de chien fort réputé 90
Asmae EL KASSIRI - Environnement Unix/Linux
Variables et Opérations
• Substitution
• Bash est en mesure de substituer le résultat d’une ligne de commandes UNIX
• Le symbole impliqué dans ce genre de substitution est l’accent grave ( ` )
$ echo pwd
pwd
$ echo `pwd`
/Users/Hicham/Desktop
$ echo "Mon répertoire de travail est: `pwd`"
Mon répertoire de travail est:
/Users/Hicham/Desktop

• Il est possible d’assigner le résultat d’une ligne de commande UNIX à une variable
$ REPERTOIRE=`pwd`
$ JESUIS=`who am i`
$ MACHINE=`hostname`
$ echo -e "Utilisateur: $JESUIS\n Répertoire de travail: $REPERTOIRE\n Machine: $MACHINE"
Utilisateur: Hicham ttys000 Feb 24 22:46
Répertoire de travail: /Users/Hicham/Desktop
Machine: [Link]

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 91

Variables et Opérations
• Neutralisation des caractères
• Certains caractères ont des significations particulières pour l’interpréteur de commandes
• Par exemple : &, (, ), *, !, {, }, etc.
• Sans un mécanisme d’échappement, ces caractères spéciaux seront interprétés par Bash
• Les commandes et programmes qui utilisent ces caractères spéciaux ne pourront pas s’exécuter correctement
• D’où la nécessité de neutraliser la signification particulière de ces caractères spéciaux pour Bash
$ echo TOTO & TATA
[1] 2527
TOTO
-bash: TATA: command not found
Nous désirons afficher la chaîne de
$ echo TOTO \& TATA
caractères "TOTO & TATA"
TOTO & TATA
$ echo "TOTO & TATA"
TOTO & TATA
• Donc, le symbole \permet la neutralisation du caractère qui le suit
• Nous pouvons neutraliser la signification spéciale du caractère Espace par les symboles ” ” et ’ ’
• Le guillemet : élimine la signification spéciale du caractère Espace mais permet la substitution des variables et
commandes
• L’apostrophe : élimine la signification spéciale du caractère Espace et empêche la substitution des variables et
commandes
2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 92
Variables et Opérations
• Saisir une information et la stocker dans une variable
• Pour créer un programme qui soit interactif, vous pouvez demander à l'utilisateur de saisir des
informations et les utiliser par la suite grâce à des variables.
• Pour cela, vous pouvez utiliser la commande read suivie du nom de la variable dans laquelle vous voulez
stocker l'information : echo "Veuillez entrer votre nom :"
read nom
echo "Vous vous appellez $nom"

# Veuillez entrer votre nom :

• Résultat # Dupont
# Vous vous appellez Dupont

• Vous pouvez aussi demander à l'utilisateur d'entrer plusieurs valeurs en une seule fois, par exemple :

read nom, prenom

echo Vous vous appellez $prenom $nom

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 93

Variables et Opérations
Operator Usage
• Opérations arithmétiques + addition
• Syntaxe: var=$((expression)) - subtraction
#!/bin/bash * multiplication
# reading data from the user
read -r -p "Enter a: " a / division
read -r -p "Enter b: " b ** exponentiation
add=$((a+b))
echo "Addition of a and b are: "${add} % modulus
sub=$((a-b))
echo "Subtraction of a and b are: "${sub}
mul=$((a*b))
echo "Multiplication of a and b are: "${mul}
div=$((a/b))
echo "Division of a and b are: "${div}
mod=$((a%b))
echo "Modulis of a and b are: "${mod}
((++a))
echo "Increment operator when applied on $a results into a :" "${a}"
((--b))
echo "Decrement operator when applied on 'b' results into b :" "${b}"

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 94

Variables et Opérations
• Opérateurs bit à bit (Bitwise Operators):
• Bitwise And (&): binary AND operation bit by bit on the operands.
• Bitwise OR (|): binary OR operation bit by bit on the operands.
• Bitwise XOR (^): binary XOR operation bit by bit on the operands.
• Bitwise complement (~): binary NOT operation bit by bit on the operand.
• Left Shift (<<): shifts the bits of the left operand to left by number of times specified by right operand.
• Right Shift (>>): shifts the bits of the left operand to right by number of times specified by right operand.
#!/bin/bash
#reading data from the user
read -p 'Enter a : ' a
read -p 'Enter b : ' b
bitwiseAND=$(( a&b ))
echo Bitwise AND of a and b is $bitwiseAND
bitwiseOR=$(( a|b ))
echo Bitwise OR of a and b is $bitwiseOR
bitwiseXOR=$(( a^b ))
echo Bitwise XOR of a and b is $bitwiseXOR
bitiwiseComplement=$(( ~a ))
echo Bitwise Compliment of a is $bitiwiseComplement
leftshift=$(( a<<1 ))
echo Left Shift of a is $leftshift
rightshift=$(( b>>1 ))
echo Right Shift of b is $rightshift
2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 95
Variables et Opérations
• Opérations de comparaison :

La négation d'une comparaison

se fait avec !
Exemple de négation : Si ce
répertoire n'existe pas on le crée
: if [ ! -d /repert ]; then mkdir
/repert; f

==
!=
<
<=
>
>=
2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 96
Structures de Contrôle
• Tests avec if :
• Pour vérifier qu'une ou plusieurs conditions sont remplies avant d'effectuer un traitement, on utilise souvent le if,
par exemple : if [ $age -ge 18 ]; then if [ $age -ge 18 ] if (( $age >= 18 ))
then then
echo "Vous etes majeur(e) "
echo " Vous etes majeur(e) " echo " Vous etes majeur(
fi
fi fi
• Else, elif
• Le if sert à imposer une condition pour effectuer un traitement. Le else (sinon) permet de complêter le if pour
effectuer un traitement dans le cas ou la condition n'est pas remplie.
• Exemple : if [ $age -ge 18 ]; then
echo " Vous etes majeur(e) "
else
echo " Vous etes mineur(e) "
fi
• Le elif (else if) permet d'imbriquer plusieurs if les uns dans les autres pour pouvoir traiter tous les cas possibles :
if [ $feu = "rouge" ]; then
echo " N'avancez pas "
elif [ $feu = "orange" ]; then
echo " Ralentissez "
else echo " Allez-y "
fi
2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 97
Structures de Contrôle
• Plusieurs conditions :
• Vous pouvez aussi combiner un certain nombre de conditions les unes après les autres, par exemple
pour vérifier que l’age entré par l'utilisateur est situé entre 0 et 100 :
if [ $age -le 0 ] || [ $age -ge 100 ]
then
echo " l'age entré n\'est pas correct "
fi

• Pour combiner plusieurs conditions, vous pouvez utiliser soit OU ( || ), soit ET ( && ). Il s'agit des
opérateurs logiques :
• OU signifie soit l'un, soit l'autre, soit les deux.
• ET signifie l'un et l'autre obligatoirement.

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 98

Structures de Contrôle
• Plusieurs conditions :
#!/bin/bash echo a is not less than b.
#reading data from the user fi
read -p 'Enter a : ' a if(( $a<=$b ))
read -p 'Enter b : ' b then
if(( $a==$b )) echo a is less than or equal to b.
then else
echo a is equal to b. echo a is not less than or equal to b.
else fi
echo a is not equal to b. if(( $a>$b ))
fi then
if(( $a!=$b )) echo a is greater than b.
then else
echo a is not equal to b. echo a is not greater than b.
else fi
echo a is equal to b. if(( $a>=$b ))
fi then
if(( $a<$b )) echo a is greater than or equal to b.
then else
echo a is less than b. echo a is not greater than or equal to b.
else fi

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 99

Structures de Contrôle
#!/bin/bash
• Plusieurs conditions : #reading data from the user
read -p 'Enter a : ' a
read -p 'Enter b : ' b
if(($a == "true" & $b == "true" ))
then
echo Both are true.
else
echo Both are not true.
fi
if(($a == "true" || $b == "true" ))
then
echo Atleast one of them is true.
else
echo None of them is true.
fi
if(( ! $a == "true" ))
then
echo "a" was initially false.
else
echo "a" was initially true.
fi

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 100

 Variables et Opérations
• Plusieurs conditions :
• Opérateurs de test des Fichiers
#!/bin/bash echo The given file has read access.
#reading data from the user else
read -p 'Enter file name : ' FileName echo The given file does not has read access.
if [ -e $FileName ] fi
then if [ -w $FileName ]
echo File Exist then
else echo The given file has write access.
echo File doesnot exist else
fi echo The given file does not has write access.
if [ -s $FileName ] fi
then if [ -x $FileName ]
echo The given file is not empty. then
else echo The given file has execute access.
echo The given file is empty. else
fi echo The given file does not has execute
if [ -r $FileName ] access.
then fi

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 101

Structures de Contrôle
• Case :
• La structure case permet de faire un traitement différent en fonction de la valeur d'une variable, par exemple :

#!/bin/bash
echo Quel est votre OS préféré ?
Echo 1- Windows 2- Linux 3- Mac OS 4- Autre # Quel est votre OS préféré ?
read $choix 2
case "$choix" in Vous préférez Linux
1) echo "Vous préférez Windows" ;;
2) echo "Vous préférez Linux";;
3) echo "Vous préférez Mac OS";;
4) echo "Vous préférez un autre OS";;
else ) echo "Vous devez taper un nombre entre 1 et 4 ! ";;
esac

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 102

Structures de Contrôle
• Select :
• Le select est une extension du case. La liste des choix possibles est faite au début et on utilise le choix de
l'utilisateur pour effectuer un même traitement.
• Exemple :
select systeme in "Windows" "Linux" "BSD" "Mac OS" "MS DOS"
do
echo "Votre système favori est $systeme."
break
done

• Ce qui créera automatiquement un menu et donnera à l'écran :

1) Windows
2) Linux
3) BSD
4) Mac OS
5) MS DOS
#? 4
Votre système favori est Mac OS

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 103

Boucles
• Les boucles servent en général à refaire le même traitement plusieurs fois. On peut les
utiliser pour:
• Vérifier qu'une information saisie par l'utilisateur est correcte et lui faire recommencer la saisie tant que
ce n'est pas correct
• Recommencer un certain nombre de fois la même suite de commandes
• D’autre part elles fonctionnent toujours avec ces trois critères :
• Une valeur de départ
• Une condition d'entrée ou de sortie
• Une incrémentation
• Les boucles While et Until testent une condition avant d'effectuer le traitement, ce qui
veut dire qu'il se peut qu'on n'entre jamais dans la boucle.

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 104

Boucles
• La boucle while : tant que …
• While signifie tant que, ce qui veut dire que la boucle sera exécutée tant que la condition est respectée.
• Exemples :

i=1 # Valeur de départ 1 continuer=o # Nouvelle valeur de continuer

while [ $i -le 5 ]; do # Condition de sortie : i > 5 while [ $continuer = «o» ]; do # condition de sortie : pas o
echo "tour de boucle num $i" echo Voulez-vous recommencer ? o/n
# Incrément de 1 par tour de boucle read continuer
((i+=1)) # Nouvelle valeur de continuer (qui remplace l'incrément)
done done
# Cette boucle continue tant que l'utilisateur entre o

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 105

Boucles
• La boucle until : jusqu'à …
• Until signifie jusqu'à, ce qui veut dire que la boucle sera exécutée jusqu'à ce que la condition soit
respectée.
• Exemples :
i=1 # Valeur de départ 1
until [ $i -gt 5 ]; do # Condition de sortie : i > 5
echo tour de boucle n° $i
i = `expr i «+» 1` # Incrément de 1 par tour de boucle
done
continuer=o # Valeur de départ «o»
until [ $continuer = «n» ]; do # condition de sortie : n
echo Voulez-vous recommencer ? o/n
read continuer # Nouvelle valeur de continuer
done # (qui remplace l'incrément)
# Cette boucle continue jusqu'à ce que l'utilisateur entre n
2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 106
Boucles
• La boucle for :
• A priori, la boucle for est utilisée quand on veut exécuter un ensemble de commandes un nombre précis
de fois.
• Exemple : La commande seq sert à afficher une liste de nombre :
seq 3: affichera à l'écran 1 2 3
echo Combien voulez-vous d\'étoiles ? seq 3 5: affichera à l'écran 3 4 5
read nombre seq 1 2 7: affichera à l'écran 1 3 5 7
for i in `seq $nombre`
do
echo -n \* Combien voulez-vous d'étoiles ?
done 4
****

• En shell la boucle for est beaucoup utilisée pour traiter les fichiers, par exemple :
echo Ce script va renommer tous les fichiers en y ajoutant votre nom
for fichier in `ls`
do
if [ ! -d $fichier ]; then
fichierdest=$USER-$fichier
mv $fichier $fichierdest
fi
done
2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 107
Fonctions
• Passage de paramètres
• En général pour utiliser une commande, on l'appelle par son nom, suivi d'un certain nombre de paramètres, par
exemple pour déplacer un fichier :
• mv fichier répertoire/
• Commande paramètre 1 paramètre 2
• L'avantage d'utiliser des paramètres est que lorsqu'on lance le programme, on n'a pas à faire intervenir l'utilisateur,
donc le script peut s'exécuter sans que personne ne tape quoi que ce soit au clavier.
• Pour passer un paramètre à votre programme, il vous faut faire comme avec n'importe quelle commande :
nom_de_votre_script paramètre1 paramètre2
• Quand un utilisateur appelle votre programme en y ajoutant des paramètres, vous devez les récupérer dans des
variables. Pour cela il existe des variables spéciales :
• $1 à $9 :contienne le Xième paramètre passé
• $* : contient tous les paramètres qui ont été passés
• $# : contient ne nombre de paramètres qui ont été passés
• $0 : contient le nom du script lui-même
• $$ :contient le numéro de processus du shell lui-même

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 108

Fonctions
• Passage de paramètres
• Exemple de script utilisant des paramètres :
#!/bin/sh
echo "Vous avez passé les $# paramètres suivant :"
echo " paramètre 1 : $1 "
echo " paramètre 2 : $2 "
echo " paramètre 3 : $3 "
echo " paramètre 4 : $4 "
echo "On peut aussi les afficher tous d\'un coup : $*"

• En appelant ce programme comme ceci: # mon_script 10 abc toto 91

• On obtient :
Vous avez passé les 4 paramètres suivant :
paramètre 1 : 10
paramètre 2 : abc
paramètre 3 : toto
paramètre 4 : 91
On peut aussi les afficher tous d'un coup : 10 abc toto 91

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 109

Fonctions
• Fonctions
• Comme pour les autres langages de programmation,
les scripts Bash peuvent faire appel à des fonctions.
• La déclaration de fonction se fait comme suit :

function nom () {
#!/bin/sh
commandes ;
# Déclaration de la fonction :
} function multiplier() {
resultat=`expr $1 "*" $2` echo $resultat
• L'appel d'une fonction se fait en écrivant son nom. On }
peut lui passer des paramètres comme on le fait pour echo Veuillez entrer deux nombres
une commande. read nb1
• Attention on ne peut appeler une fonction que si elle read nb2
a été déclarée avant ! # Appel de la fonction :
multiplier $nb1 $nb2
• Exemple de fonction et de son appel :

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 110

Tableaux
• Dans le langage de programmation C, un tableau est une variable permettant de stocker uniquement le
même type de données.
• Alors que dans le script bash, un tableau est une variable permettant de contenir plusieurs valeurs du même
type ou de différents types de données.
• Toute variable peut être utilisée comme un tableau.
• Il n'y a pas de limite maximale à la taille d'un tableau.
• Il n'est pas obligatoire que les variables de tableau soient indexées ou assignées de manière contiguë ou
consécutive.
• Le concept de tableau n'était pas supporté par le Bourne Shell original, mais les versions plus récentes de
bash et d'autres shells plus récents supportent le concept de tableau.
• Elles prennent en charge les tableaux unidimensionnels.
• Par défaut, dans le script shell, tout est traité comme une chaîne de caractères.

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 111

Tableaux
• Déclarer un tableau
• Il existe de nombreuses façons de déclarer un tableau dans un script shell, qui sont décrites ci-dessous :
• Déclaration indirecte
• Le tableau est déclaré à l'aide de la syntaxe suivante : NOMTAB[INDICE]=valeur
• où INDICE est une valeur numérique qui doit être un nombre positif.
• Il n'est pas nécessaire de déclarer le tableau en premier.
• Par exemple:
Etudiant[1]= 20
Etudiant[3]= "Mostafa"
Etudiant[4]= "Meknes"
Etudiant[5]=17.5

• Déclaration explicite
• Dans une déclaration explicite d'un tableau, nous utilisons la commande intégrée declare : declare -a NOMTAB
• Tout d'abord, déclarez le tableau, puis attribuez les valeurs.

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 112

Tableaux
• Déclarer un tableau
• Déclaration classique
• Une variable de tableau peut également être créée en utilisant l'affectation composée.
• Il est utile de déclarer un tableau avec un groupe de valeurs : NOMTAB=(val val2 .... valN)
• Vous pouvez également ajouter d'autres valeurs plus tard
• L'indice est facultatif: s'il est donné, il est assigné comme un indice, sinon, l'indice de l'élément assigné est le
numéro du dernier indice qui a été assigné, plus un.
• Si aucun numéro d'indice n'est défini, l'indexation commence à 0.
• Par exemple, un tableau entier peut être déclaré en mettant les valeurs du tableau entre parenthèses:
Villes=(Meknes Paris Lille Marrakech Rabat)

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 113

Tableaux
• Afficher les éléments d’un tableau
• Pour afficher les valeurs d'un tableau: echo ${NOMTAB[INDICE]}
• Pour faire référence au contenu d'un élément dans un tableau, utilisez des accolades.
• Si le numéro d'indice d'un tableau est @ ou *, tous les éléments d'un tableau sont référencés ou pris en
compte.
• Exemple:
#!/bin/bash
Villes=(Meknes Paris Lille Marrakech Rabat)
devinfo@ubuntu:~/scripts$ [Link]
echo "Tous les éléments ${Villes[*]} "
Tous les éléments Meknes Paris Lille Marrakech Rabat
echo "Le premier élément : ${Villes[0]} "
Le premier élément : Meknes
echo "Le premier élément : ${Villes} "
Le premier élément : Meknes
# ajouter un élément
Tous les éléments Meknes Paris Lille Marrakech Rabat Lyon
Villes[5]=Lyon
echo "Tous les éléments ${Villes[@]} "

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 114

Tableaux
• Supprimer des éléments du tableau
• Pour supprimer un élément du tableau ou supprimer un tableau, utilisez la commande intégrée unset
avec le nom du tableau et le numéro d'indice de l'élément ou sa clé.
• Exemple:

#!/bin/bash
Villes=(Meknes Paris Lille Marrakech Rabat)
echo "Tous les éléments : ${Villes[*]} " devinfo@ubuntu:~/scripts$ [Link]
unset Villes[3] Tous les éléments : Meknes Paris Lille Marrakech Rabat
echo "Tous les éléments : ${Villes[*]} " Tous les éléments : Meknes Paris Lille Rabat
unset Villes[*] Tous les éléments :
echo "Tous les éléments : ${Villes[*]} "

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 115

Automatisation
• Automatiser l’installation et les mises à jour
• Les commandes pour mettre à jour un système peuvent être regroupées.
• Par exemple, exécuter sudo apt update suivi de sudo apt upgrade -y en une seule commande.
• Cela permet de réduire les tâches manuelles lors des mises à jour.
• Utilisation de Nano ou Vim pour écrire le script
• Sécuriser le fichier avec la commande chmod
• Lancer le script avec commandes adéquates
• Conserver une copie de sauvegarde dans un dossier accessible

Commande Description Exemple Résultat

sudo apt update Mise à jour de la liste des paquets sudo apt update Liste actualisée
sudo apt upgrade -y Mise à niveau automatique sudo apt upgrade -y Paquets mis à jour
chmod +x Rendre le script exécutable chmod +x monscript Exécution possible
mv Déplacer le script dans un dossier mv monscript /usr/bin/ Accessible globalement

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 116

Automatisation
• Scripts pour tâches réseau
• Les scripts peuvent également surveiller la connectivité.
• Par exemple, exécuter un ping en arrière-plan aide à détecter des anomalies.
• L’approche permet de vérifier la performance réseau en temps réel.
• Commande ping pour vérifier la connexion
• Utilisation de boucles pour surveiller en continu
• Gestion des erreurs via le code de retour
• Sortie des messages de statut sur le terminal

Script Commande Usage Vérification

Ping continu ping [Link] Test de réseau Statut en temps réel
Mise à jour sudo apt upgrade -y Gestion des paquets Résultat de mise à jour
Vérification disque df -h Espace disque Utilisation affichée
Changement permissions chmod +x script Exécution script Droit modifié

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 117

Automatisation
• Automatisation de la gestion des utilisateurs
• Créer des utilisateurs sur plusieurs machines est simplifié par un script.
• Ce script lit un fichier contenant des noms d’hôte et utilise SSH pour ajouter un utilisateur.
• La tâche est ainsi déléguée à une série de commandes précises.
• Lecture d’un fichier avec les serveurs
• Utilisation de SSH pour la connexion
• Exécution de la commande useradd
• Vérification du code de retour pour confirmer l’ajout

Fichier Fonction Commande Action

[Link] Liste des serveurs cat [Link] Lecture
[Link] Script d’ajout sudo useradd -m Exécution
SSH Connexion distante ssh server Vérification
Retour code État de commande if [ $? -eq 0 ] Validation

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 118

Automatisation
• Automatisation des sauvegardes
• Les sauvegardes s’exécutent régulièrement pour éviter tout incident. Un script regroupe plusieurs
répertoires et envoie les archives vers un serveur distant.
• Le processus diminue le risque de perte de données.
• Création d’un tableau des répertoires à sauvegarder
• Utilisation de tar pour compresser les fichiers
• Transfert des archives via scp
• Nettoyage des fichiers temporaires en fin de tâche

Variable Valeur Commande Action

backup_dirs /etc, /home, /boot tar -Pczf Compression
dest_dir /backup scp Transfert
dest_server server1 scp Destination
backup_date Date du backup date +%b-%d-%y Horodatage

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 119

Automatisation
• Surveillance de l’espace disque
• L’utilisation de commandes comme df -h permet d’afficher l’espace libre.
• Le script extrait le pourcentage d’utilisation et envoie un avertissement par mail si le seuil est atteint.
• Cette méthode protège contre une saturation du disque.
• Analyse de l’espace disque via df
• Extraction du pourcentage avec awk
• Envoi d’email d’alerte en cas de dépassement
• Exécution planifiée pour vérification régulière

Système de fichiers Taille Utilisation Action

/ 20G 44% Aucune
/apps 4.9G 52% Surveillance
/database 4.9G 97% Alerte email
Backup Variable N/A Vérification régulière

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 120

Automatisation
• Planification via cron
• Planifier l’exécution continue des scripts se fait avec cron.
• Le démon crond agit comme un service en arrière-plan pour l’exécution des jobs planifiés.
• Crontab sert de fichier de configuration où sont stockées les instructions.
• Cron Job représente une tâche spécifique à effectuer. Elle est décrite dans une ligne, associée à l’heure à
laquelle elle doit être effectuée
• Une tâche programmée à intervalle régulier permet de surveiller l’état système sans intervention
constante.
• Chaque tâche crontab se compose d’une ligne et est formatée comme suit :
• crontab [options]

• * * * * * <commande>
• OU
• * * * * * <chemin/du/script>
1er 2eme 3eme 4eme 5eme
* * * * *
Nom du
ID Minute Heure Jour/Date Mois
Jour
Valeur 0-59 0 -23 1-31 1-12 0-6
2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 121
Automatisation
• Planification via cron
• Les tâches programmées garantissent un suivi automatisé.
• Lancement automatique des scripts
• Utilisation de la commande cron pour la planification
• Exécution à intervalle (toutes les 6 heures par exemple)
• Administration sans surveillance continue

Heure Tâche Chemin du script Fréquence

00*** Sauvegardes /home/user/[Link] Chaque jour
0 */6 * * * Surveillance disque /home/user/disk_space.sh Toutes les 6 heures
***** Vérification réseau /home/user/network_check.sh Chaque minute
30 2 * * * Mises à jour /home/user/[Link] Quotidien

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 122

Automatisation
• Planification via cron
• Pour modifier l’entrée crontab d’un utilisateur, on utilise l’option -e : crontab –e
• À la première utilisation, on demande l’diteur de texte préféré.
• Nano est suggéré comme le programme le plus facile à utiliser.
• On peut utiliser n’importe quel éditeur de texte en ligne de commande comme Vim ou Emacs.
• Il est aussi possible de forcer l’éditeur de crontab en modifiant la variable EDITOR ou VISUAL avec la
commande export : export EDITOR=vi

crontab -e pas de crontab pour xxx - utilisation d'une crontab vide

Sélectionnez un éditeur. Pour changer plus tard, exécutez 'select-editor’.
1. /bin/nano <---- le plus simple
2. 2. /usr/bin/code
3. 3. /bin/ed
Choisissez 1-3 [1] : 1

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 123

Automatisation
• Planification via cron
• Exécuter un script automatiquement avec crontab
• crontab vous permet d’exécuter n’importe quoi, une commande, un script.
• Il y a tout de même quelques règles à respecter :
• L’utilisateur doit avoir la permission d’exécution que vous pouvez donner à l’aide de la commande chmod +x
• Dans crontab, spécifiez le chemin complet du script
• Par exemple pour exécuter un script de sauvegarde :
• 0 3 * * * ~/scripts/backup_script.sh
• Par défaut, crontab utilise le shell /bin/sh dont la configuration se trouve dans /etc/crontab.
• Si nécessaire, vous pouvez forcer le shell Linux. Par exemple pour forcer l’exécution du script en bash :
• 0 3 * * * bash ~/scripts/backup_script.sh
• Par exemple pour exécuter un script PHP de vérification de sites :
• */5 * * * * /usr/bin/php /home/malekalmorte/script/check_sites.php > /dev/null 2>&1

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 124

Automatisation
• Planification via cron
• Il est aussi possible de lister les tâches et supprimer du fichier Crontab
• Lister tous les travaux actuellement actifs dans votre fichier crontab à l’aide de la commande : crontab -l
• Supprimer toutes les tâches de la crontab et vider le contenu de votre fichier crontab à l’aide de la commande:
crontab -r
• Modifier ou lister le cron d’un utilisateur avec le paramètre -u :
• crontab -u malekalmorte -l
• crontab -u malekalmorte –e
• Le système d’exploitation stocke le cron utilisateur dans /var/spool/cron/crontabs/.
• On trouve un dossier pour chaque utilisateur Linux.

2025-2026 Asmae EL KASSIRI - Environnement Unix/Linux 125