9 exemples de boucles for dans les scripts Linux Bash

Le Bash polyvalent for loop fait bien plus que boucler un certain nombre de fois. Nous décrivons ses nombreuses variantes afin que vous puissiez les utiliser avec succès dans vos propres scripts Linux.

La boucle for

Tous les langages de script et de programmation ont un moyen de gérer les boucles. Une boucle est une section de code que vous souhaitez exécuter à plusieurs reprises. Plutôt que de taper le même ensemble d’instructions dans votre script, encore et encore, une boucle répétera une section de code encore et encore pour vous.

La fête for la boucle est très flexible. Il peut fonctionner avec des nombres, des mots, des tableaux, des variables de ligne de commande ou la sortie d’autres commandes. Ceux-ci sont utilisés dans le entête de la boucle. L’en-tête dicte avec quoi la boucle fonctionne – des nombres ou des chaînes, par exemple – et quelle est la condition de fin qui arrêtera la boucle.

La corps de la boucle contient le code que vous souhaitez faire répéter. Il contient ce que vous voulez que la boucle fais. Le corps de la boucle peut contenir n’importe quelle commande de script valide.

Une variable appelée compteur de boucle ou itérateur est utilisé pour parcourir une plage de valeurs ou une liste d’éléments de données. Pour chaque boucle, l’itérateur prend la valeur du nombre, de la chaîne ou du type de données suivant sur lequel la boucle itère. Cela permet à la boucle de travailler tour à tour avec les valeurs de chacun des éléments de données ou même, dans certains cas, de manipuler les éléments de données eux-mêmes.

Simple pour les boucles

Si vous cherchez à écrire votre première boucle for, ces exemples simples vous aideront à démarrer.

pour les boucles utilisant des listes numériques

Vous pouvez exécuter un for boucle sur la ligne de commande. Cette commande crée et exécute un simple for boucle. L’itérateur est une variable appelée i. Nous allons attribuer i être chacune des valeurs de la liste de nombres, à tour de rôle. Le corps de la boucle va imprimer cette valeur dans la fenêtre du terminal. La condition qui termine cette boucle est lorsque i a parcouru toute la liste des nombres.

for i in 1 2 3 4 5; do echo $i; done

Il est important de noter ici que la variable i est augmenté de un à chaque fois que la boucle tourne, mais c’est parce que la liste des nombres augmente d’un à chaque fois.

Cette liste de nombres commence à 3 et monte par paliers de deux, puis saute arbitrairement à 44.

for i in 3 5 7 9 11 44; do echo $i; done

Cela ne fait aucune différence pour le for boucle. Il commence à une extrémité de la liste et utilise chaque valeur à tour de rôle, jusqu’à ce que toutes les valeurs de la liste aient été utilisées.

Les nombres n’ont pas non plus besoin d’être dans l’ordre croissant. Ils peuvent être dans n’importe quel ordre.

for i in 3 43 44 11 9; do echo $i; done

pour les boucles utilisant des listes de mots

Nous pouvons tout aussi bien faire la même chose avec des mots. Copiez le texte du script dans un éditeur et enregistrez-le sous « word-list.sh ».

#!/bin/bash

for word in This is a sequence of words
do 
  echo $word
done

Vous devrez utiliser chmod pour rendre le script exécutable, et tout autre script que vous copiez à partir de cet article. Remplacez simplement le nom du script chaque fois que vous utilisez le chmod commande.

chmod +x word-list.sh

Exécutons le script.

./word-list.sh

Tout comme il l’a fait avec les nombres, l’itérateur – dans cet exemple, la variable word— parcourt la liste des éléments de données jusqu’à ce qu’il atteigne la fin de la liste. Le corps de la boucle accède à la valeur dans le word variable et ainsi chaque mot de la liste est traité.

pour les boucles avec plages de nombres

Si vous vouliez un for boucle pour s’exécuter 100 fois, il serait assez fastidieux de devoir saisir une séquence de 100 chiffres dans l’en-tête de la boucle. Les plages de numéros vous permettent de spécifier uniquement le premier et le dernier numéro.

Ce script est « number-range.sh ».

#!/bin/bash

for i in {1..10}
do
  echo "Loop spin:" $i
done

La plage de numéros est définie entre accolades « {}« avec deux périodes »..” séparant les nombres qui commencent et terminent la plage. Assurez-vous de ne pas inclure d’espace dans la définition de la plage.

Voici comment cela fonctionne :

./number-range.sh

