Boucles — traiter les fichiers un par un avec for

Traiter une liste dans l'ordre — for

for prend les valeurs que tu lui donnes une à une et exécute le même travail sur chacune.

La forme est for v in a b c; do ... done, où v devient a, puis b, puis c tour à tour.

Ce qui se trouve entre do et done est le corps qui se répète.

Tu peux lister les valeurs directement, utiliser un motif de fichiers comme *.txt, ou injecter la sortie de $(...) d'une commande.

Écris for f in *.txt et chaque fichier .txt du répertoire courant passe dans f tour à tour, ce qui te permet d'écrire un traitement par fichier.

Utiliser $(...) comme dans for line in $(cat list.txt) te laisse parcourir la sortie d'une commande.

C'est ainsi que tu écris des synthèses sur une liste de fichiers ou un traitement par lot sur plusieurs fichiers.

for env in dev stg prod; do        # traite les valeurs listées tour à tour
  echo "deploying to $env"
done
for f in *.sh; do                  # traite les fichiers .sh tour à tour
  echo "script: $f"
done

Écris un script qui parcourt une liste de fichiers et totalise les comptes.

① Ouvre count-lines.sh avec vi count-lines.sh, appuie sur i pour passer en mode insertion et écris #!/bin/sh sur la première ligne.

② Dans le script, crée quelques fichiers de matière, parcours un motif de fichiers avec for, compte les lignes de chaque fichier une à une et affiche le total.

③ Appuie sur Esc, enregistre avec :wq, puis rends le script exécutable.

④ Lance le script et vérifie que chaque fichier et le total s'affichent.

⑤ Si tu hésites sur quoi écrire, copie le texte du panneau de réponse et colle-le dans le mode insertion de vi. (Exécute-le correctement pour révéler l'explication.)

Répéter sur une condition — while / until

while répète tant que la condition est vraie.

Comme dans while [ "$i" -lt 3 ]; do ... done, tu incrémentes un compteur dans le corps pour avancer vers la fin.

until fait l'inverse — il répète jusqu'à ce que la condition devienne vraie.

Il convient au travail dont le nombre de tours n'est pas fixé à l'avance.

i=1
while [ "$i" -le 3 ]; do          # répète tant que i vaut 3 ou moins
  echo "try $i"
  i=$((i + 1))
done                              # try 1 / try 2 / try 3

i=1
until [ "$i" -gt 3 ]; do          # répète jusqu'à ce que la condition devienne vraie
  echo "i=$i"
  i=$((i + 1))
done                              # i=1 / i=2 / i=3

Écris un script de réessai qui répète le travail tout en comptant les tours.

① Ouvre retry.sh avec vi retry.sh, appuie sur i pour passer en mode insertion et écris #!/bin/sh sur la première ligne.

② Mets en place une variable compteur, boucle avec while jusqu'à une limite en affichant le numéro de tentative, et incrémente le compteur dans le corps.

③ Vérifie que réécrire le même travail avec until [ "$i" -gt "$max" ] donne le même résultat.

④ Appuie sur Esc, enregistre avec :wq, puis rends le script exécutable.

⑤ Lance le script et vérifie qu'il a répété le nombre de fois prévu.

⑥ Si tu hésites sur quoi écrire, copie le texte du panneau de réponse et colle-le dans le mode insertion de vi.

Contrôler une boucle for — break / continue

Même en plein milieu d'une boucle for, tu peux changer le flux avec break et continue.

continue saute le reste de ce tour et passe à l'élément suivant, tandis que break met fin à la boucle elle-même.

Combine-les avec une condition comme dans if [ condition ]; then continue; fi ou if [ condition ]; then break; fi pour sauter les éléments dont tu n'as pas besoin ou arrêter une fois que tu en as assez.

for n in 1 2 3 4 5; do
  if [ "$n" -eq 3 ]; then continue; fi  # saute 3
  if [ "$n" -eq 5 ]; then break; fi     # sort à 5
  echo "n=$n"
done                                    # n=1 / n=2 / n=4

Écris un script de collecte qui saute les valeurs vides et s'arrête à une limite.

① Ouvre collect.sh avec vi collect.sh, appuie sur i pour passer en mode insertion et écris #!/bin/sh sur la première ligne.

② Parcours une liste de valeurs avec for, saute les valeurs vides ou indésirables avec continue, et sors de la boucle avec break une fois la limite atteinte.

③ Appuie sur Esc, enregistre avec :wq, puis rends le script exécutable.

④ Lance le script et vérifie les valeurs sautées et le point où il s'est arrêté.

⑤ Si tu hésites sur quoi écrire, copie le texte du panneau de réponse et colle-le dans le mode insertion de vi.

Contrôler une boucle while — break / continue

En plus de la vérification de condition dans while, utiliser break et continue te permet d'arrêter tôt ou de sauter un tour.

continue saute ce tour et revient à la vérification de condition, tandis que break sort de la boucle sans attendre la condition.

Attention ici : si tu ne places pas la mise à jour du compteur en tête du corps (avant continue), le tour sauté ne la mettra pas à jour et la boucle ne finira jamais.

i=0
while [ "$i" -lt 10 ]; do
  i=$((i + 1))                          # avance en tête
  if [ "$i" -eq 3 ]; then continue; fi  # saute le 3e tour
  if [ "$i" -eq 6 ]; then break; fi     # sort au 6e tour
  echo "attempt $i"
done                                    # attempt 1 / 2 / 4 / 5

Écris un script de balayage qui boucle avec while, saute les tours dont il n'a pas besoin et s'arrête une fois qu'il a le nombre d'éléments voulu.

① Ouvre scan.sh avec vi scan.sh, appuie sur i pour passer en mode insertion et écris #!/bin/sh sur la première ligne.

② Mets en place un compteur, boucle avec while jusqu'à une limite, et fais avancer le compteur de 1 en tête du corps.

③ Saute les tours qui remplissent une certaine condition avec continue, et sors de la boucle avec break une fois atteint le nombre d'éléments voulu.

④ Appuie sur Esc, enregistre avec :wq, puis rends le script exécutable.

⑤ Lance le script et vérifie les tours sautés et le point où il s'est arrêté.

⑥ Si tu hésites sur quoi écrire, copie le texte du panneau de réponse et colle-le dans le mode insertion de vi.