Script bash pour la boucle expliqué avec des exemples

Présentation

Le for loop est une fonctionnalité de programmation essentielle qui passe par une liste d'éléments. Pour chacun de ces éléments, le for loop exécute un ensemble de commandes. La commande aide à répéter les processus jusqu'à une condition de fin.

Que vous parcouriez un tableau de nombres ou que vous renommiez des fichiers, for les boucles dans les scripts Bash offrent un moyen pratique de répertorier automatiquement les éléments.

Ce tutoriel montre comment utiliser Bash for boucles dans les scripts.

Prérequis

• Accès au terminal/ligne de commande (CTRL +ALT +T ).
• Un éditeur de texte, tel que Nano ou Vi/Vim.
• Terminologie de programmation élémentaire.

Script bash pour la boucle

Utilisez le for boucle pour parcourir une liste d'éléments afin d'exécuter les commandes indiquées.

La syntaxe de base pour le for loop dans les scripts Bash est :

for <element> in <list>
do
	<commands>
done

L'élément, la liste et les commandes analysés dans la boucle varient en fonction du cas d'utilisation.

Bash For Exemples de boucles

Vous trouverez ci-dessous divers exemples de for boucle dans les scripts Bash. Créez un script, ajoutez le code et exécutez les scripts Bash depuis le terminal pour voir les résultats.

Éléments individuels

Parcourez une série d'éléments donnés et imprimez chacun avec la syntaxe suivante :

#!/bin/bash
# For loop with individual numbers
for i in 0 1 2 3 4 5
do
   echo "Element $i"
done

Exécutez le script pour voir le résultat :

. <script name>

Le script imprime chaque élément de la liste fournie sur la console.

Vous pouvez également utiliser des chaînes dans une liste séparée par des espaces :

#!/bin/bash
# For loop with individual strings
for i in "zero" "one" "two" "three" "four" "five"
do
   echo "Element $i"
done

Enregistrez le script et exécutez-le depuis le terminal pour voir le résultat.

La sortie imprime chaque élément sur la console et quitte la boucle.

Plage

Au lieu d'écrire une liste d'éléments individuels, utilisez la syntaxe de plage et indiquez le premier et le dernier élément :

#!/bin/bash
# For loop with number range
for i in {0..5}
do
        echo "Element $i"
done

Le script génère tous les éléments de la plage fournie.

La syntaxe de plage fonctionne également pour les lettres. Par exemple :

#!/bin/bash
# For loop with letter range
for i in {a..f}
do
        echo "Element $i"
done

Le script envoie des lettres à la console par ordre croissant dans la plage fournie.

La syntaxe de plage fonctionne pour les éléments dans l'ordre décroissant si l'élément de départ est supérieur à l'élément de fin.

Par exemple :

#!/bin/bash
# For loop with reverse number range
for i in {5..0}
do
        echo "Element $i"
done

La sortie répertorie les nombres dans l'ordre inverse.

La syntaxe de plage fonctionne que les éléments augmentent ou diminuent.

Plage avec incrément

Utilisez la syntaxe de plage et ajoutez la valeur de pas pour parcourir la plage par intervalles.

Par exemple, utilisez le code suivant pour répertorier les nombres pairs :

#!/bin/bash
# For loop with range increment numbers
for i in {0..10..2}
do
        echo "Element $i"
done

La sortie imprime tous les autres chiffres de la plage donnée.

Vous pouvez également boucler de dix à zéro en comptant à rebours par nombres pairs :

#!/bin/bash
# For loop with reverse range increment numbers
for i in {10..0..2}
do
        echo "Element $i"
done

Exécutez le script pour imprimer tous les autres éléments de la plage dans l'ordre décroissant.

Incrément d'échange 2 pour tout nombre inférieur à la distance entre la plage pour obtenir des valeurs pour différents intervalles.

La commande seq

