Bash : variables, conditions et boucles

Un script Bash est une suite de commandes Linux enrichie de variables, de tests (if, case) et de boucles (for, while) : le shell remplace les variables par leur texte, lance chaque commande et regarde son code de retour pour savoir si elle a réussi. Ce chapitre présente ces briques, les redirections qui relient les commandes entre elles, et la règle qui évite la moitié des bugs Bash : mettre les variables entre guillemets.

Les variables

serveur="srv-web"          # pas d'espace autour du =
seuil=15
aujourdhui=$(date +%F)     # la sortie d'une commande : 2026-11-03
echo "Contrôle de $serveur le $aujourdhui"

En Bash, tout est du texte : seuil=15 range les deux caractères 1 et 5. Les calculs se font dans $(( )), qui ne connaît que les entiers :

echo $(( 17 / 5 ))    # 3 : division entière
echo $(( 17 % 5 ))    # 2 : reste
echo $(( 2 ** 10 ))   # 1024 : puissance
x="5"; y=3
echo $(( x + y ))     # 8 : dans $(( )), les variables n'ont pas besoin de $
echo "$x$y"           # 53 : hors calcul, c'est du texte collé

Par convention, les variables d'environnement et les constantes sont en MAJUSCULES (PATH, HOME, RETENTION_JOURS), les variables du script en minuscules. export NOM=valeur rend une variable visible des programmes lancés par le script ; readonly interdit de la modifier ensuite.

Les guillemets, la règle d'or

Ce découpage est la source de bugs la plus fréquente :

f="rapport final.txt"
touch "$f"
ls $f      # Bash comprend : ls rapport final.txt (deux fichiers)
ls "$f"    # Bash comprend : ls "rapport final.txt"

ls: impossible d'accéder à 'rapport': Aucun fichier ou dossier de ce nom
ls: impossible d'accéder à 'final.txt': Aucun fichier ou dossier de ce nom
rapport final.txt

Avec rm $f, la même erreur pourrait supprimer deux autres fichiers. D'où la règle : mets toujours tes variables entre guillemets doubles, "$f", sauf si tu veux précisément le découpage. L'outil ShellCheck signale chaque oubli (avertissement SC2086).

Les accolades délimitent le nom de la variable et donnent accès à des transformations utiles, sans appeler de programme externe :

Les paramètres du script

Un script reçoit des arguments au lancement : ./verif.sh srv-web 15.

Écris toujours "$@" avec ses guillemets pour transmettre les arguments : avec ./copie.sh "rapport final.txt" srv-web, "$@" donne deux arguments, rapport final.txt et srv-web, alors que $@ sans guillemets en donne trois. Le chapitre 6 montre comment traiter des options comme -j 30 avec getopts.

Code de retour, redirections et pipes

Chaque commande Linux se termine par un code de retour (exit status) : 0 si tout s'est bien passé, un nombre de 1 à 255 sinon. C'est sur ce code, et non sur ce qui s'affiche, que Bash prend ses décisions. $? le contient juste après la commande.

grep -q '^root:' /etc/passwd
echo $?        # 0 : trouvé
grep -q '^zorro:' /etc/passwd
echo $?        # 1 : pas trouvé

&& lance la commande suivante seulement si la précédente a réussi, || seulement si elle a échoué :

mkdir -p /srv/sauvegardes && echo "Dossier prêt"
ping -c 1 -W 2 srv-journaux > /dev/null || echo "srv-journaux ne répond pas"

Chaque programme dispose de trois canaux : l'entrée standard (0, le clavier par défaut), la sortie standard (1, l'écran) et la sortie d'erreur (2, l'écran aussi). Les redirections les branchent ailleurs.

Le document en ligne (here-document) envoie plusieurs lignes à l'entrée standard d'une commande, pratique pour écrire un fichier de configuration depuis un script :

cat > /etc/motd <<EOF
Serveur $(hostname) - Sorbier Logistique
Accès réservé au service informatique. Toute connexion est journalisée.
EOF

Avec <<'EOF' (le mot entre apostrophes), rien n'est remplacé à l'intérieur : $(hostname) resterait tel quel.

Les tests : [[ ]] et (( ))

if exécute une commande et regarde son code de retour. La commande la plus utilisée est le test [[ … ]], propre à Bash, qui répond 0 (vrai) ou 1 (faux).

Pour comparer des nombres, l'arithmétique (( … )) est plus lisible : (( libre < 10 )). Attention, dans [[ ]], les signes < et > comparent des chaînes dans l'ordre alphabétique : [[ 10 > 9 ]] est faux, car le caractère 1 vient avant 9. Avec des nombres, utilise -gt ou (( )).

Tu croiseras aussi l'ancienne forme [ … ] (la commande test), seule comprise par sh et dash. Elle exige des guillemets partout et n'accepte ni && ni =~ à l'intérieur : dans un script Bash, préfère [[ ]].

if et case

libre=12
if (( libre < 10 )); then
    echo "CRITIQUE : ${libre} Go libres"
elif (( libre < 15 )); then
    echo "ATTENTION : ${libre} Go libres"
