Boucles Bash : for, while, until

Les boucles Bash permettent de répéter une action sur chaque élément d’un ensemble. Avec for, vous itérez sur une liste connue — serveurs, fichiers, éléments d’un tableau. Avec while, vous traitez un flux dont la taille n’est pas connue à l’avance — chaque ligne d’un fichier de configuration, chaque entrée d’un find. Ce sont les deux outils les plus utilisés dans les scripts d’administration Linux.

Ce que vous allez apprendre

• Écrire une boucle for sur une liste, un tableau, des globs de fichiers et des plages numériques
• Utiliser while IFS= read -r pour lire un fichier ligne par ligne sans perdre les espaces
• Lire la sortie d’une commande dans une boucle while
• Contrôler l’exécution avec break et continue
• Choisir entre for, while et until en fonction du contexte

Dans quel contexte ?

Les boucles interviennent dès qu’une action doit être répétée sur plusieurs éléments :

• vérifier le statut de dix services et afficher ceux qui sont arrêtés
• renommer en lot tous les fichiers .log d’un répertoire en .log.bak
• lire /etc/passwd ligne par ligne pour extraire les utilisateurs avec un UID supérieur à 1000
• attendre qu’un port soit ouvert avant de continuer un déploiement
• appliquer un patch à une liste de serveurs passée en arguments

En préparation RHCSA, l’itération sur une liste (for) et la lecture de fichier (while read) sont testées dans les exercices de scripting.

for — itérer sur une liste

Liste littérale

for serveur in web01 web02 db01; do
    echo "Traitement de $serveur"
done
# Traitement de web01
# Traitement de web02
# Traitement de db01

Tableau

services=("nginx" "postgresql" "redis" "sshd")
for svc in "${services[@]}"; do
    echo "Service : $svc"
done
# Service : nginx
# Service : postgresql
# Service : redis
# Service : sshd

Attention

Toujours citer "${tableau[@]}" avec les guillemets doubles — sans eux, les éléments contenant des espaces seraient découpés.

Glob de fichiers

