Boucle imbriquée dans des exemples de script bash

En programmation ou en script, la boucle est l'un des concepts les plus fondamentaux et les plus puissants. Une boucle effectue certaines tâches jusqu'à ce que les conditions spécifiées soient remplies. Chaque langage de programmation ou de script a différentes façons de mettre en œuvre le concept.

Dans ce guide, consultez la boucle imbriquée en script bash.

Boucle imbriquée

Une boucle, par définition, effectue certaines tâches jusqu'à ce que les conditions soient remplies. Et si la tâche comprend l'exécution d'une boucle? C'est le concept d'une boucle imbriquée. Une boucle dans une boucle.

C'est la structure de base d'une boucle.

while (condition)
# quelque chose

Ici, la boucle while continuera à effectuer les tâches déclarées à l'intérieur du bloc tant que la condition est remplie. Dans le cas d'une boucle imbriquée, la structure ressemblerait à ceci.

# boucle principale
while (condition)
# boucle imbriquée
while (condition)
# quelque chose

En théorie, les boucles imbriquées peuvent aller à une profondeur infinie. Dans de nombreuses situations, les boucles imbriquées peuvent être la solution parfaite.

Boucle en script bash

Bash est une puissante langue de script. Il existe différentes structures de boucle dans le bash. Les plus populaires sont pour, pendant que et jusqu'à des boucles. Si vous connaissez la programmation C / C ++ auparavant, alors la syntaxe sera certainement assez similaire.

Pour boucles

Car Loop est l'une des sorties de formes les plus courantes et les plus polyvalentes, etc. La structure des boucles dans les scripts bash. La structure ressemble également à une boucle en C / C ++ beaucoup.

La structure de la boucle pour bash est la suivante.

pour ((initialiser; condition; incrément)); faire
# quelque chose
fait

La structure est très explicite. La section d'initialisation n'est pas obligatoire. Cependant, la condition et l'incrément sont une priorité plus élevée.

Mettons-le en action. Voici un script bash très simpliste qui implémente pour Loop.

pour ((i = 0; i < 5 ; i++)); do
Echo "Hello World"
fait

Il est également possible d'utiliser la liste / plage comme condition de boucle. Il est particulièrement utile si vous travaillez avec une liste de fichiers, des gammes de nombres, des tableaux, des sorties de commande, etc. La structure ressemble à quelque chose comme ça.

pour l'article dans ; faire
# quelque chose
fait

Par exemple, le script suivant imprimera «Hello World» cinq fois.

pour i dans 1… 5; faire
Echo "Hello World"
fait

Et si nous devons travailler avec le contenu d'un répertoire? Dans l'exemple suivant, le script imprimera tous les fichiers dans le répertoire / usr / bin.

pour i in / usr / bin / *; faire
echo $ i
fait

Maintenant, que faisons-nous pour avoir une boucle imbriquée? C'est juste pour une boucle à l'intérieur d'un autre. Voici une boucle imbriquée en utilisant l'exemple précédent.

pour ((i = 0; i < 3 ; i++)); do
pour ((j = 0; j < 2 ; j++)); do
Echo "Hello World"
fait
fait

La production sera «Hello World» 6 fois. La boucle extérieure fonctionnera trois fois, exécutant la boucle intérieure deux fois.

Pendant les boucles

La boucle while est une autre boucle populaire et intuitive disponible en script bash. La syntaxe ressemble à ceci.

alors que ; faire
# quelque chose
fait

Dans l'exemple suivant, le script imprimera «Hello World» cinq fois.

num = 1
tandis que [$ num -le 5]; faire
Echo "Hello World"
num = $ (($ num + 1))
fait

À quoi cela ressemblerait-il d'avoir une boucle imbriquée? Voici un exemple simple.

num_a = 1
num_b = 1
tandis que [$ num_a -le 5]; faire
tandis que [$ num_b -le 5]; faire
Echo "Hello World"
num_b = $ (($ num_b + 1))
fait
num_a = $ (($ num_a + 1))
fait

Jusqu'à des boucles

Si vous avez un fond de programmation en C / C ++, alors vous connaissez la boucle à faire. Malheureusement, Bash n'a rien de tel. Cependant, jusqu'à ce que la boucle fonctionne de manière similaire. La syntaxe a également la même apparence.

jusqu'à [ ]] faire
# quelque chose
fait

La différence entre le temps et jusqu'à ce que la boucle soit la condition de test. Tant que la condition de test est vraie, une boucle de temps continuera de fonctionner. Une boucle jusqu'à ce que vous ne continuera à fonctionner que si la condition est fausse.

Voici un exemple rapide de la boucle while. Il imprimera le tableau de multiplication de 2.

num_a = 1
jusqu'à [$ num_a -gt 10]; faire
echo $ (($ num_a * 2))
num_a = $ (($ num_a + 1))
fait

Pause en boucle

Dans certaines situations, si certaines conditions sont remplies, l'exécution du reste de la boucle devient redondante. Les pauses en boucle sont une caractéristique intéressante qui permet de sortir de la boucle à une condition donnée. Il est plus important pour les boucles imbriquées, plus les boucles sont élevées, plus la consommation de ressources et l'inefficacité.

Ici, ce qui suit pour Loop cessera d'exécuter dès qu'il atteindra la condition.

pour ((i = 1; i<=100;i++)); do
echo $ i
si [$ i -eq 10]; alors
casser
Fi
fait

Découvrez comment casser pendant la boucle pour une explication approfondie et une démonstration des pauses en boucle.

Dernières pensées

Une boucle imbriquée est un concept simple et puissant à comprendre et à mettre en œuvre. Espérons que ce guide a pu décrire et démontrer le concept.

Intéressé par plus de guides de script bash? Découvrez les guides suivants.

• Boucle infinie bash
• Entrée utilisateur de script bash
• Tableau de retour de la fonction de bash

Happy Computing!