Vous pouvez inclure un autre nombre qui définit la taille de pas que l’itérateur doit utiliser pour parcourir les nombres de la plage. Ce script, « number-range2.sh » utilisera une plage de 0 à 32 et une taille de pas de 4.

#!/bin/bash

for i in {0..32..4}
do
  echo "Loop spin:" $i
done

L’itérateur parcourt la plage de nombres par sauts de quatre.

./number-range2.sh

pour les boucles utilisant des noms de fichiers

Parce que nous pouvons traiter des listes de mots, nous pouvons faire fonctionner nos scripts avec des noms de fichiers. Ce script s’appelle « filenames.sh ».

#!/bin/bash

for file in word-list.sh number-range.sh number-range2.sh filenames.sh
do
  ls -lh "$file"
done

Il serait assez inutile d’avoir un script qui ne fait que ce que ls peut faire, mais il montre comment accéder aux noms de fichiers à l’intérieur du corps de la boucle.

./filenames.sh

De la même manière que pour l’utilisation de la plage de numéros, nous pouvons utiliser un modèle de fichier dans l’en-tête de la boucle pour spécifier les fichiers que nous voulons traiter. Cela évite beaucoup de frappe et signifie que nous n’avons pas besoin de connaître à l’avance les noms des fichiers.

Ce script s’appelle « filenames2.sh ». Nous avons remplacé la liste des noms de fichiers par le modèle de nom de fichier « *.sh » pour que le rapport de script concerne tous les fichiers de script du répertoire actuel.

#!/bin/bash

for file in *.sh
do
  ls -lh "$file"
done

Voici la sortie.

./filenames2.sh

Boucles for utilisant des paramètres de ligne de commande

Nous pouvons ajouter un peu plus de flexibilité en passant le modèle de nom de fichier sur la ligne de commande. La $* La variable représente tous les paramètres de ligne de commande passés au script.

Il s’agit de « filenames3.sh ».

#!/bin/bash

for file in $*
do
  ls -lh "$file"
done

Nous demanderons des noms de fichiers commençant par « n » et ayant une extension SH.

./filenames3.sh n*.sh

Nous pouvons également transmettre plus d’un motif à la fois.

./filenames3.sh n*.sh .bashrc

La variable d’itérateur file prend la valeur de chacun des paramètres de la ligne de commande. Les modèles de noms de fichiers sont développés et tous les noms de fichiers sont traités dans le corps de la boucle.

C-like pour les boucles

Bash prend en charge la boucle for classique à trois termes, comme celles trouvées dans le langage de programmation C. On les appelle des boucles for à trois termes car il y a trois termes dans l’en-tête de la boucle.

• La valeur initiale de l’itérateur de boucle.
• Le test pour savoir si la boucle continue ou se termine.
• L’incrémentation ou la décrémentation de l’itérateur.

Ce script est « c-like.sh ».

L’itérateur I est défini sur 1 au début de la boucle, et la boucle s’exécutera aussi longtemps que l’instruction ” i<=10  » est vrai. Dès que i atteint 11 ans, le for la boucle s’arrêtera. L’itérateur est augmenté de un à chaque révolution de la boucle.

#!/bin/bash

for (( i=1; i<=10; i++ ))
do 
  echo "Loop number:" $i
done

Exécutons ce script.

./c-like.sh

Le C-like for boucle permet de créer facilement for boucles qui ont des exigences légèrement étranges. Cette boucle commence à 15 et compte à rebours par pas de 3. C’est « c-like2.sh »

#!/bin/bash

for (( i=15; i>0; i-=3 ))
do 
  echo "Loop number:" $i
done

Lorsque nous l’exécutons, il devrait revenir en arrière par étapes de trois.

./c-like2.sh

Infini pour les boucles

Vous pouvez également utiliser ce format de for boucle pour créer une boucle infinie. Tout ce que vous avez à faire est de supprimer tous les éléments de l’en-tête de la boucle, comme ceci. C’est « infini.sh. »

#!/bin/bash

for (( ; ; ))
do
  echo "Press Ctrl+C to stop..."
  sleep 1
done

Vous devrez appuyer sur Ctrl + C pour arrêter la boucle.

./infinite.sh

pour les boucles utilisant des tableaux de mots

Nous pouvons facilement parcourir un tableau de mots. Nous devons fournir le nom du tableau dans l’en-tête de la boucle, et l’itérateur parcourra toutes les entrées du tableau. Il s’agit de « word-array.sh ».

