Script Shell Partie 4 : Structures de Contrôle de Répétition

Bienvenue dans la quatrième partie de la série de tutoriels sur le script shell de HowtoForge (Cliquez ici pour lire la partie 1, la partie 2 et la partie 3 du tutoriel). Dans cette partie, nous allons couvrir 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 de 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 de boucle optimisent tout code en fournissant un moyen de minimiser le code, le rendant plus facile à dépanner que du code non structuré fournissant la même sortie. Il existe trois types d’instructions de boucle que le shell bash prend en charge : les boucles for, while et until.

Boucles For

La boucle for est une instruction de 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 boucle for :

Syntaxe 1 : Structure For-in

for  in   
 do  
     #### votre instruction ici  
 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 de boucle for qui permettra à l’utilisateur d’entrer 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 "Entrer l'entier %d : " $var   
      read input   
      result=$((result+input))   
 done   
 echo "le résultat est " $result

Instruction de boucle utilisant for dans bash

Dans cet exemple, la variable var sert de compteur pour notre boucle. Sa valeur est définie dans la liste de nombres après le mot-clé in et le shell change les valeurs de la variable var après chaque exécution du cycle dans l’instruction de boucle. Comme il n’y a que cinq valeurs entières dans notre liste, le shell exécutera les codes à l’intérieur de notre instruction de boucle pendant seulement cinq fois.

Syntaxe 2 : Instruction de boucle For avec des valeurs de liste de chaînes

Vous pouvez également déclarer une variable qui contiendra la liste des éléments pour votre compteur. Par exemple, considérez le code suivant :

#!/bin/bash  
 list="var1 var2 var3 var4"   
 var=""   
 mkdir sample   
 cd sample   
 echo créant les "répertoires...."  
 for var in $list   
 do   
      mkdir $var   
 done

Lecture des valeurs de chaînes utilisant l'instruction de boucle for

La ligne list=”var1 var2 var3 var4” définit les valeurs de la variable list. Elle a ensuite été assignée à var dans la ligne for var in $list et enfin, les répertoires sont créés dans la ligne mkdir $var.

Syntaxe 3 : Instruction de boucle For avec une liste comme fichier

Vous pouvez également récupérer une liste à partir d’un fichier existant à utiliser dans l’instruction de boucle for au lieu de la déclarer à l’intérieur de votre code en utilisant la commande cat. Par exemple, ouvrez votre éditeur de texte préféré puis notez au moins cinq noms de répertoires.

Création de répertoires à partir d'un fichier texte utilisant la boucle for

Ensuite, ouvrez 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 "créant des répertoires...."  
 for var in $dirList   
 do   
 mkdir $var   
 done

Création de répertoires à partir d'un fichier texte utilisant la boucle for

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   
 #### votre code va ici  
 done

Peut-être que la structure de boucle for la plus familière que le shell prend en charge 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 des instructions à l’intérieur de la clause do, sinon, il termine l’instruction de boucle et passe à la ligne après le mot-clé done. Le shell procédera à l’itération suivante via l’instruction d’incrément ou de décrément déclarée après le test booléen. Par exemple, reconstruisons notre premier exemple en utilisant cette structure.

#!/bin/bash   
 result=0   
 input=0   
 for((var=1;var<=5;var++))   
 do   
 printf "Entrer l'entier %d : " $var   
 read input   
 result=$((result+input))   
 done  
 echo $result

Instructions de boucle For dans bash

Instruction de Boucle While

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 de boucle for, la structure de contrôle de répétition while sépare l’initialisation, le test booléen et l’instruction d’incrément/decrément.

Syntaxe 1 : Structure While avec des symboles arithmétiques basés sur des instructions conditionnelles

  
 while(condition)  
 do  
     ###votre code va ici  
   
 done

Pour pouvoir différencier while des autres instructions de boucle, construisons notre premier exemple pour l’instruction while.