else
    echo "OK : ${libre} Go libres"
fi

ATTENTION : 12 Go libres

if peut tester directement n'importe quelle commande : if grep -q "^$login:" /etc/passwd; then …, if ping -c 1 -W 2 "$hote" > /dev/null; then …. Pas besoin de $? : c'est le code de retour qui est testé.

case compare une valeur à des motifs, comme switch -Wildcard en PowerShell, mais s'arrête au premier motif qui correspond :

case "$1" in
    srv-ad*)  echo "contrôleur de domaine" ;;
    srv-*)    echo "serveur membre" ;;
    -h|--aide) echo "usage : $0 nom-du-serveur" ;;
    *)        echo "nom inconnu : $1" ; exit 1 ;;
esac

Les boucles

for … in parcourt une liste de mots, un tableau ou des fichiers :

for s in srv-web srv-journaux; do
    echo "Contrôle de $s"
done

for f in /var/log/nginx/*.log; do       # les jokers sont développés en noms de fichiers
    echo "$f : $(wc -l < "$f") lignes"
done

for ((i = 1; i <= 3; i++)); do          # forme avec compteur
    printf 'ENT-%03d\n' "$i"
done

ENT-001
ENT-002
ENT-003

printf est plus fiable qu'echo pour mettre en forme : %s pour une chaîne, %d pour un entier, %03d pour un entier sur trois chiffres complété par des zéros, \n pour aller à la ligne.

while read lit un fichier ligne par ligne. C'est la boucle de base pour traiter une liste :

while IFS= read -r serveur; do
    [[ -z "$serveur" || "$serveur" == \#* ]] && continue   # sauter lignes vides et commentaires
    echo "Traitement de $serveur"
done < serveurs.txt

IFS= garde les espaces en début et en fin de ligne, -r empêche read d'interpréter les barres obliques inverses. Le fichier est donné à la boucle par < serveurs.txt après done. until répète jusqu'à ce qu'une condition devienne vraie ; break et continue fonctionnent comme en PowerShell.

Les tableaux

serveurs=(srv-web srv-journaux srv-ad)
echo "${serveurs[0]}"        # srv-web
echo "${#serveurs[@]}"       # 3 : le nombre d'éléments
serveurs+=(srv-ad2)          # ajouter un élément
for s in "${serveurs[@]}"; do echo "- $s"; done

Bash 4 et suivants ont aussi des tableaux associatifs, l'équivalent des tables de hachage, à déclarer avec declare -A :

declare -A passerelle=([POSTES]=192.168.10.126 [SERVEURS]=192.168.10.190 [ADMIN]=192.168.10.222)
echo "${passerelle[SERVEURS]}"    # 192.168.10.190
for vlan in "${!passerelle[@]}"; do echo "$vlan -> ${passerelle[$vlan]}"; done

"${!passerelle[@]}" donne les clés, dans un ordre qui n'est pas garanti. macOS fournit encore Bash 3.2, sans tableaux associatifs : un script qui en utilise ne tourne que sur un Linux récent.

Demander une valeur

read -rp "Nom du serveur : " serveur
read -rsp "Mot de passe : " mdp; echo     # -s : la saisie ne s'affiche pas

Comme en PowerShell, un script d'administration évite les questions et prend des arguments : il pourra tourner seul, dans cron.

Exercices

#!/usr/bin/env bash
a=7
b="3"
echo "$a$b"
echo $(( a * b ))
echo '$a vaut' "$a"
chemin="/etc/nginx/sites-available/suivi.conf"
echo "${chemin##*/}"
echo "${chemin%/*}"
echo "${chemin##*.}"
[[ 10 -gt 9 ]] && echo "nombres : oui"
[[ 10 > 9 ]] && echo "texte : oui" || echo "texte : non"

73
21
$a vaut 7
suivi.conf
/etc/nginx/sites-available
conf
nombres : oui
texte : non

#!/usr/bin/env bash
# verif-disque.sh POINT_DE_MONTAGE SEUIL_POURCENT
if [[ $# -ne 2 ]]; then
    echo "usage : $0 point_de_montage seuil_pourcent" >&2
    exit 2
fi
point="$1"
seuil="$2"
if [[ ! -d "$point" ]]; then
    echo "erreur : $point n'est pas un dossier" >&2
    exit 2
fi
if [[ ! $seuil =~ ^[0-9]+$ ]]; then
    echo "erreur : le seuil doit être un entier, reçu « $seuil »" >&2
    exit 2
fi

for f in $(ls /srv/partage); do
    mv /srv/partage/$f /srv/archives/
done

for f in /srv/partage/*; do
    mv -- "$f" /srv/archives/
done

# serveurs Linux de Sorbier
srv-web

srv-journaux
# fin

n=0
while IFS= read -r s; do
    [[ -z "$s" || "$s" == \#* ]] && continue
    echo "serveur : $s"
    n=$((n + 1))
done < serveurs.txt
echo "$n serveur(s)"

serveur : srv-web
serveur : srv-journaux
2 serveur(s)