La boucle for est la première des 3 structures de boucles du Shell. Cette boucle autorise la spécification d'une liste de valeurs. Une liste de commandes est exécutée pour chaque valeur de la liste.

La syntaxe de cette boucle est:

Si [in LIST] est absent, il est remplacé par in $@ et for exécute les COMMANDES une fois pour chaque paramètre positionnel déclaré (voir Section 2.5, « Paramètres Spéciaux » et Section 2.1.2, « Contrôle des paramètres de la ligne de commande »).

Le statut retourné est le statut d'exécution de la dernière commande exécutée. Si aucune commande n'est exécutée parce que LIST ne résulte en aucun élément, le code retour est zéro.

NOM peut être tout nom de variable, même si i est employé très souvent. LIST peut être toute liste de mots, chaînes ou nombres qui peuvent être des littéraux ou générés par toute commande. Les COMMANDES à exécuter peuvent être aussi toute commande système, script, programme ou instruction Shell. Au premier passage dans la boucle, NOM est valorisé à la valeur du premier élément dans LIST. Au deuxième passage, sa valeur est donnée par le second élément dans la liste, et ainsi de suite. La boucle termine quand NOM a pris une fois la valeur de chaque élément de LIST et qu'il ne reste plus d'éléments dans LIST.

La structure while permet une exécution répétitive d'une liste de commandes tant que la commande qui contrôle le while s'exécute avec succès (code retour égal à zéro). La syntaxe est:

CONTROL-COMMAND peut être toute commande(s) qui peut s'achever avec un statut de succès ou d'échec. Le CONSEQUENT-COMMANDS peut être tout programme, script ou bloc Shell.

Dès que CONTROL-COMMAND échoue, la boucle est arrêtée. Dans un script, la commande suivant l'instruction done est exécutée.

Le statut retourné est le statut d'exécution de la dernière commande de CONSEQUENT-COMMANDS ou zéro si aucune n'est exécutée

La boucle until est très similaire à while, à part que elle s'exécute jusqu'à ce que TEST-COMMAND s'exécute avec succès. Tant que cette commande échoue, la boucle se poursuit. La syntaxe est la même que pour la boucle while:

Le statut retourné est le statut d'exécution de la dernière commande exécutée dans la liste CONSEQUENT-COMMANDS ou zéro si aucune n'est exécutée. TEST-COMMAND peut être toute commande qui peut s'achever avec un statut de succès ou d'échec, et CONSEQUENT-COMMANDS peut être toute commande UNIX, script ou bloc Shell.

Comme nous l'avons déjà expliqué auparavant; le « ; » peut être remplacé par un ou plus sauts de lignes quelque soit l'endroit où il apparaît.

Script amélioré de picturesort.sh (voir Section 2.2.2, « Des boucles while imbriquées »), qui teste l'espace disque disponible. Si pas assez d'espace disque disponible, supprimer les images des mois précédents:

#!/bin/bash

# Ce script copie les fichiers de mon répertoire racine dans le répertoire du serveur WEB.
# Un nouveau répertoire est créé à chaque heure.
# Si les images prennent trop de place, les plus anciennes sont supprimées.