#!/bin/bash

distributions=("Ubuntu Fedora Manjaro Arch EndeavourOS Garuda")

for distro in $distributions
do
  echo $distro
done

Toutes les distributions sont listées pour nous.

./word-array.sh

La commande continuer

Si vous souhaitez que la boucle passe par-dessus une entrée particulière, testez si l’itérateur correspond à cette entrée et utilisez la continue commande. La continue la commande abandonne le courant rotation de la boucle. Il incrémente l’itérateur et démarre la rotation suivante de la boucle, en supposant que l’entrée que vous souhaitez ignorer n’est pas le dernier élément de la liste.

Il s’agit de « word-array2.sh ». Il enjambe l’entrée du tableau « Arch » mais traite tous les autres membres du tableau.

#!/bin/bash

distributions=("Ubuntu Fedora Manjaro Arch EndeavourOS Garuda")

for distro in $distributions
do
  if [[ "$distro" == "Arch" ]] ;
    then
    continue
  fi
  echo $distro
done

« Arch » n’apparaît pas dans la fenêtre du terminal.

./word-array2.sh

La commande break

La break La commande sort de la boucle et empêche tout autre traitement.

Il s’agit de « word-array3.sh ». C’est le même que le script précédent avec continue remplacé par break.

#!/bin/bash

distributions=("Ubuntu Fedora Manjaro Arch EndeavourOS Garuda")

for distro in $distributions
do
  if [[ "$distro" == "Arch" ]] ;
    then
    break
  fi
  echo $distro
done

Lorsque l’itérateur contient « Arch », la boucle for abandonne tout traitement supplémentaire.

./word-array3.sh

pour les boucles utilisant des tableaux associatifs

Dans Bash 4 et supérieur, les tableaux associatifs vous permettent de créer des listes de paires clé-valeur qui peuvent être recherchées par clé ou par valeur. En raison de la relation bidirectionnelle entre la clé et la valeur, ils sont également appelés dictionnaires de données.

Nous pouvons parcourir un tableau associatif en utilisant un for boucle. Ce script est « associative.sh ». Il définit un tableau associatif avec quatre entrées, une pour chacun de « dog », « cat », « robin » et « human ». Ce sont les clés. Les valeurs sont le nombre (par défaut) de jambes qu’ils ont chacun.

#!/bin/bash

declare -A animals=( [dog]=Four-legged [cat]=Four-legged [robin]=Two-legged [human]=Two-legged )

for legs in ${!animals[@]}
do
  if [ ${animals[$legs]} == "Two-legged" ]; then 
    echo ${legs}
  fi
done

L’itérateur est appelé legs . Notez que l’en-tête de la boucle contient un « ! » point d’exclamation. Cela n’agit pas comme l’opérateur logique NOT, cela fait partie de la syntaxe du tableau associatif. Il est nécessaire de rechercher dans le tableau.

Le corps de la boucle effectue un test de comparaison de chaînes. Si la valeur du membre du tableau est « Two-legged », il imprime la valeur de la clé dans la fenêtre du terminal. Lorsque nous l’exécutons, le script imprime les créatures à deux pattes.

./associative.sh

Itération sur la sortie des commandes

Si vous avez une commande ou une séquence de commandes qui produit une liste de quelque chose, comme des noms de fichiers, vous pouvez les parcourir avec un for boucle. Vous devez faire attention aux extensions de nom de fichier inattendues, mais dans les cas simples, tout va bien.

Ce script est « command.sh ». il utilise ls et wc pour fournir une liste triée des noms de fichiers de script, ainsi que leur nombre de lignes, de mots et d’octets.

#!/bin/bash

for i in $(ls *.sh | sort);
do 
  echo $(wc $i)
done

Lorsque nous l’exécutons, nous obtenons les statistiques de chaque fichier, avec les fichiers répertoriés par ordre alphabétique.

./command.sh

L’éblouissant pour la boucle

La for loop est un outil de script polyvalent et facile à comprendre. Mais aussi flexible soit-il, n’oubliez pas que d’autres boucles existent pour une raison. Ne soyez pas ébloui en pensant que for boucle est tout ce dont vous aurez besoin.

La while boucle, par exemple, est beaucoup mieux adaptée à certaines choses que la for boucle, comme la lecture de lignes à partir d’un fichier.

Rédiger de bons scripts signifie utiliser l’outil le plus adapté à la tâche à accomplir. La for loop est un excellent outil à avoir dans votre boîte à outils d’astuces.