Bienvenue dans la quatrième partie de la série de didacticiels sur les scripts shell de HowtoForge (Cliquez ici pour lire la partie 1, la partie 2 et la partie 3 du didacticiel). Dans cette partie, nous couvrirons les différentes structures de contrôle de répétition du shell bash et comment utiliser chaque structure en fournissant quelques exemples. Commençons.
Introduction
La structure de contrôle de répétition, également connue sous le nom de structure de contrôle en boucle, est un type de structure de contrôle dans les langages de programmation qui est utilisé pour simplifier les tâches répétitives ou récursives. Les instructions en boucle optimisent n'importe quel code en fournissant un moyen de minimiser le code, ce qui facilite le dépannage par rapport au code non structuré fournissant la même sortie. Il existe trois types d'instructions en boucle prises en charge par le shell bash :les boucles for, while et until.
Boucles For
La boucle for est une instruction en boucle qui utilise le mot-clé for pour déclarer une instruction répétitive. Le bash prend en charge différentes syntaxes pour l'instruction de la boucle for :
Syntaxe 1 :Structure for-in
for <varName> in <list>
do
#### your statement here
done
Cette syntaxe commence par le mot-clé for, suivi d'un nom de variable, du mot-clé in et de la liste des valeurs possibles pour la variable. Chaque valeur de la liste sera séparée par un espace et le début des lignes de code qui seront répétées est défini dans le do et se termine par un mot-clé done.
Créons une simple instruction en boucle for qui permettra à l'utilisateur de saisir 5 valeurs et d'obtenir la somme des nombres :
#!/bin/bash
result=0;
input=0;
for var in 1 2 3 4 5
do
printf "Input integer %d : " $var
read input
result=$((result+input))
done
echo "the result is " $result
Dans cet exemple, la variable var sert de compteur de notre boucle. Sa valeur est définie dans la liste des nombres après le mot-clé in et le shell modifie les valeurs de la variable var après chaque exécution du cycle dans l'instruction en boucle. Puisqu'il n'y a que cinq valeurs entières dans notre liste, le shell n'exécutera les codes à l'intérieur de notre instruction en boucle que cinq fois.
Syntaxe 2 :pour une instruction en boucle avec des valeurs de liste de chaînes
Vous pouvez également déclarer une variable qui contiendra la liste des éléments de votre compteur. Par exemple, considérez le code suivant :
#!/bin/bash
list="var1 var2 var3 var4"
var=""
mkdir sample
cd sample
echo creating the "directories...."
for var in $list
do
mkdir $var
done
La ligne list="var1 var2 var3 var4" définit les valeurs de la variable liste. Il a ensuite été affecté à var dans la ligne pour var dans $list et enfin, les répertoires sont ensuite créés dans la ligne mkdir $var.
Syntaxe 3 :instruction de boucle For avec liste sous forme de fichier
Vous pouvez également récupérer une liste à partir d'un fichier existant à utiliser dans l'instruction for looping au lieu de la déclarer dans votre code à l'aide de la commande cat. Par exemple, ouvrez votre éditeur de texte préféré, puis répertoriez au moins cinq noms de répertoires.
Ouvrez ensuite un nouvel onglet dans le même éditeur de texte et créez un nouveau script. Ce script doit être enregistré dans le même répertoire où la liste des répertoires que vous avez précédemment créés est enregistrée.
#!/bin/bash
dirList=$(cat list)
echo "creating directories...."
for var in $dirList
do
mkdir $var
done
Cet exemple devient pratique lorsque vous devez créer des centaines de répertoires sur votre ordinateur Linux, n'est-ce pas ?
Syntaxe 4 :syntaxe de type C
for((initialization; boolean_test; increment/decrement))
do
#### your code goes here
done
Peut-être que la structure la plus familière de la boucle for prise en charge par le shell est la structure de type C. La boucle commence par l'initialisation de la variable compteur, puis le shell évalue l'expression booléenne déclarée après l'initialisation. Si le résultat de l'expression booléenne est vrai, alors le shell exécutera l'ensemble d'instructions à l'intérieur de la clause do sinon, il termine l'instruction en boucle et passe à la ligne après le mot-clé done. Le shell passera à l'itération suivante via l'instruction d'incrémentation ou de décrémentation déclarée après le test booléen. A titre d'exemple, reconstruisons notre premier exemple en utilisant cette structure.
#!/bin/bash
result=0
input=0
for((var=1;var<=5;var++))
do
printf "Input integer %d : " $var
read input
result=$((result+input))
done
echo $result
Instruction en boucle
L'instruction while est un type de structure répétitive dans bash qui utilise le mot clé while. Contrairement à la syntaxe de type C de la structure en boucle for, la structure de contrôle répétitive while sépare l'initialisation, le test booléen et l'instruction d'incrémentation/décrémentation.
Syntaxe 1 :Structure While avec des instructions conditionnelles basées sur des symboles arithmétiques
<initialization>
while(condition)
do
###your code goes here
<increment/decrement>
done
Pour pouvoir différencier while des autres instructions en boucle, construisons notre premier exemple pour l'instruction while.
#!/bin/bash
result=0
input=0
var=1
while((var <= 5))
do
printf "Input integer %d : " $var
read input
result=$((result+input))
var=$((var+1))
done
echo "the result is " $result
En regardant notre exemple, l'instruction while commence par une initialisation de notre variable de compteur var. Ensuite, le test booléen est déclaré après le mot-clé while et l'ensemble d'instructions à répéter sera déclaré à l'intérieur des instructions do et done. Dans les instructions while, l'interpréteur ne démarre et n'exécute la répétition des codes que si le résultat du test booléen est vrai. D'autre part, l'instruction en boucle will ne mettra fin à l'itération des codes que lorsque l'expression booléenne donne la valeur false.
Syntaxe 2 :lors de la boucle avec instruction conditionnelle basée sur des mnémoniques
<initialization>
while [ <condition> ]
do
####your code goes here
<increment/decrement>
done
Vous pouvez également déclarer une instruction conditionnelle basée sur des mnémoniques dans une instruction de boucle while. Pour la déclaration, un crochet sera utilisé à la place de la parenthèse. (Revoyez les instructions conditionnelles basées sur des mnémoniques ici ) Par exemple :
#!/bin/bash
var=1;
while [ $var -le 5 ]
do
printf "Input integer %d : " $var
read input
result=$((result+input))
var=$((var+1))
done
echo "the result is " $result
Syntaxe 3 :lors de la boucle avec instruction conditionnelle basée sur un fichier
while read <variable_name>
do
####your code goes here
done <<path to the text file>
Tout comme ce que nous avons fait dans l'instruction de boucle for, vous pouvez également ouvrir un fichier texte et l'associer dans l'instruction de boucle while. Par exemple :
#!/bin/bash
mkdir sample2
cd sample2
echo "creating directories..."
while read var
do
mkdir $var
done<list
Dans cet exemple, j'ai recyclé la liste que nous avons créée il y a quelque temps et j'ai créé un nouveau script dans le même répertoire. Notez que si votre fichier texte se trouve dans un répertoire différent, vous devez fournir le chemin exact du fichier après le symbole <.
Jusqu'à l'instruction en boucle
Un autre type d'instruction en boucle prise en charge par bash est la structure until. L'instruction until exécute chaque commande à l'intérieur de la boucle jusqu'à ce que l'expression booléenne déclare des résultats faux. C'est tout le contraire de l'instruction while.
Syntaxe 1 :boucle Until avec instruction conditionnelle basée sur des symboles arithmétiques
until ((<conditional_statement>))
do
####set of commands
done
Prenons un exemple :
result=0
input=0
var=1
until((var > 5))
do
printf "Input integer %d : " $var
read input
result=$((result+input))
var=$((var+1))
done
echo "the result is " $result
Syntaxe 2 :jusqu'à l'instruction en boucle avec instruction conditionnelle basée sur des mnémoniques
<initialization>
until [ <condition> ]
do
####your code goes here
<increment/decrement>
done
Étant donné que l'instruction until est exactement l'opposé de l'instruction while looping, vous pouvez également déclarer une instruction conditionnelle basée sur des mnémoniques dans la structure until. Cependant, pour terminer le, vous devez déclarer une instruction conditionnelle opposée - c'est-à-dire que l'instruction conditionnelle est évaluée à false.
!/bin/bash
result=0
input=0
var=1
until [ $var -gt 5 ]
do
printf "Input integer %d : " $var
read input
result=$((result+input))
var=$((var+1))
done
echo "the result is " $result
Conclusion
Cette partie du didacticiel couvre les trois structures de bouclage prises en charge par bash - les instructions de bouclage for, while et until . Chacune de ces déclarations a une structure, une utilisation et des avantages différents. Le bash prend en charge différentes structures, offrant plus de choix aux programmeurs et facilitant ainsi le codage des scripts shell.