Le seq commande génère une séquence de nombres. Analyser la séquence dans le script Bash for loop comme une commande pour générer une liste.

Par exemple :

#!/bin/bash
# For loop with seq command
for i in $(seq 0 2 10)
do
   echo "Element $i"
done

La sortie imprime chaque élément généré par le seq commande.

Le seq La commande est une commande historique et non une méthode recommandée pour générer une séquence. Les méthodes intégrées des accolades sont préférables et plus rapides.

Style C

Les scripts bash autorisent trois paramètres de style C for expressions de contrôle de boucle. Ajoutez l'expression entre doubles parenthèses comme suit :

#!/bin/bash
# For loop C-style
for (( i=0; i<=5; i++ ))
do
   echo "Element $i"
done

L'expression se compose de :

• L'initialiseur (i=0 ) détermine le nombre où la boucle commence à compter.
• Condition d'arrêt (i<=5 ) indique quand la boucle se termine.
• Étape (i++ ) incrémente la valeur de i jusqu'à la condition d'arrêt.

Séparez chaque condition par un point-virgule (; ). Ajustez les trois valeurs en fonction de votre cas d'utilisation.

Le terminal affiche chaque élément, en commençant par la valeur de l'initialiseur.

La valeur augmente de la quantité de pas, jusqu'à la condition d'arrêt.

Boucles infinies

Infini for les boucles n'ont pas de condition définie pour terminer la boucle. Le programme s'exécute indéfiniment car la condition de fin n'existe pas ou ne se remplit jamais.

Pour générer un for infini boucle, ajoutez le code suivant à un script Bash :

#!/bin/bash
# Infinite for loop
for (( ; ; ))
do
      echo "CTRL+C to exit"
done

Pour terminer l'exécution du script, appuyez sur CTRL +C .

Les boucles infinies sont utiles lorsqu'un programme s'exécute jusqu'à ce qu'une condition particulière soit remplie.

Pause

L'instruction break termine la boucle en cours et permet de quitter le for boucle tôt. Ce comportement permet de sortir de la boucle avant de remplir une condition indiquée.

Pour illustrer, ajoutez le code suivant à un script Bash :

#!/bin/bash
# Infinite for loop with break
i=0
for (( ; ; ))
do
        echo "Iteration: ${i}"
        (( i++ ))
        if [[ i -gt 10 ]]
        then
                break;
        fi
done
echo "Done!"

L'exemple montre comment sortir d'un for infini boucle en utilisant un break . L'instruction Bash if aide à vérifier la valeur de chaque entier et fournit le break condition. Cela termine le script lorsqu'un entier atteint la valeur dix.

Pour sortir d'une boucle imbriquée et d'une boucle externe, utilisez break 2 .

Continuer

Le continue La commande termine l'itération de la boucle en cours. Le programme continue la boucle en commençant par l'itération suivante. Pour illustrer, ajoutez le code suivant à un script Bash pour voir comment le continue l'instruction fonctionne dans un for boucle :

#!/bin/bash
# For loop with continue statement
for i in {1..100}
do
        if [[ $i%11 -ne 0 ]]
        then
                continue
        fi
        echo $i
done

Le code vérifie les nombres entre un et cent et n'imprime que les nombres divisibles par onze.

Le conditionnel if vérifie la divisibilité, tandis que le continue saute tous les nombres qui ont un reste lorsqu'ils sont divisés par onze.

Tableaux

Les tableaux stockent une liste d'éléments. Le for loop fournit une méthode pour parcourir les tableaux par élément.

Par exemple, définissez un tableau et parcourez les éléments avec :

#!/bin/bash
# For loop with array
array=(1 2 3 4 5)
for i in ${array[@]}
do
        echo "Element $i"
done

La sortie imprime chaque élément stocké dans le tableau du premier au dernier.

Le coup for loop est la seule méthode pour parcourir les éléments individuels du tableau.

Indices

Lorsque vous travaillez avec des tableaux, chaque élément a un index.