#!/bin/bash  
 result=0   
 input=0   
 var=1   
 while((var <= 5))   
 do  
 printf "Entrer l'entier %d : " $var   
 read input   
 result=$((result+input))   
 var=$((var+1))  
 done   
 echo "le résultat est " $result

Instruction de boucle While dans le script shell Bash

En regardant notre exemple, l’instruction while commence par une initialisation de notre variable compteur var. Ensuite, le test booléen est déclaré après le mot-clé while et l’ensemble des instructions à répéter sera déclaré à l’intérieur des instructions do et done. Dans les instructions while, l’interpréteur ne commencera et n’exécutera la répétition des codes que si le résultat du test booléen est vrai. D’autre part, l’instruction de boucle ne terminera l’itération des codes que lorsque l’expression booléenne devient fausse.

Syntaxe 2 : Instruction de boucle While avec une instruction conditionnelle basée sur un mnémonique

  
 while [  ]  
 do  
 ####votre code va ici  
   
 done

Vous pouvez également déclarer une instruction conditionnelle basée sur un mnémonique à l’intérieur d’une instruction de boucle while. Pour la déclaration, une parenthèse carrée sera utilisée au lieu de parenthèses. (Consultez les instructions conditionnelles basées sur un mnémonique ici) Par exemple :

#!/bin/bash   
 var=1;   
 while [ $var -le 5 ]   
 do   
 printf "Entrer l'entier %d : " $var   
 read input   
 result=$((result+input))   
 var=$((var+1))   
 done   
 echo "le résultat est " $result

Instruction de boucle While dans le script shell

Syntaxe 3 : Instruction de boucle While avec une instruction conditionnelle basée sur un fichier

while read   
 do   
 ####votre code va ici   
 done <

Tout comme ce que nous avons fait dans l’instruction de boucle for, vous pouvez également ouvrir un fichier texte et l’associer à l’instruction de boucle while. Par exemple :

#!/bin/bash   
 mkdir sample2  
cd sample2   
 echo "créant des répertoires..."  
 while read var   
 do   
     mkdir $var   
 done

Dans cet exemple, j’ai recyclé la liste que nous avons créée tout à l’heure et créé un nouveau script dans le même répertoire. Notez que si votre fichier texte est situé dans un répertoire différent, vous devez fournir le chemin exact du fichier après le symbole <.

`Instruction de Boucle Until`

Un autre type d’instruction de boucle que le bash prend en charge 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éclarée donne un résultat faux. C’est l’opposé complet de l’instruction while.

`Syntaxe 1 : Boucle Until avec une instruction conditionnelle basée sur des symboles arithmétiques`

until (())  
 do  
 ####ensemble de commandes  
 done

Prenons un exemple :

result=0   
 input=0   
 var=1   
 until((var > 5))   
 do   
 printf "Entrer l'entier %d : " $var  
 read input   
 result=$((result+input))   
 var=$((var+1))   
 done   
 echo "le résultat est " $result

`Syntaxe 2 : Instruction de boucle Until avec une instruction conditionnelle basée sur un mnémonique`

  
 until [  ]  
 do  
      ####votre code va ici  
   
 done

Puisque l’instruction until est juste l’opposée de l’instruction de boucle while, vous pouvez également déclarer une instruction conditionnelle basée sur un mnémonique dans la structure until. Cependant, pour terminer, vous devez déclarer une instruction conditionnelle opposée - c’est-à-dire faire en sorte que l’instruction conditionnelle évalue à faux.

!/bin/bash   
 result=0   
 input=0   
 var=1   
 until [ $var -gt 5 ]   
 do   
 printf "Entrer l'entier %d : " $var   
 read input   
 result=$((result+input))   
 var=$((var+1))   
 done   
 echo "le résultat est " $result

`Conclusion`

Cette partie du tutoriel couvre les trois structures de boucle que le bash prend en charge : les instructions de boucle for, while et until. Chacune de ces instructions 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 rendant ainsi le script shell facile à coder.