while true; do 
	DISKFUL=$(df -h $WEBDIR | grep -v File | awk '{print $5 }' | cut -d "%" -f1 -)

	until [ $DISKFUL -ge "90" ]; do 

        	DATE=`date +%Y%m%d`
        	HOUR=`date +%H`
        	mkdir $WEBDIR/"$DATE"
                                                                                
        	while [ $HOUR -ne "00" ]; do
                	DESTDIR=$WEBDIR/"$DATE"/"$HOUR"
                	mkdir "$DESTDIR"
                	mv $PICDIR/*.jpg "$DESTDIR"/
                	sleep 3600
                	HOUR=`date +%H`
        	done

	DISKFULL=$(df -h $WEBDIR | grep -v File | awk '{ print $5 }' | cut -d "%" -f1 -)
	done

	TOREMOVE=$(find $WEBDIR -type d -a -mtime +30)
	for i in $TOREMOVE; do
		rm -rf "$i";
	done

done

Notez l'initialisation des variables HOUR et DISKFULL et l'emploi d'options avec ls et date afin d'obtenir une liste correcte pour TOREMOVE.

Plutôt que de contrôler une boucle en testant le résultat d'une commande ou la saisie utilisateur, vous pouvez spécifier un fichier depuis lequel l'entrée est lue pour contrôler la boucle. Dans un tel cas, read est souvent la commande de contrôle. Tant que des lignes sont entrées dans la boucle, les commandes de la boucle sont exécutées. Dès que toutes les lignes ont été lues la boucle s'arrête.

Parce que la structure de boucle est considérée comme étant une structure de commande (tel que while TEST-COMMAND; do CONSEQUENT-COMMANDS; done), la redirection doit apparaître après l'instruction done afin de respecter la syntaxe.

Ce genre de redirection convient aux autres types de boucles.

Dans l'exemple suivant, le résultat de la commande find est utilisé comme entrée de la commande read afin de contrôler une boucle while:

[carol@octarine ~/testdir] cat archiveoldstuff.sh
#!/bin/bash

# Ce script crée un sous-répertoire dans le répertoire courant où sont gardés les
# fichiers supprimés.
# Cela pourrait être adapté à cron (avec modifications) pour être exécuté 
# chaque semaine ou mois.

ARCHIVENR=`date +%Y%m%d`
DESTDIR="$PWD/archive-$ARCHIVENR"

mkdir $DESTDIR

find $PWD -type f -a -mtime +5 | while read file
do
gzip "$file"; mv "$file".gz "$DESTDIR"
echo "$file archived"
done

Les fichiers sont compressés avant d'être déplacés dans le répertoire d'archive.

L'instruction break est employée pour quitter la boucle en cours avant sa fin normale. Ceci peut être nécessaire quand vous ne savez pas à l'avance combien de fois la boucle devra s'exécuter, par exemple parce que elle est dépendante de la saisie utilisateur.

Cet exemple montre une boucle while qui peut être interrompue. Ceci est une version légèrement améliorée du script wisdom.sh de la Section 2.2.3, « Contrôle d'une boucle while avec des saisies au clavier ».

#!/bin/bash

# Ce script vous apporte sagesse
# Vous pouvez maintenant quitter d'une façon décente.

FORTUNE=/usr/games/fortune

while true; do
echo "Sur quel sujet voulez-vous un conseil?"
echo "1.  politique"
echo "2.  startrek"
echo "3.  noyau"
echo "4.  sports"
echo "5.  excusesbidon"
echo "6.  magie"
echo "7.  amour"
echo "8.  littérature"
echo "9.  drogues"
echo "10. éducation"
echo

echo -n "Entrez votre choix, ou 0 pour quitter: "
read choice
echo

case $choice in
     1)
     $FORTUNE politique
     ;;
     2)
     $FORTUNE startrek
     ;;
     3)
     $FORTUNE noyau
     ;;
     4)
     echo "Le sport est une perte d'argent, d'énergie et de temps."
     echo "Retournez à votre clavier."
     echo -e "\t\t\t\t -- \"Unhealthy is my middle name\" Soggie."
     ;;
     5)
     $FORTUNE excusesbidon
     ;;
     6)
     $FORTUNE magie
     ;;
     7)
     $FORTUNE amour
     ;;
     8)
     $FORTUNE littérature
     ;;
     9)
     $FORTUNE drogues
     ;;
     10)
     $FORTUNE éducation
     ;;
     0)
     echo "OK, au revoir!"
     break
     ;;
     *)
     echo "Ceci n'est pas un choix valide, taper un chiffre entre 0 et 10."
     ;;
esac  
done

Mémorisez que break quitte la boucle, pas le script. Ceci se voit en ajoutant une commande echo à la fin du script. Cet echo sera aussi exécuté à la saisie qui provoque l'exécution du break (quand l'usager frappe « 0 »).

Dans les boucles imbriquées, break autorise la spécification de la boucle dont il faut sortir. Voir les pages Bash info pour plus de détails.

L'instruction continue repart à l'itération d'une boucle for, while, until ou select.

Quand elle est utilisée dans une boucle for la variable de contrôle prend la valeur de l'élément suivant de la liste. Quand elle est utilisée dans une structure while ou until à contrario, l'exécution repart avec la première commande de TEST-COMMAND en haut de la boucle.

Dans les exemples suivants, les noms de fichiers sont convertis en minuscule. Si la conversion n'est pas nécessaire, une instruction continue recommence l'exécution de la boucle. Ces commandes ne consomment pas trop de ressources systèmes, et la plupart du temps, un effet similaire peut être obtenu avec sed et awk. Cependant, il est utile de connaître ces structures pour l'exécution de travaux coûteux,  cela ne serait sans doute pas nécessaire si les tests était positionnés aux bons endroits dans le script, en partageant les ressources systèmes.

[carol@octarine ~/test] cat tolower.sh
#!/bin/bash

# Ce script convertit tous les noms de fichiers contenant des majuscules en nom de fichier contenant que des minuscules

LIST="$(ls)"

for name in "$LIST"; do

if [[ "$name" != *[[:upper:]]* ]]; then
continue
fi

ORIG="$name"
NEW=`echo $name | tr 'A-Z' 'a-z'`

mv "$ORIG" "$NEW"
echo "nouveau nom pour $ORIG est $NEW"
done

Ce script a au moins un inconvénient: il écrase les fichiers existants. L'option noclobber de Bash est seulement utile quand intervient des redirections. L'option -b de la commande mv offre plus de sécurité, mais seulement dans le cas de réécriture accidentelle, comme le montre ce test:

[carol@octarine ~/test] rm *

[carol@octarine ~/test] touch test Test TEST

[carol@octarine ~/test] bash -x tolower.sh
++ ls
+ LIST=test
Test
TEST
+ [[ test != *[[:upper:]]* ]]
+ continue
+ [[ Test != *[[:upper:]]* ]]
+ ORIG=Test
++ echo Test
++ tr A-Z a-z
+ NEW=test
+ mv -b Test test
+ echo 'nouveau nom pour Test est test'
new name for Test is test
+ [[ TEST != *[[:upper:]]* ]]
+ ORIG=TEST
++ echo TEST
++ tr A-Z a-z
+ NEW=test
+ mv -b TEST test
+ echo 'nouveau nom pour TEST est test'
nouveau nom pour TEST est test

[carol@octarine ~/test] ls -a
./  ../  test  test~

tr fait parti du paquet textutils, il peut effectuer toute sorte de transformation de caractère.

Toute instruction dans une structure select peut être un autre select ce qui autorise un(des) sous-menu(s) dans un menu.

Par défaut la variable PS3 n'est pas changée dans une boucle select imbriquée. Si vous voulez une invite différente dans le sous-menu, assurez-vous de la définir aux bons moments.

La commande shift est l'une des intégrées Bourne Shell qui est fournie par Bash. Cette commande prend un paramètre, un nombre. Les paramètres positionnels sont décalés sur la gauche le nombre de fois N. Les paramètres positionnels de N+1 à $# sont renommés avec les noms de variable $1 à $# - N+1.

Disons que nous avons une commande qui a 10 paramètres, et N vaut 4, alors $4 devient $1, $5 devient $2 et ainsi de suite. $10 devient $7 et les anciens$1, $2 et $3 sont éliminés.

Si N est zéro ou supérieur à $# les paramètres positionnels ne sont pas décalés (le nombre total de paramètres, voir Section 2.1.2, « Contrôle des paramètres de la ligne de commande »). Si N est absent, il est considéré valant 1. Le code renvoyé est zéro à moins que N soit supérieur à $# ou inférieur à zéro, sinon il est différent de zéro.

Une instruction shift est typiquement employée quand le nombre de paramètres d'une commande n'est pas connu par avance, par exemple quand l'usager peut donner autant de paramètres qu'il le souhaite. Dans de tels cas, les paramètres sont généralement traités dans une boucle while avec un test sur (( $# )). Ce test est vrai tant que le nombre de paramètres est supérieur à zéro. La variable $1 et l'instruction shift traite chaque paramètre. Le nombre de paramètres est diminué chaque fois que shift est exécutée et finalement devient zéro, sur quoi la boucle while s'arrête.

L'exemple suivant, cleanup.sh, emploie l'instruction shift pour traiter chaque fichier d'une liste générée par find:

#!/bin/bash

# Ce script peut éliminer des fichiers qui n'ont pas été accédés depuis plus de 365 jours.

USAGE="Utilisation: $0 dir1 dir2 dir3 ... dirN"

if [ "$#" == "0" ]; then
	echo "$USAGE"
	exit 1
fi

while (( "$#" )); do

if [[ "$(ls $1)" == "" ]]; then 
	echo "Répertoire vide, rien à faire."
  else 
	find $1 -type f -a -atime +365 -exec rm -i {} \;
fi

shift

done

Dans l'exemple suivant, nous avons modifié le script de la Section 2.4.4, « Les documents intégrés (NdT: here documents, que l'on appele aussi 'document lié') » afin qu'il accepte de multiples paquets à installer d'un coup:

#!/bin/bash
if [ $# -lt 1 ]; then
        echo "Utilisation: $0 package(s)"
        exit 1
fi
while (($#)); do
	yum install $1 << CONFIRM
	y
	CONFIRM
	shift
done