UN boucle while est une instruction qui parcourt un bloc de code jusqu'à ce que la condition spécifiée soit évaluée comme fausse. Nous pouvons utiliser cette instruction ou cette boucle dans notre programme lorsque nous ne savons pas combien de fois la condition va être évaluée comme vraie avant d'être évaluée comme fausse.
Table des matières
- La syntaxe d'une boucle while dans les scripts BASH
- Exemple de boucle utilisant l'instruction while sous Linux
- Lire un fichier avec une boucle while
- Boucle while infinie
- Boucle While pour itérer un nombre fixe de fois
- Lisez l'argument de ligne de commande avec les options getopts
- Boucle while de style C
- Boucle While pour effectuer des opérations sur un fichier
- Écrire dans un fichier à l'aide d'une boucle while
- Arrêter et continuer à utiliser la boucle while
- Questions fréquemment posées
La syntaxe d'une boucle while dans les scripts BASH
while [ condition ]; do # statements # commands done>
Si la condition est vraie, les commandes à l'intérieur du bloc while sont exécutées et itérées à nouveau après avoir vérifié la condition. De plus, si la condition est fausse, les instructions à l'intérieur du bloc while sont ignorées et les instructions après le bloc while sont exécutées.
Exemple de boucle utilisant l'instruction while sous Linux
Tout d'abord, nous créons un fichier texte à l'aide d'un éditeur de texte sous Linux, dans ce cas, nous utilisons l'éditeur de texte `vim`.
vim while.sh>
#!/usr/bin/bash
une=7
tandis que [ $a -gt 4 ];
faire
écho $a
((un-))
fait
echo Hors de la boucle
Explication:
-
#!/usr/bin/bash>: Cette ligne s'appelle un shebang et indique le chemin vers l'interpréteur qui doit être utilisé pour exécuter le script. Dans ce cas, il précise que le shell Bash doit être utilisé. -
a=7>: Initialise une variable nomméea>avec la valeur 7. -
while [ $a -gt 4 ];>: Démarre une boucle while qui continue aussi longtemps que la valeur dea>est supérieur à 4. -
do>: Marque le début du bloc de code à exécuter dans la boucle while. -
echo $a>: Imprime la valeur actuelle de la variablea>à la console. -
((a--))>: Décrémente la valeur dea>par 1. C'est une manière abrégée d'écrirea=$((a - 1))>. -
done>: Marque la fin du bloc de code pour la boucle while. -
echo 'Out of the loop'>: Imprime la sortie de la boucle sur la console une fois la boucle while terminée.
Boucle While sous Linux
En résumé, ce script initialise une variable ` a`> avec la valeur 7, puis entre dans une boucle while qui continue aussi longtemps que ` a`> est supérieur à 4. Dans la boucle, il imprime la valeur actuelle de ` a`> et le décrémente de 1 à chaque itération. Une fois ` a`> devient 4 ou moins, la boucle se termine et le script imprime Out of the loop sur la console.
Lire un fichier avec une boucle while
On peut lire un fichier avec une boucle while en BASH. En analysant certains paramètres selon la condition de boucle while, nous pouvons parcourir le fichier ligne par ligne ou par d'autres groupes comme des caractères ou des mots.
bash longueur de chaîne
Tout d'abord, nous créons un fichier texte à l'aide d'un éditeur de texte sous Linux, dans ce cas, nous utilisons l'éditeur de texte `vim`.
vim while.sh>
#!/usr/bin/bash
fichier = temp.txt
while read -r ligne ;
faire
écho $ligne
fait <$fichier
Explication:
-
#!/usr/bin/bash>: Cette ligne shebang spécifie que le shell Bash doit être utilisé pour interpréter le script. -
file=temp.txt>: Attribue la chaîne temp.txt à la variablefile>, représentant le nom du fichier à lire. -
while read -r line;>: Initie une boucle while qui lit chaque ligne du fichier spécifié. -
do>: Marque le début du bloc de code à exécuter dans la boucle while. -
echo $line>: Imprime le contenu de la variableline>, qui représente la ligne en cours de lecture du fichier vers la console. -
done>: Marque la fin du bloc de code pour la boucle while. -
<'$file'>: redirige l'entrée de la boucle while vers le fichier spécifié, dans ce cas, temp.txt.
En résumé, ce script lit chaque ligne du fichier temp.txt et l'imprime sur la console jusqu'à ce qu'il ne reste plus de lignes dans le fichier. Le-r>possibilité avec leread>La commande est utilisée pour garantir que les barres obliques inverses dans l’entrée sont traitées comme des caractères littéraux.
lire le fichier en utilisant l'instruction while sous Linux
Nous utilisons la commande read pour récupérer les lignes ou les caractères du fichier. La commande read est passée avec l'argument -r qui ignore l'échappement des caractères si le apparaît et est donc analysé comme étant le sien. Nous lisons une ligne d'un fichier mentionné après l'instruction done. La commande read lit une ligne du fichier mentionné et les boucles while se terminent lorsque la dernière ligne du fichier est lue (il ne reste plus aucune ligne à lire).
C'est ainsi que nous pouvons lire le contenu du fichier en utilisant une boucle while en BASH.
Boucle while infinie
Pour créer une boucle infinie à l'aide d'une instruction de boucle while. Nous n'avons pas besoin de mettre de condition dans la boucle while et donc la boucle itère à l'infini. Voici un exemple de boucle while infinie :
Tout d'abord, nous créons un fichier texte à l'aide d'un éditeur de texte sous Linux, dans ce cas, nous utilisons l'éditeur de texte `vim`.
vim while.sh>
#!/usr/bin/bash
alors que :
faire
echo Une boucle infinie
# Nous pouvons appuyer sur Ctrl + C pour quitter le script
fait
Explication:
-
#!/usr/bin/bash>: La ligne shebang précise que le shell Bash doit être utilisé pour interpréter le script. -
while :>: Initie une boucle infinie. Le:>(deux-points) est une commande intégrée au shell qui renvoie toujours vrai, créant ainsi une boucle infinie. -
do>: Marque le début du bloc de code à exécuter dans la boucle infinie. -
echo 'An Infinite loop'>: Imprime la chaîne An Infinite Loop sur la console à chaque itération de la boucle. -
# We can press Ctrl + C to exit the script>: Il s'agit d'un commentaire indiquant que vous pouvez interrompre le script en appuyant sur Ctrl + C dans le terminal. Ctrl + C est un moyen courant d'interrompre et de terminer les scripts en cours d'exécution dans le terminal. -
done>: Marque la fin du bloc de code pour la boucle infinie.
En résumé, ce script crée une boucle infinie qui fait écho en permanence au message An Infinite loop sur la console. La boucle peut être interrompue et le script quitté en appuyant sur Ctrl + C dans le terminal.
Boucle infinie utilisant l'instruction While sous Linux
Ainsi, la boucle while du script va itérer pendant un temps infini. On peut briser manuellement la boucle ou le script par CTRL + C.
Boucle While pour itérer un nombre fixe de fois
Nous pouvons utiliser une boucle while pour parcourir un nombre fixe de fois, nous pouvons définir la condition comme étant -le ou inférieure à un nombre, et la boucle itérera jusqu'à ce que l'itérateur soit inférieur ou égal au nombre fourni dans la condition. De plus, nous devons incrémenter l'itérateur manuellement afin de maintenir l'itérateur de boucle en marche, sinon la boucle continuera indéfiniment.
Tout d'abord, nous créons un fichier texte à l'aide d'un éditeur de texte sous Linux, dans ce cas, nous utilisons l'éditeur de texte `vim`.
vim while.sh>
#!/usr/bin/bash
je = 1
# le chiffre 4 peut être la limite à
# parcourir la boucle
tandis que [ $i -le 4 ];
faire
écho $i
((i++))
faitquand est-ce que Win 7 est sorti
Explication:
-
#!/usr/bin/bash>: La ligne shebang précise que le shell Bash doit être utilisé pour interpréter le script. -
i=1>: Initialise une variable nomméei>avec la valeur 1. -
while [ $i -le 4 ];>: Initie une boucle while qui continue aussi longtemps que la valeur dei>est inférieur ou égal à 4. -
do>: Marque le début du bloc de code à exécuter dans la boucle while. -
echo $i>: Imprime la valeur actuelle de la variablei>à la console. -
((i++))>: Incrémente la valeur dei>par 1. C'est une manière abrégée d'écrirei=$((i + 1))>. -
done>: Marque la fin du bloc de code pour la boucle while.
boucle while sous Linux
Dans l’exemple ci-dessus, nous pouvons voir que la boucle itère un nombre défini de fois. Comme nous avons initialisé le compteur à 1 et que la condition est de parcourir la boucle jusqu'à ce que l'itérateur soit inférieur ou égal au nombre dans ce cas 4. Ainsi, nous pouvons changer le nombre dans la condition selon nos besoins.
Lisez l'argument de ligne de commande avec les options getopts
Nous pouvons utiliser les options get ops pour lire l'entrée de la ligne de commande et s'il y a plusieurs arguments, nous pouvons les vérifier et les analyser un par un à l'aide d'une boucle while. getopts est un outil permettant d'obtenir les entrées de l'utilisateur à partir de la ligne de commande. Nous pouvons avoir plusieurs options pour analyser à partir de la ligne de commande, et en utilisant getopts et les boucles while, nous pouvons créer un programme de saisie utilisateur d'aspect professionnel.
Tout d'abord, nous créons un fichier texte à l'aide d'un éditeur de texte sous Linux, dans ce cas, nous utilisons l'éditeur de texte `vim`.
vim while.sh>
#!/bin/bash
while getopts n:a : OPT
faire
cas ${OPT} dans
n) nom=${OPTARG} ;;
a) âge=${OPTARG} ;;
*) echo Option invalide
sortie 1 ;;
esac
fait
printf Je m'appelle $name et j'ai $age ans
Explication:
-
#!/bin/bash>: La ligne shebang précise que le shell Bash doit être utilisé pour interpréter le script. -
while getopts n:a: OPT>: Initie une boucle qui utilisegetopts>pour analyser les options de ligne de commande. Les options spécifiées sontn>eta>, qui devraient tous deux être suivis d'un argument. -
do>: Marque le début du bloc de code à exécuter dans la boucle. -
case '${OPT}' in>: démarre une instruction case qui évalue la valeur de l'option rencontrée pargetopts>. -
n) name=${OPTARG};;>: Si l'option est-n>, affecte la valeur de l'argument correspondant à la variablename>. -
a) age=${OPTARG};;>: Si l'option est-a>, affecte la valeur de l'argument correspondant à la variableage>. -
*) echo 'Invalid option'>: Si une option non valide est rencontrée, imprime un message d'erreur sur la console. -
exit 1;;>: Quitte le script avec un code d'état différent de zéro, indiquant une erreur. -
esac>: termine l'instruction case. -
done>: Marque la fin du bloc de code pour la boucle. -
printf 'My name is $name and am $age years old '>: Imprime un message formaté sur la console en utilisant les valeurs de `name`>et `age`>obtenu à partir des options de ligne de commande.
Boucle while sous Linux
Dans ce cas, nous avons deux options à savoir le nom et l’âge, vous pouvez avoir plusieurs options. Nous devons spécifier quelle option allons-nous utiliser les instructions switch case et à partir de la ligne de commande en utilisant l'option -shorthand. Dans ce cas, nous avons utilisé -n pour le nom et -un pour l'âge . Nous avons également une vérification de cas par défaut ou invalide pour garantir que nous n'analysons pas les mauvais arguments. Nous pouvons attribuer la valeur de l'option en utilisant le OPTARG variable qui analyse la valeur fournie à l'option.
La boucle while ici est utilisée pour itérer jusqu'à ce qu'aucune option ne soit transmise depuis la ligne de commande. Nous vérifions les options -n et -a et itérons jusqu'à ce que la touche retour chariot ou entrée soit enfoncée et qu'il n'y ait plus d'options à analyser.
Boucle while de style C
Nous pouvons utiliser une boucle while de style C dans BASH, les variables doivent être évaluées avec le style BASH mais la syntaxe globale ressemble à C. Nous pouvons utiliser les opérateurs comme ,<= et ainsi de suite dans la condition de la boucle while et donc est appelé comme la boucle while de style C.
Tout d'abord, nous créons un fichier texte à l'aide d'un éditeur de texte sous Linux, dans ce cas, nous utilisons l'éditeur de texte `vim`.
vim c-style-while.sh>
#!/bin/bash
je = 0
tandis que ((je <12))
faire
écho $i
((i+=2))
fait
c-style-pendant
Dans cet exemple, nous pouvons voir que la boucle while a une condition avec des opérateurs non bash comme -le, -ge, etc. à la place, nous utilisons les opérateurs de style C dans la condition. Le reste de la boucle est la boucle de base comme en BASH, la variable ou itérateur i est incrémentée de deux comme on peut le voir dans la dernière instruction du corps de la boucle. Ainsi, la boucle itère plus de 5 fois.
Boucle While pour effectuer des opérations sur un fichier
Nous pouvons effectuer des opérations sur un fichier, comme lire uniquement une partie particulière d'un fichier. Si nous avons des colonnes formatées d'une manière particulière, nous pouvons utiliser des variables pour les attribuer et les imprimer sur une seule ligne.
Voici l'exemple de nom de fichier wh.txt
vim wh.txt>
nous créons un fichier texte à l'aide d'un éditeur de texte sous Linux, dans ce cas, nous utilisons l'éditeur de texte `vim`.
décodage js base64
vim file-while.sh>
Type de langue publié
Python général 1991
JavascriptWeb 1995
Javamobile 1995
Rouille intégrée 2010
Aller au back-end 2007
nous créons un fichier texte à l'aide d'un éditeur de texte sous Linux, dans ce cas, nous utilisons l'éditeur de texte `vim`.
vim file-while.sh>
#!/bin/bash
en lisant a b c
faire
écho $b – $a
fait
Boucle while sous Linux
Dans cet exemple, nous avons trois lignes, nous lisons le contenu en les attribuant aux variables a,b et c, cela peut être n'importe quoi mais n'oubliez pas de les utiliser dans le corps de la boucle. Nous pouvons sélectionner une colonne particulière comme b et a et pouvons imprimer ou effectuer n'importe quelle opération dessus. Cela ne sera cependant pas reflété dans le fichier car il ne s'agit que des variables de script locales.
Écrire dans un fichier à l'aide d'une boucle while
Nous pouvons écrire dans un fichier par saisie utilisateur dans une boucle while. Nous pouvons utiliser la boucle while pour itérer jusqu'à ce que nous quittions manuellement la boucle en utilisant CTRL + D en enregistrant les modifications apportées au fichier ou en CTRL + C pour éviter d'écrire dans le fichier. Nous utilisons la commande read pour saisir le texte à partir de la ligne de commande et l'analyser dans le fichier.
Tout d'abord, nous créons un fichier texte à l'aide d'un éditeur de texte sous Linux, dans ce cas, nous utilisons l'éditeur de texte `vim`.
vim write-wh.sh>
#! /bin/bash
fichier = wh.txt
echo Entrer le contenu dans le fichier $file
pendant la lecture de la ligne
faire
echo $ligne>> $fichier
fait
boucle while sous Linux
Ainsi, à partir de l'exemple ci-dessus, nous avons pu saisir du texte dans un fichier à l'aide d'une boucle while et d'une commande read. Pour sortir de la boucle et enregistrer les modifications dans le fichier, nous utilisons les touches CTRL+ D, et pour sortir de la boucle sans rien enregistrer dans le fichier, nous pouvons utiliser les touches CTRL + C. Ainsi, nous saisissons le texte de la ligne de commande dans le fichier texte en utilisant la commande read et une boucle while.
Arrêter et continuer à utiliser la boucle while
Break et continue sont essentiels dans un programme qui traite des instructions de boucle car ils contrôlent le flux des instructions de boucle sans aucune condition explicite.
Instruction Break dans la boucle While
Nous utilisons des instructions break pour sortir de la boucle sans attendre que la condition de la boucle while soit évaluée comme fausse. Cette instruction peut être utilisée dans un bloc de boucle. Cela peut être utilisé pour sortir d'une boucle infinie avec une condition programmatique à l'intérieur de la boucle et ainsi maintenir le contrôle de la boucle.
Par exemple, nous avons un script qui compte à partir de 1 et pour toujours. Mais nous pouvons sortir de la boucle par programme en utilisant une instruction break à l'intérieur du corps de la boucle avec une condition.
Tout d'abord, nous créons un fichier texte à l'aide d'un éditeur de texte sous Linux, dans ce cas, nous utilisons l'éditeur de texte `vim`.
vim while.sh>
#!/usr/bin/bash
je = 1
alors que :
faire
écho $i
si [ $i -eq 20 ]; alors
echo C'est la fin de la boucle
casser
être
((i++))
fait
Instruction Break while boucle sous Linux
À partir du script et de l'exécution, nous pouvons voir que nous avons pu interrompre ou quitter une boucle infinie avec une instruction conditionnelle et l'instruction break. Ainsi, l'instruction break est utilisée pour que le flux de contrôle d'un programme/script depuis l'intérieur d'une boucle while sorte de la boucle sans que la condition de boucle ne soit évaluée comme fausse.
Continuer l'instruction dans la boucle While
Nous pouvons utiliser l’instruction continue pour faire le contraire de l’instruction break. Il sautera au début du bloc de boucle et recommencera. Ceci peut être utilisé pour sauter certaines commandes pour certaines conditions et permet ainsi de modifier le déroulement de la boucle.
Par exemple, si nous avons une variable initialisée à 1 et que nous souhaitons afficher uniquement les nombres divisibles par cinq ou selon un certain modèle suivant une condition, nous pouvons utiliser les instructions continue pour faire exactement cela. Cela permet de parcourir la boucle de la manière souhaitée.
Tout d'abord, nous créons un fichier texte à l'aide d'un éditeur de texte sous Linux, dans ce cas, nous utilisons l'éditeur de texte `vim`.
vim while.sh>
#!/usr/bin/bash
je = 1
tandis que [ $i -lt 30 ];
faire
((i++))
si [[ $(( $i % 5 )) -ne 0 ]];
alors
continuer
être
écho $i
fait
Continuer l'instruction dans la boucle While sous Linux
Comme nous pouvons le voir, l'instruction continue passe au début du bloc et démarre l'exécution des commandes en sautant les commandes suivantes à l'intérieur du bloc. La boucle while itère uniquement pour la valeur de variable je étant inférieur à 30, la condition if vérifie donc si le variable je est divisible par 5, et si ce n'est pas le cas, nous répétons à nouveau en utilisant continue et incrémentons la valeur de la variable i. Le variable je n'est répercuté que s'il est divisible par 5, donc la condition if est évaluée à false et nous ne rencontrons pas d'instruction continue et ne suivons pas le flux normal de la boucle. Ceci est fait pour éviter la journalisation de chaque nombre et imprimer uniquement les nombres qui ne suivent pas un modèle ou une condition dans l'instruction if ou d'autres instructions conditionnelles.
Questions fréquemment posées
1. Qu'est-ce qu'un ` while`> boucle dans les scripts Bash ?
UNwhile>loop est une instruction de flux de contrôle dans les scripts Bash qui permet à un certain bloc de code d'être exécuté à plusieurs reprises tant qu'une condition spécifiée est vraie. La boucle permet d'automatiser les tâches répétitives et constitue une construction fondamentale dans les scripts et la programmation.
2. Comment fonctionne la syntaxe d'un ` while`> regarder en boucle dans Bash ?
La syntaxe de base d'unwhile>la boucle dans Bash est la suivante :
tandis que [état]
faire
# Code à exécuter tant que la condition est vraie
fait
Le ' condition`> est un test qui a lieu avant chaque itération de la boucle. Si la condition est vraie, le code dans la boucle est exécuté. Si la condition est fausse, la boucle se termine et le script continue avec la commande suivante après le ` done`> déclaration.
3. Quel est le rôle du ` (( ... ))`> construire dans un Bash while> boucle?
Le ' (( ... ))`> La construction dans Bash est utilisée pour les opérations arithmétiques. Dans le cadre d'un ' while`> boucle, il est souvent utilisé pour évaluer des conditions arithmétiques.
Par exemple: ` ((i <10))> `>vérifie si la variable ` i`> est inférieur à 10. Cela vous permet d'utiliser des expressions arithmétiques directement dans la condition de boucle, ce qui le rend particulièrement utile lorsqu'il s'agit de comparaisons numériques.
numpy unique
4. Comment créer une boucle infinie en utilisant ` while`> dans Bash ?
Une boucle infinie dans Bash peut être créée en fournissant une condition qui est toujours évaluée comme vraie.
Par exemple:
bien que vrai
faire
# Code pour la boucle infinie
fait
Alternativement, vous pouvez utiliser une constante non nulle dans la condition, comme ` while [ 1 ]`> , pour obtenir le même résultat. Les boucles infinies sont utiles dans les situations où une exécution continue est requise jusqu'à ce qu'elle soit interrompue manuellement.
Conclusion
Dans cet article, nous avons discuté de la boucle while de script BASH qui s'avère être un outil polyvalent pour exécuter un bloc de code à plusieurs reprises en fonction d'une condition spécifiée. La syntaxe de base implique de définir la condition entre crochets, permettant des itérations flexibles. L'article explore diverses applications des boucles while, notamment la lecture à partir de fichiers, la création de boucles infinies, les itérations fixes, l'analyse des arguments de ligne de commande et l'utilisation des instructions break et continue. De la syntaxe de style C à l’écriture de fichiers interactifs, chaque exemple démontre l’adaptabilité de la boucle pour répondre à une gamme de besoins en matière de scripts. Cet aperçu complet souligne l’importance de la boucle while dans les scripts BASH, fournissant un mécanisme robuste pour une répétition contrôlée et une exécution efficace du code.