pendant, pendant et jusqu’à –

La plupart des langages de programmation prennent en charge diverses formes de lignes de code en boucle. Bash prend en charge nativement les boucles «while», «until» et les plus connues, les boucles «for». Cet article présente et discute les trois.

Que sont Boucles Bash?

Pour définir un peu mieux cela, nous devrions commencer par la question que sont les boucles. Les boucles sont une construction de langage de programmation, permettant à un développeur de répéter (c’est-à-dire de boucler) certaines parties, ou la totalité, du code à l’intérieur d’une telle définition de boucle. Il est désormais facile de définir Boucles Bash comme toute construction de langage de programmation en boucle utilisée dans Bash!

Bash prend en charge nativement les boucles basées sur «for», «until» et «while». Chacun d’eux a ses propres avantages, mais vous pouvez déjà avoir une idée de leur signification simplement en regardant l’idiome du mot principal. Par exemple, «jusqu’à» conduit à penser naturellement à «faire quelque chose jusqu’à» et c’est bien ce que fait une boucle Bash «jusqu’à»; il boucle une certaine quantité de code (ou la totalité) jusqu’à ce qu’une certaine condition soit remplie.

De même, les boucles «while» continuent à s’exécuter jusqu’à ce qu’une condition ne soit plus vraie. Enfin, «pour» boucle de boucles, par exemple, un nombre défini de fois, semblable à la façon dont on écrirait «pour 70 fois, fais…». Cela nous aide à comprendre logiquement les fonctionnalités uniques que chaque boucle nous fournit et à implémenter un code plus lisible.

pour Boucles Bash basées

Pour les besoins de cet article, nous examinerons la nouvelle forme de définition Bash pour les boucles. Une définition un peu plus ancienne et moins moderne de pour les boucles dans Bash peuvent, par exemple, ressembler à ceci: for i in $(seq 1 5); do echo $i; done. Comparons cela avec un look plus propre, mieux structuré et moderne pour boucle:

for ((i=1;i<=5;i++)); do echo $i; done

Ce simple pour basé sur Bash one-liner (un terme souvent utilisé dans les cercles Linux / Bash pour conceptualiser un mini-script écrit sur une seule ligne) imprimera les nombres 1 à 5 dans l’ordre séquentiel. Nous définissons une valeur de départ pour le i variable ($i) en attribuant la valeur 1 au même, comme la première partie de notre pour définition de boucle, terminée par un ; délimiteur.

Ensuite, nous précisons que nous sommes un seul à monter ‘plus petit ou égal à cinq’ en utilisant i<=5. Nous indiquons ensuite ce qui doit se passer à la fin de chaque tour, c’est-à-dire augmenter la variable i par un, ou, dans un raccourci de codage couramment utilisé (y compris dans le langage C ++ par exemple), cela se traduit par i++.

Enfin, nous spécifions le début de notre code de boucle en utilisant do, c’est-à-dire après avoir terminé notre for définition de boucle, comme pour toute autre terminaison d’instruction, avec ; avant le do. Nous spécifions également la fin de notre code de boucle en utilisant done et nous echo (imprimer) la valeur de notre variable je entre le do et done.

Notez également que le do la clause elle-même n’est pas terminée par ;, et cela conduirait à une erreur. Prendre en compte do un préfixe à ce qui doit être fait, et cela a plus de sens. C’est peut-être une des raisons pour lesquelles il est parfois plus propre de mettre les choses dans un script multiligne, car le do peut simplement être le dernier mot d’une ligne.

Même lors de la définition d’autres types de boucles, nous maintiendrons toujours le do et done clauses, et nous nous assurerons toujours de terminer notre définition de boucle (c’est-à-dire avant do) avec ;, ainsi que la fin de chaque déclaration individuelle dans notre do...done définition de boucle avec ;.

Mettons ceci dans un petit script pour voir plus clairement comment les choses peuvent fonctionner de cette façon:

#!/bin/bash

for ((i=1;i<=10;i+=2)); do 
  echo $i
done

Après avoir rendu le script exécutable avec chmod +x test.sh, nous exécutons la même chose. Quelques petits changements ont été apportés au script. Notez comment cette fois, nous augmentons la variable i par deux à chaque fois. Ceci fait en utilisant un autre raccourci de codage, à savoir i+=2 qui peut être lu comme augmenter i de deux. On peut aussi écrire i=i+2 au même endroit, et cela fonctionne exactement de la même manière.