Répertorier les indices d'un tableau avec le code suivant :

#!/bin/bash
# For loop with array indices
array=(1 2 3 4 5)
for i in ${!array[@]}
do
        echo "Array indices $i"
done

L'indexation des éléments commence à zéro. Par conséquent, le premier élément a un indice zéro.

La sortie imprime des nombres de zéro à quatre pour un tableau à cinq éléments.

Boucles imbriquées

Pour parcourir ou générer des tableaux multidimensionnels, utilisez for imbriqué boucles.

Par exemple, générez des valeurs décimales de zéro à trois à l'aide de boucles imbriquées :

#!/bin/bash
# Nested for loop
for (( i = 0; i <= 2; i++ ))
do
    for (( j = 0 ; j <= 9; j++ ))
    do
            echo -n " $i.$j "
    done
  echo "" 
done

Le code fait ce qui suit :

• Ligne 1 démarre le for boucle à zéro, incrémente de un et se termine à deux inclus.
• Ligne 3 démarre le for imbriqué boucle à zéro. La valeur est incrémentée de un et se termine à neuf inclus.
• Ligne 5 imprime les valeurs du for boucles. Le for imbriqué parcourt tous les nombres trois fois, une fois pour chaque valeur de boucle externe.

La sortie imprime chaque combinaison de chiffres sur la console et entre dans une nouvelle ligne lorsque l'outer boucle termine une itération.

Chaînes

Pour parcourir les mots d'une chaîne, stockez la chaîne dans une variable. Ensuite, analysez la variable en un for boucle sous forme de liste.

Par exemple :

#!/bin/bash
# For loop with string
strings="I am a string"
for i in ${strings}
do
        echo "String $i"
done

La boucle parcourt la chaîne, chaque mot étant un élément distinct.

La sortie imprime des mots individuels de la chaîne vers la console.

Fichiers

Le for La boucle combinée aux recherches de proximité permet de répertorier ou de modifier les fichiers qui répondent à une condition spécifique.

Par exemple, listez tous les scripts Bash dans le répertoire courant avec un for boucle :

#!/bin/bash
# For loop with files
for f in *.sh
do
        echo $f
done

Le script recherche dans le répertoire courant et liste tous les fichiers avec le .sh extension.

Parcourez les fichiers ou les répertoires pour renommer ou modifier automatiquement les autorisations de plusieurs éléments à la fois.

Substitution de commande

Le for loop accepte la substitution de commande comme une liste d'éléments à parcourir.

L'exemple suivant montre comment écrire un for boucle avec substitution de commande :

#!/bin/bash
# For loop with command substitution
list=`cat list.txt`
# Alternatively, use list=$(cat list.txt)
for i in $list
do
        echo $i
done

Le commentaire Bash offre une syntaxe alternative pour la substitution de commande. Le code lit le contenu de list.txt fichier en utilisant le cat commande et enregistre les informations dans une variable list .

Utilisez la méthode de substitution de commande pour renommer des fichiers à partir d'une liste de noms enregistrés dans un fichier texte.

Remarque : Apprenez à utiliser la commande cat et la boucle for pour lire les fichiers ligne par ligne dans Bash.

Arguments de la ligne de commande

Utilisez le for boucle pour parcourir les arguments de la ligne de commande.

L'exemple de code suivant montre comment lire les arguments de ligne de commande dans un for boucle :

#!/bin/bash
# For loop expecting command line arguments
for i in [email protected]
do
    echo "$i"
done

Fournissez les arguments de ligne de commande lorsque vous exécutez le script Bash.

Par exemple :

. <script name> foo bar

Le [email protected] remplace chaque argument de ligne de commande dans le for boucle.

Conclusion

Après avoir suivi ce tutoriel, vous savez utiliser le for boucle dans les scripts Bash pour parcourir les listes.

Ensuite, apprenez à écrire et à utiliser les fonctions Bash.