Dans une structure itérative ou “boucle” un même bloc de commandes s’exécute plusieurs fois. On dit que la boucle fait plusieurs tours. Le nombre de tours qui sera réalisé est déterminé par le type de boucle utilisé et les paramètres spécifiés pour celle-ci. Il existe plusieurs types de boucles. Nous allons étudier ici les deux plus courantes. Il s’agit:

• De l’itération conditionnelle; elle continue de boucler sur le bloc de commandes tant que la condition de continuation est vérifiée.
• De l’itération bornée; elle réalise l’exécution du bloc de commandes pour chaque élément d’une liste.

Un premier type de boucle est celui consistant à répéter l’exécution du bloc de commandes tant qu’une condition est vérifiée. Cet usage est connu sous la boucle while qui est commun à beaucoup de langages de programmation.

while condition
do
  commande1
  commande2
  ...
done

#!/bin/bash
 
# Si l'argument 1 est vide, un mot est demandé à l'utilisateur
mot=${1:?"Vous devez indiquer un mot"}
 
# Si le second argument est vide, il est initialisé à 10
nb=${2:-10}
 
i=0
while [ $i -lt $nb ] ; do
echo $mot
i=$(($i + 1))
done

Une utilisation classique de la boucle while est la lecture de fichier ligne à ligne. Cette lecture se fait en utilisant la commande read.

#!/bin/bash
a=0
 
# read permet de lire l'entrée standard, retourne 0 tant que la fin
# de fichier n'est pas présente (<key>ctrl</key>+ <key>d</key>
while read ligne; do
  ((a++))
  echo $a $ligne
done

Pour utiliser le script, il faut connecter un fichier sur son entrée standard:

cat file.txt | script.sh

Si l'on souhaite pouvoir utiliser un nom de fichier placé en argument, on peut utiliser la syntaxe:

#!/bin/bash
a=0
while read ligne; do
  ((a++))
  echo $a ligne
done <$1

La redirection se place après le marqueur de fin de commande de la boucle while à savoir après le done. Le symbole $1 représente le premier argument de la ligne de commande et donc le nom du fichier à lire en entrée de la boucle.

La séquence normale d'une boucle peut être interrompue par les commandes break et continue. Ces commandes sont le plus souvent présentes dans des boucles while mais peuvent être employées également dans des boucles for.

• La commande continue renvoie en début de boucle. Les commandes présentes dans le corps de la boucle après le commande continue ne sont pas exécutées. Elle peut prendre un paramètre un entier positif indiquant le nombre de boucles imbriquées qu'il faut remonter.
• La commande break termine la boucle en sortant directement de celle-ci. Elle peut aussi prendre en argument le nombre d'imbrications à remonter.

Avec une itération bornée la séquence de commandes est répéter un nombre de fois déterminé en amont. En shell, on utilise la boucle for. Cette boucle est utilisée dans de nombreux langages. Une spécificité du shell cependant, la commande for va en fait parcourir les éléments d’une liste.

for variable in liste
do
  commande1
  commande2
  ...
done

Dans l'exemple ci-dessous, la boucle for permet de parcourir les arguments du scripts passés sur la ligne de commande:

#!/bin/bash
num=1
for var in "$@" ; do
echo "argument $num = $var"
((num++))
done

La commande seq permet de générer une liste à partir des limites passées en argument:

$ seq 1 5

#!/bin/bash
mot=${1:?"Vous devez indiquer un mot"}
nb=${2:-10}
 
for i in $(seq 1 $nb) ; do
echo $mot
done

Le Bash offre aussi un moyen de générer une liste au moyen du développement des accolades. Cette construction syntaxique génère des chaînes de caractères.

# développement de nombres entres accolades
$ echo {0..9}
0 1 2 3 4 5 6 7 8 9
 
# développement de chaînes de caractères
$ echo file.{pdf,png,jpg}
file.pdf file.png file.jpg
 
# développement combiné
$ echo A{1..4}{0..3}
A10 A11 A12 A13 A20 A21 A22 A23 A30 A31 A32 A33 A40 A41 A42 A43

La boucle for peut aussi prendre une syntaxe héritée du langage de programmation C. Cette variante est caractérisée par trois paramètres qui contrôlent la boucle for. Ces trois paramètres sont EXP1 : qui est l’initialisation de la boucle, EXP2 qui présente le test qui conditionne l’exécution du prochain tour de boucle, et EXP3 qui spécifie l’expression de comptage. EXP1, EXP2, et EXP3 sont des expressions arithmétiques.

for (( EXP1; EXP2; EXP3 ))
do
  command1
  command2
done

(( EXP1 ))
while (( EXP2 )); do
  command1
  command1
  (( EXP3 ))
done

#!/bin/bash
for ((i=1; i<=4; i++)); do
echo "Nombre $i"
done