Nous voyons que nous commençons à 1et augmenter de 2 chaque fois que nous parcourons la boucle, se terminant à 9. La raison pour laquelle il se termine à 9 est que la valeur maximale est dix. Ainsi, après 9 la valeur suivante serait 11, ce qui est plus grand alors dix et il n’est donc pas affiché / bouclé.

Notez également comment le ; a été supprimé après la ligne d’écho. En effet, il n’est pas nécessaire de terminer la fin d’une instruction s’il existe à la place une situation / un caractère de fin de ligne. C’est le cas ici; nous n’avons aucune autre commande après le echo $i et la ligne se termine immédiatement (les espaces à la fin de la ligne conviendraient aussi, le principe est simplement de ne pas avoir d’autre commande à moins que cette nouvelle commande ne soit préfixée (et la précédente terminée) par ;).

tandis que Boucles Bash basées

Voyons ensuite une boucle Bash – en utilisant la même do...done définition de boucle, nous pouvons définir un tandis que la boucle Bash basée qui fonctionnera tant qu’une condition donnée est vraie.

i=1; while [ $i -le 5 ]; do echo $i; i=$[ i + 1 ]; done

Dans cet exemple, nous faisons la même chose que notre premier pour exemple de boucle basée. Alors que la définition semble plus complexe (et donc pour boucle peut être mieux adaptée à ce cas d’utilisation particulier), il est intéressant de voir comment on peut définir un tandis que boucle de la même manière.

Ici, nous définissons d’abord notre i variable, manuellement, dans une commande séparée terminée par ;, à 1. Ensuite, nous commençons un tandis que boucle où nous définissons une condition, d’une manière très similaire à la définition d’un if déclaration (il y a un lien à la fin de cet article vers un article sur if si vous souhaitez en savoir plus), où nous vérifions si le i la variable est inférieure ou égale (-le) puis 5.

Après cela, nous avons notre habituel do...done bloc dans lequel nous echo notre variable, et par la suite, dans une nouvelle instruction, manuellement, augmentez la valeur de notre i variable par un dans un calcul mathématique tel que défini par le $[...] Idiomes de calcul Bash. Passons maintenant au contrôle d’un jusqu’à la boucle Bash basée

jusqu’à Boucles Bash basées

Forts de ce que nous avons appris jusqu’à présent, nous pouvons désormais évaluer plus facilement les éléments suivants jusqu’à boucle Bash basée:

i=1; until [ $i -gt 5 ]; do echo $i; i=$[ i + 1 ]; done

Ici, nous recherchons la condition je meilleur que 5 devenir vrai. Jusqu’à ce moment (c.-à-d. jusqu’à basée sur la boucle), nous imprimerons (en utilisant echo) notre variable je et augmenter la même chose avec un, pareil à notre précédent tandis que exemple basé.

Nous pouvons voir comment la syntaxe du jusqu’à est très similaire à la commande tandis que commander. Notez également que, contrairement au for basée sur une commande, ces commandes recherchent soit un vrai condition de persister (avec tandis que), ou a pour un vrai condition pour commencer (avec jusqu’à). Cela permet également d’utiliser d’autres commandes qui peuvent renvoyer une sortie de type vrai / faux, comme par exemple grep -q:

echo 1 > a
while grep -q '1' ./a; do echo 'yes'; sleep 5; done

Ici, nous ajoutons le nombre 1 dans un fichier nommé une, et vérifiez l’existence du numéro 1 dans ce fichier en utilisant un grep -q (un grep silencieux). Nous continuons à le faire (ie tandis que) jusqu’à ce que ce ne soit plus vrai. Bien que ce soit vrai, nous imprimons le texte Oui et mettez la boucle en pause pendant cinq secondes avec sleep 5. Notez comment chaque commande se termine par ; encore.

Après environ 17 secondes, nous interrompons notre script en utilisant CTRL + c, qui est la méthode universelle pour arrêter un processus en cours dans Bash (en plus du CTRL + z plus fort et plus efficace qui met immédiatement un processus en pause, mais c’est pour un autre article!)

Emballer

Dans cet article, nous avons passé en revue les boucles «for», «while» et «until» qui sont disponibles nativement dans Bash. Si vous êtes intéressé par plus de Bash, jetez un œil aux tests conditionnels dans Bash: if, then, else, elif et Bash Functions et Local Variables.

Prendre plaisir!