for f in /etc/*.conf itère sur les fichiers correspondant au pattern :

count=0
for f in /etc/*.conf; do
    [[ -f "$f" ]] || continue       # ignorer les entrées qui ne sont pas des fichiers
    echo "$f ($(wc -l < "$f") lignes)"
    count=$((count + 1))
    (( count >= 5 )) && break
done
#     /etc/adduser.conf (109 lignes)
#     /etc/ca-certificates.conf (157 lignes)
#     /etc/debconf.conf (83 lignes)
#     /etc/deluser.conf (41 lignes)
#     /etc/dhcpcd.conf (48 lignes)

Astuce

Si le glob ne correspond à aucun fichier, Bash passe la chaîne littérale *.conf à la boucle. Testez avec [[ -f "$f" ]] || continue pour ne traiter que les vrais fichiers.

Plage numérique avec {debut..fin} et {debut..fin..pas}

for i in {1..5}; do
    printf "%d " "$i"
done
# 1 2 3 4 5

for i in {0..20..5}; do    # pas de 5
    printf "%d " "$i"
done
# 0 5 10 15 20

Style C — for (( init; condition; incrément ))

Utile pour les index ou compteurs avec logique arithmétique :

for (( i=1; i<=5; i++ )); do
    printf "%d " "$i"
done
# 1 2 3 4 5

# Compter à rebours
for (( i=10; i>=1; i-- )); do
    printf "%d " "$i"
done
# 10 9 8 7 6 5 4 3 2 1

Sortie de commande avec substitution

for ip in $(cat /etc/hosts | awk '{print $1}' | grep -v '^#'); do
    echo "Hôte : $ip"
done

Attention

for ligne in $(cat fichier) découpe sur tous les espaces, pas seulement les sauts de ligne. Pour traiter des lignes entières, utilisez while IFS= read -r (voir ci-dessous).

while — répéter tant qu’une condition est vraie

Compteur

compteur=1
while (( compteur <= 3 )); do
    echo "Itération $compteur"
    compteur=$((compteur + 1))
done
# Itération 1
# Itération 2
# Itération 3

Lire un fichier ligne par ligne

C’est le patron canonique pour traiter un fichier texte sans perdre les espaces en début de ligne ni les backslashes :

while IFS= read -r ligne; do
    echo "→ $ligne"
done < fichier.txt
# → nginx
# → postgresql
# → redis

Décomposition :

• IFS= — désactive la séparation par espaces/tabulations pendant read
• read -r — préserve les backslashes tels quels
• < fichier.txt — redirige le fichier vers l’entrée standard de la boucle

Lire la sortie d’une commande

count=0
while IFS=: read -r user _ uid _; do
    (( uid < 100 )) || continue
    echo "$user (uid=$uid)"
    count=$((count + 1))
    (( count >= 3 )) && break
done < /etc/passwd
# root (uid=0)
# daemon (uid=1)
# bin (uid=2)

IFS=: indique que les champs sont séparés par : (format de /etc/passwd). _ est une variable muette pour ignorer les champs non utiles.

Avec substitution de processus (pour une commande au lieu d’un fichier) :

while IFS= read -r ligne; do
    echo "→ $ligne"
done < <(find /var/log -name "*.log" -newer /etc/passwd)

< <(commande) équivaut à rediriger la sortie de commande dans la boucle, sans créer de sous-shell pour la boucle elle-même — ce qui permet de modifier des variables à l’intérieur.

Astuce

Évitez commande | while read — le pipe crée un sous-shell, les variables modifiées dans la boucle ne persistent pas après.

until — répéter jusqu’à ce qu’une condition soit vraie

until est l’inverse de while : la boucle continue tant que la condition est fausse :

n=3
until (( n <= 0 )); do
    echo "Compte à rebours : $n"
    n=$((n - 1))
done
# Compte à rebours : 3
# Compte à rebours : 2
# Compte à rebours : 1

Cas d’usage typique : attendre qu’un service soit disponible.

until nc -z localhost 5432 2>/dev/null; do
    echo "PostgreSQL pas encore prêt, nouvelle tentative dans 2s..."
    sleep 2
done
echo "PostgreSQL disponible."

break et continue

• break : sort de la boucle immédiatement
• continue : passe à l’itération suivante sans exécuter le reste du corps

for i in {1..10}; do
    (( i % 2 != 0 )) && continue   # ignorer les impairs
    (( i > 8 )) && break            # s'arrêter à 8
    printf "%d " "$i"
done
echo ""
# 2 4 6 8

break N et continue N permettent de sortir ou passer à l’itération d’une boucle externe imbriquée (N = niveau) :

for hote in web01 web02; do
    for port in 80 443 8080; do
        nc -z "$hote" "$port" 2>/dev/null && continue 2   # port ouvert : passer à l'hôte suivant
        echo "$hote:$port FERMÉ"
    done
done

Choisir la bonne boucle

Situation	Boucle recommandée
Liste connue (serveurs, fichiers, arguments)	for item in liste
Plage numérique ou compteur simple	for i in {1..N} ou for ((i=0; ...))
Taille inconnue — lire fichier ou commande	while IFS= read -r
Attendre une condition externe	until condition
Condition dépend d’un compteur modifiable	while (( compteur < MAX ))

Glissez pour voir

Dépannage

Symptôme	Cause probable	Solution
Variables modifiées dans le while perdues après	Boucle dans un sous-shell via pipe	Utiliser while ... done < <(cmd) au lieu de cmd | while
Glob *.conf passe la chaîne littérale	Aucun fichier ne correspond	Vérifer avec [[ -f "$f" ]] || continue
{1..N} avec variable : {1..$n} ne s’expande pas	Les accolades s’expandent avant les variables	Utiliser seq "$n" ou for (( i=1; i<=n; i++ ))
for ligne in $(cat fichier) découpe sur les espaces	Word splitting actif	Utiliser while IFS= read -r ligne; do ... done < fichier
break dans un sous-shell ne sort pas de la boucle principale	Boucle + sous-shell = contextes séparés	Éviter les sous-shells dans les boucles critiques

Glissez pour voir

À retenir

• for item in "${tableau[@]}" est la forme sûre pour itérer sur un tableau — avec guillemets doubles.
• while IFS= read -r ligne; do ... done < fichier est le patron canonique pour lire un fichier ligne par ligne.
• Évitez cmd | while read — le pipe crée un sous-shell, les variables sont perdues après la boucle.
• break sort de la boucle, continue passe à l’itération suivante — suffixez d’un entier pour les boucles imbriquées.
• {1..N} ne s’expande pas avec des variables — utilisez seq ou for (( )).

Prochaines étapes

Fonctions Bash Déclarer, appeler, passer des arguments et retourner des valeurs depuis une fonction.

Conditions et tests Bash if/elif/else, [[ ]] et tests de fichiers, chaînes et nombres.

Scripts Bash robustes set -euo pipefail, trap, mktemp — scripts de production.

×

📖 Voir la documentation →