Guide complet des boucles de bash
Bash Shell sort de la boîte avec de nombreuses distributions Linux et contient également des caractéristiques de nombreuses autres coquilles,. Bash est beaucoup plus efficace lorsqu'il s'agit d'effectuer une opération via la commande. Si vous souhaitez effectuer une tâche qui nécessite l'exécution de plusieurs commandes avec une certaine logique, il y a un langage de programmation entier appelé Bash Scripting.
1. Qu'est-ce que les scripts bash?
2. Que sont les boucles de bash?
3. Applications de boucles dans la programmation
4. Avantages des boucles dans la programmation
5. Types de boucles en bash
- 5.1 bash pour la syntaxe de boucle
- 5.2 bash While While Loop Syntaxe
- 5.3 bash jusqu'à la syntaxe de boucle
6. Utilisation de boucles en bash
6.1 mise en œuvre de la boucle pour bash
- 6.1.1 bash pour la boucle itérant à travers une liste de chaînes
- 6.1.2 bash pour la boucle itérer via une liste de nombres
- 6.1.3 bash pour la boucle itérant à travers une gamme d'articles
- 6.1.4 bash pour la boucle itérant à travers un tableau
- 6.1.5 bash pour boucle en C comme la syntaxe
- 6.1.6 bash pour boucle infinie boucle
- 6.1.7 Bash imbriqué pour la boucle
6.2 Implémentation de la boucle While dans Bash
- 6.2.1 bash while en boucle pour imprimer les numéros
- 6.2.2 bash infini
- 6.2.3 bash en boucle avec plusieurs conditions
6.3 Mise en œuvre de la boucle jusqu'à Bash
- 6.3.1 bash jusqu'à la boucle pour imprimer les numéros
- 6.3.2 bash infini jusqu'à la boucle
7. Instructions de contrôle en boucle
- 7.1 La déclaration de pause
- 7.2 La déclaration de poursuite
8. Exemples de boucles bash
- 8.1 Exemple 1: Modification de l'extension des fichiers à l'aide de boucles bash
- 8.2 Exemple 2: Modification des noms de fichiers à l'aide de boucles bash
- 8.3 Exemple 3: Lire un fichier à l'aide de boucles bash
- 8.4 Exemple 4: trouver un fichier à l'aide de boucles bash
- 8.5 Exemple 5: Création d'un compteur simple à l'aide de boucles bash
- 8.6 Exemple 6: Vérification de la connexion Internet à l'aide de boucles bash
- 8.7 Exemple 7: une calculatrice simple avec des boucles bash
- 8.8 Exemple 8: trouver la moyenne à l'aide de boucles bash
9. Conclusion
1 Qu'est-ce que les scripts bash?
Un script est quelque chose qui indique au système quel fonctionnement spécifique il devrait effectuer. De même, Bash Scripts Commandez Bash Shell que ce qu'il devrait faire. Un fichier texte simple transportant les chaînes des commandes bash s'appelle un fichier de script bash. Bash Script exécute les commandes de la même manière que le shell s'exécute, mais vous pouvez appliquer des opérations logiques pour effectuer une fonction spécifique. Le langage de programmation utilisé dans Bash est appelé langage de programmation bash.
Le langage de programmation bash est similaire à tout autre langage de programmation où vous pouvez attribuer des variables, appliquer des instructions conditionnelles, des boucles et des tableaux. Vous pouvez effectuer n'importe quelle tâche, du niveau de base aux programmes complexes avec des centaines d'instructions dans les scripts bash. Pour comprendre les scripts bash, créons un simple Script helloworld:
#! / bac / bash
Echo "Bienvenue à Bash Scripting"
Dans le script ci-dessus, "#!" est connu comme "case" ou "hashbang," et "/ bac / bash"Est le chemin vers l'interprète. Le "écho»La commande affiche la sortie à l'écran; Le script ci-dessus imprime une chaîne. Le script bash peut être écrit dans n'importe quel éditeur; Linux est livré avec des éditeurs par défaut tels que nano, vim, etc. Après avoir tapé le script, enregistrez le fichier avec le ".shot»Extension, E.g., "Bonjour le monde.shot". Pour exécuter un script bash dans CLI, utilisez le «frapper" commande:
$ bash helloworld.shot
La commande ci-dessus exécute le script bash et imprime la chaîne comme indiqué dans l'image de sortie. De même, vous pouvez effectuer n'importe quelle opération logique en utilisant des instructions conditionnelles ou exécuter des instructions à plusieurs reprises; Les boucles peuvent être implémentées. Cet article concerne les boucles de bash. Les boucles sont utilisées pour exécuter certaines lignes de code particulières à plusieurs reprises. Le segment suivant couvrira soigneusement les boucles bash:
2 Quelles sont les boucles de bash?
Les boucles sont l'une des structures de programmation fondamentales utilisées pour exécuter une séquence d'instructions à plusieurs reprises jusqu'à ce qu'une condition spécifique soit remplie. Les programmeurs utilisent des boucles de diverses manières, telles que l'itération des valeurs d'un tableau, la répétition des fonctions, l'ajout de nombres et la création de compteurs.
La boucle vérifie un ensemble d'instructions dans le corps de la boucle jusqu'à ce que la condition de boucle soit satisfaite, comme démontré dans l'image ci-dessus.
3 Applications des boucles dans la programmation:
Des boucles peuvent être utilisées à de nombreuses fins de programmation, l'utilisation principale des boucles est mentionnée ci-dessous:
- Dans les algorithmes pour rechercher des informations spécifiques
- Dans le jeu pour créer des boucles de jeu
- Création de compteurs qui peuvent être utiles pour l'automatisation
- Pour répéter des fonctions spécifiques
- Résoudre des problèmes mathématiques complexes
Les boucles sont également utiles pour parcourir les tableaux.
4 Avantages des boucles dans la programmation:
Les boucles en programmation présentent divers avantages:
- Les boucles peuvent effectuer une tâche à plusieurs reprises sans faire d'erreurs (en supposant que les instructions sont correctes)
- Les boucles permettent d'effectuer un certain nombre d'instructions à plusieurs reprises
- Les boucles simplifient les codes complexes et les rendent efficaces
- Ils empêchent d'écrire le même code encore et encore
- Les boucles peuvent également être utilisées dans la structure de données pour itérer à travers les tableaux
5 types de boucles en bash:
Dans Bash, il existe trois types de boucle principale:
- : Pour Loop
- : Pendant la boucle
- : Jusqu'à boucle
1 bash pour la syntaxe de boucle:
Le bas de base pour la boucle itère via la liste des éléments et exécute les instructions ou les commandes mentionnées dans le corps de la boucle.
La syntaxe de bash pour la boucle est:
pour l'élément dans [Liste]
faire
[Commandes]
fait
La liste peut être un tableau, une séquence de nombres ou de chaînes, ou la sortie d'une commande. Le bash pour la boucle de base peut également être attribué à l'aide de la structure du langage C:
pour ((initialisation; condition; incrément))
faire
[Commandes]
fait
Le "initialisation"Ne fonctionne qu'une seule fois, puis"condition" est vérifié. Si c'est vrai, les commandes du corps s'exécuteront et continueront à s'exécuter jusqu'à ce que la condition l'évalue comme fausse.
2 bash While While Loop Syntaxe:
La boucle Bash While exécute l'ensemble des instructions ou des commandes spécifiques un nombre inconnu de fois jusqu'à la condition spécifiée marquée comme fausse:
tandis que [condition]
faire
[Commandes]
fait
La condition est évaluée avant l'exécution de la commande. Si la condition est vraie, la commande s'exécutera; Si la condition devient fausse, la boucle sera terminée.
3 bash jusqu'à la syntaxe de boucle:
Le bash jusqu'à la boucle exécute l'ensemble des instructions ou commande un nombre infini de fois jusqu'à ce que la condition spécifiée soit marquée comme vraie:
Jusqu'à [condition]
faire
[Commandes]
fait
Semblable à la boucle while, la condition est vérifiée avant l'exécution de la commande; Si la condition est fausse, l'ensemble des instructions exécutera. Si la condition devient vraie, la boucle se terminera.
Utilisation de boucles en bash:
Comme mentionné ci-dessus, Bash a trois principaux types de boucles, et l'utilisation de chaque type dépend de la tâche qu'un utilisateur souhaite effectuer. Plongeons dans les détails de la façon dont divers types de boucles sont attribués et manipulés dans Bash.
1 implémentation de la boucle pour bash:
La section suivante se concentre sur la façon de mettre en œuvre Bash pour les boucles dans les scripts bash. In bash for Loop est utilisé pour passer en revue une liste d'objets,
1.1 bash pour la boucle itérant à travers une liste de chaînes:
Le bas de base pour la boucle passe en revue une liste d'éléments, un tableau ou peut être utilisé pour exécuter un ensemble d'instructions dans le corps de la boucle à plusieurs reprises. L'exemple suivant est une implémentation de For Loop qui passe en revue une liste d'éléments de chaîne:
#! / bac / bash
Pour les articles du samedi dimanche lundi mardi mercredi
faire
Echo "L'article dans la liste est:" $ articles
fait
1.2 bash pour la boucle itérant via une liste de nombres:
Pour itérer dans la liste des nombres:
#! / bac / bash
pour les articles en 1 2 3 4 5
faire
Echo "L'article dans la liste est:" $ articles
fait
1.3 bash pour la boucle itérant à travers une gamme d'articles:
En bash, l'expression de séquence est utilisée pour imprimer une séquence de nombres. L'expression de séquence prend également en charge la plage. La boucle pour peut également être appliquée pour passer en revue la plage d'expression de séquence. Par exemple:
#! / bac / bash
pour les éléments de 1… 5
faire
Echo "L'article dans la liste est:" $ articles
fait
L'expression "1… 5«Est une représentation des nombres de 1 à 5. La séquence peut également être définie avec un incrément spécifique, l'expression à suivre serait «Start… fin… incrément»:
#! / bac / bash
pour les éléments de 1… 10… 2
faire
Echo "L'article dans la liste est:" $ articles
fait
1.4 bash pour la boucle itérant dans un tableau:
Les boucles sont couramment utilisées pour itérer par un tableau. Comprenons-le à travers un exemple:
#! / bac / bash
my_array = (Jan février mars avr mai juin)
pour les éléments de $ my_array [@]
faire
Echo "Articles dans le tableau:" $ articles
fait
1.5 bash pour boucle en C comme la syntaxe:
Comme mentionné ci-dessus, le bash prend également en charge la boucle dans le style de langue C. L'exemple suivant montre comment utiliser le style C pour la boucle utilisée dans Bash:
#! / bac / bash
pour ((articles = 1; articles<=10 ; i++))
faire
Echo "Numéro:" $ articles
fait
La structure de boucle de style C est largement utilisée, facile à retenir et à mettre en œuvre. Étant donné que de nombreux langages de programmation modernes prennent en charge la syntaxe de boucle similaire, la structure de boucle ci-dessus imprimera les nombres de 1 à 10.
1.6 bash pour boucle infinie boucle:
La boucle infinie a diverses utilisations dans la programmation. L'exemple suivant montre la mise en œuvre d'une boucle infinie à l'aide de bash pour la boucle:
#! / bac / bash
comte = 0
pour (( ; ; ))
faire
sommeil 2
Echo $ Count
Echo "Appuyez sur Ctrl + C pour arrêter l'exécution du code"
((count ++))
fait
1.7 Bash imbriqué pour la boucle:
Les boucles imbriquées signifient la structure de boucle dans une autre structure de boucle; La première boucle sera appelée la boucle extérieure, tandis que la boucle à l'intérieur de la boucle extérieure sera appelée la boucle intérieure. Chaque itération de la boucle extérieure exécutera toutes les itérations de la boucle intérieure. La boucle pour bash peut également être mise en œuvre dans le format imbriqué:
#! / bac / bash
pour les articles1 en Jan février mars
faire
pour les articles2 en avril mai juin
faire
Echo "$ items1: $ items2"
fait
fait
2 Mise en œuvre de la boucle While dans Bash:
La principale différence entre bash pour la boucle et tandis que la boucle est que tandis que la boucle est utilisée lorsque le nombre d'intégrations est inconnu. Apprenons comment la boucle est attribuée et implémentée dans les scripts bash:
2.1 bash while en boucle pour imprimer les numéros:
L'exemple suivant affichera des numéros de 1 à 10:
#! / bac / bash
x = 0
tandis que [$ x -le 10]
faire
Echo "Les chiffres sont:" $ x
((x ++))
fait
2.2 bash infinis while while:
La boucle infinie s'exécute en continu et ne se termine jamais. Infinite Loop est utilisé pour vérifier les entrées des utilisateurs et répondre en conséquence. L'exemple le plus courant est la boucle de jeu, où un joueur contrôle un personnage et les boucles impriment la réponse de chaque mouvement:
#! / bac / bash
comte = 0
alors que :
faire
sommeil 2
Echo "Counter =" $ COUNT
Echo "Appuyez sur Ctrl + C pour arrêter l'exécution du code"
((count ++))
fait
Le code ci-dessus imprimera la valeur de comptoir et «Bonjour ! Appuyez sur Ctrl + C pour quitter la boucle infinie »après 1 seconde et l'imprimez à plusieurs reprises chaque seconde. La commande «Sleep» ajoute un retard à l'exécution du programme. Le côlon «:» après «while» est le commandement nul. L'autre façon d'attribuer une boucle infinie:
#! / bac / bash
comte = 0
Bien que vrai
faire
sommeil 2
Echo "Counter =" $ COUNT
Echo "Appuyez sur Ctrl + C pour arrêter l'exécution du code"
((count ++))
fait
2.3 bash pendant la boucle avec plusieurs conditions:
L'exemple suivant est de montrer comment plusieurs conditions sont utilisées avec Bash pendant la boucle:
#! / bac / bash
num1 = 1
num2 = 5
tandis que [[$ num1 -lt $ num2 || $ num1 == $ num2]]
faire
Echo "Le nombre est:" $ num1
((num1 ++))
fait
Echo "fait !"
On peut voir que pendant que Loop évalue deux conditions avec ou opérateur «||». Ou l'opérateur est un opérateur booléen qui sort vrai si l'une des conditions est vraie.
3 Mise en œuvre de la boucle jusqu'à Bash:
La boucle de fer est similaire à la boucle while, mais il boucle jusqu'à la condition spécifiée l'évaluation comme vraie. Comprenons comment mettre en œuvre jusqu'à la boucle en bash:
3.1 bash jusqu'à la boucle pour imprimer les numéros:
L'exemple suivant de jusqu'à la boucle imprime les nombres dans la sortie de 0 à 10:
#! / bac / bash
x = 0
Jusqu'à [$ x -gt 10]
faire
Echo "Les chiffres sont:" $ x
((x ++))
fait
3.2 bash infini jusqu'à boucle en bash:
La boucle infinie à l'aide de l'opérateur de boucle jusqu'à ce que l'opérateur de boucle est mentionné ci-dessous:
#! / bac / bash
x = 0
jusqu'à faux
faire
Echo "Counter:" $ x
((x ++))
sommeil 1
Echo "Appuyez sur Ctrl + C pour terminer la boucle"
fait
Instructions de contrôle de boucle:
Les boucles sont conçues pour boucler en continu jusqu'à ce qu'une condition spécifique soit remplie, mais il y a des déclarations à travers lesquelles le flux de boucle peut être contrôlé.
- La déclaration de pause
- La déclaration continue
1 La déclaration de pause:
Le mot-clé Break termine la boucle, quel que soit le type de construction de boucle, et exécute l'instruction du code en dehors du corps de la boucle:
Comprenons la déclaration de rupture à travers un exemple de bash:
#! / bac / bash
pour les articles en janvier février mars avril mai juin juil
faire
Si [["$ item" == "peut"]]
alors
casser
Fi
Echo "Les articles sont:" $ articles
fait
écho "boucle terminée"
De même, la déclaration de rupture peut également être utilisée dans une boucle de temps:
#! / bac / bash
x = 0
tandis que [$ x -lt 10]
faire
Echo "Le nombre est:" $ x
((x ++))
Si [["$ x" == "7"]]
alors
casser
Fi
fait
écho "boucle terminée"
L'exemple d'une déclaration jusqu'à la pause est mentionné ci-dessous:
#! / bac / bash
x = 0
jusqu'à faux
faire
((x ++))
Si [[$ x -eq 5]]
alors
casser
Fi
Echo "Les valeurs sont:" $ x
fait
écho "boucle terminée"
Lorsque la valeur de l'incrément («x») équivaut à 5, l'instruction BRISE mettra fin à la boucle et les instructions à l'extérieur du corps de la boucle s'exécuteront.
2 La déclaration de poursuite:
L'instruction CONSTERNE termine l'opération actuelle de la boucle, revient à la condition de boucle d'origine et exécute la prochaine itération.
Comprenons l'instruction CONTRÔLE CONTINURE à travers un exemple:
#! / bac / bash
pour les articles en janvier février mars avril mai juin juil
faire
Si [[«$ item» == «May»]]
alors
continuer
Fi
Echo «Article dans la liste:» Articles
fait
La boucle pour itérara la liste des mois et s'arrêtera lorsque la valeur deviendra «peut". Une nouvelle itération commencera et les instructions sous l'instruction Continuer ne s'exécuteront pas. On peut également voir dans l'image de sortie que le «peut"Est absent de la liste parce que l'instruction CONTINUE a ignoré l'exécution de" Echo "lorsque le"articles"La variable devient égale au"peut" chaîne.
Comme pour la boucle le "continuer»L'instruction peut également être mise en œuvre dans une boucle de temps:
#! / bac / bash
x = 0
tandis que [$ x -lt 10]
faire
((x ++))
Si [["$ x" -lt "5"]]
alors
continuer
Fi
Echo «Le nombre est:» $ x
fait
Le code ci-dessus imprimera les numéros de 1 à 10 et sautera 5, comme démontré dans l'image de sortie. Un exemple de mise en œuvre de «continuer»Déclaration avec la boucle jusqu'à ce que la boucle soit mentionnée ci-dessous:
#! / bac / bash
x = 0
Jusqu'à [$ x == 10]
faire
((x ++))
Si [[$ x -eq 5]]
alors
continuer
Fi
Echo «Le numéro est:» $ x
fait
Exemples de boucles bash:
Les structures en boucle ont diverses implémentations dans Bash. Cette section se concentrera sur des exemples de bash plus avancés où des boucles sont implémentées.
1 Exemple 1: Modification de l'extension des fichiers à l'aide de boucles bash:
L'exemple suivant est de prendre l'extension de fichier de l'utilisateur; Le script collectera tous les fichiers de l'extension donnés par l'utilisateur et les enregistrera dans un fichier "file_list". La boucle pour passe en revue la liste des fichiers. Tandis que le "CP«La commande créera la copie du fichier avec le«.bak»Extension dans le répertoire actuel.
#! / bac / bash
Echo "Entrez l'extension de fichier"
Lire Ext
Echo "Entrez l'extension de conversion"
Lire Cov
LS *.Fichiers $ ext>
pour i dans «Fichiers de chat»
faire
cp "$ i" "$ i".$ Cov
fait
Améliorons le code ci-dessus:
#! / bac / bash
Echo "Entrez le nom du répertoire"
lire Dir
Echo "Entrez l'extension du nom de fichier à convertir"
Lire F_EXT
Echo "Entrez l'extension de fichier à convertir"
Lire Cov
pour le fichier dans $ dir / * $ f_ext
faire
mv - "$ file" "$ file% $ f_ext $ cov"
fait
Maintenant, le code prend le nom du répertoire qui contient le fichier, les extensions de nom de fichier à convertir et le nom d'extension pour convertir les fichiers dans le répertoire. Un utilisateur peut obtenir n'importe quel fichier et convertir ces fichiers en extension souhaitée.
2 Exemple 2: Modification des noms de fichiers à l'aide de boucles bash:
L'espace dans les fichiers ou le répertoire peut créer des problèmes lors de l'exécution de commandes contenant des chemins. L'interface de ligne de commande ne reconnaît pas l'espace dans le nom des fichiers ou des dossiers, comme démontré dans l'image suivante:
Vous devez soit utiliser des citations ou des séquences d'échappement. Mais heureusement, nous pouvons créer un script bash qui peut ajouter de soulignement "_" ou Dash "-" pour remplir l'espace des noms de fichiers et répertoires.
#! / bac / bash
Echo "Entrez le nom du dossier"
le dossier de lecture
dossier cd $
pour les fichiers dans * \ *
faire
mv "$ files" "$ fichiers // / _"
fait
Le code ci-dessus prend le nom du dossier en entrée qui est «mon dossier», Et il contient les fichiers avec l'espace dans leur nom comme démontré dans l'image de sortie ci-dessus. Le script remplacera l'espace par soulignement "_"Dans les noms de fichiers présents dans le répertoire mentionné par l'utilisateur.
3 Exemple 3: Lire un fichier à l'aide de boucles de bash:
Un fichier peut également être lu à l'aide de la structure de boucle:
#! / bac / bash
Echo "Entrez le nom du fichier"
Lire le fichier
Bien que vrai
lire -r l
faire
Echo $ l
fait < "$file"
Le code ci-dessus prend le nom du fichier texte comme entrée de l'utilisateur et imprime son contenu.
4 Exemple 4: trouver un fichier à l'aide de boucles bash:
L'exemple suivant trouve les fichiers par l'extension que l'utilisateur donne:
#! / bac / bash
Echo "Entrez l'extension du nom de fichier"
Lire Ext
Ifs = $ '\ n'
pour le fichier dans $ (find -name "* $ ext")
faire
Fichier Echo $
fait
insensé IFS
L'IFS est une variable de coquille spéciale, un séparateur de champ interne utilisé pour trouver des limites de mots. Un utilisateur peut mentionner n'importe quelle extension de type de fichier tel que «.SMS", ".sh », ou«.png », le code trouvera tous les fichiers de cette extension et les affichera dans le terminal.
5 Exemple 5: Création d'un compteur simple à l'aide de boucles bash:
Cet exemple comptera à partir d'un nombre entré par l'utilisateur:
#! / bac / bash
Echo "Entrez un numéro"
lire le compteur
tandis que [$ compteur -gt 0]
faire
sommeil 1
Echo $ compteur
((comptoir--))
fait
écho "fait"
Le code ci-dessus obtient un numéro de l'utilisateur, et le compteur baisse de l'un à chaque seconde.
6 Exemple 6: Vérification de la connexion Internet à l'aide de boucles bash:
La structure de boucle peut également être utilisée pour vérifier la connexion Internet à l'aide du «ping-ping" commande:
#! / bac / bash
compteur = 5
tandis que [[$ compteur -ne 0]]
faire
ping -c 2 www.Google.com
chèque = $?
Si [[$ chèque -eq 0]]
alors
écho "___________________"
Echo "Internet fonctionne"
écho "___________________"
sortie 0
Fi
((comptoir--))
fait
écho "________________"
Echo "Internet est en panne"
écho "________________"
Le code ci-dessus sera un ping pour vérifier l'état du site Web de Google. Le "-c»Le drapeau est utilisé pour compter. La valeur de l'option "-c"Est 2, ce qui signifie le"ping-ping»Enverra les demandes deux fois. Si le code de sortie "$?"Est 0, la commande ping obtient une reconnaissance et Internet fonctionne. Le ping vérifiera le statut cinq fois. S'il n'obtient aucune reconnaissance, le «Internet est en panne»L'erreur sera affichée.
7 Exemple 7: Une calculatrice simple avec boucles bash:
L'exemple suivant consiste à prendre deux numéros de l'utilisateur et à demander à l'opération d'effectuer. Le script de bash suivant effectue l'addition, la soustraction, la multiplication et la division:
#! / bac / bash
Echo "Entrez le numéro 1"
Lire Num1
Echo "Entrez le numéro 2"
lire num2
Bien que vrai
faire
Echo "Sélectionnez le numéro d'opération"
Echo "1 somme +: 2 différence -: 3 Multiplication *: 4 Division \: 5 Quit"
operatrice de lecture
Si [["$ opérateur" -eq "1"]]
alors
((sortie = num1 + num2))
elif [["$ opérateur" -eq "2"]]
alors
((sortie = num1-num2))
elif [["$ opérateur" -eq "3"]]
alors
((sortie = num1 * num2))
elif [["$ opérateur" -eq "4"]]
alors
((sortie = num1 / num2))
elif [["opérateur" -eq "5"]]
alors
sortie 0
Fi
Echo "Le résultat est" $ la sortie
fait
La calculatrice continuera d'exécuter des fonctions jusqu'à ce que l'utilisateur donne à la commande de mettre fin à l'infini pendant la boucle.
8 Exemple 8: Recherche de moyenne à l'aide de boucles bash:
L'exemple suivant prendra les nombres en entrée de l'utilisateur et calculera la moyenne:
#!/ bac / bash
tandis que c'est vrai; faire
Echo -N "Entrez un nombre de 0 à 100 et appuyez sur A / A pour obtenir la moyenne:"
lire e_num
if (("$ e_num" "100"))
alors
écho " !Entrée invalide! Entrez le numéro de 0 à 100 "
elif (("$ e_num" == "a")) || (("$ e_num" == "a"))
alors
Echo "La moyenne est: $ avg%"
casser
autre
sum = $ [$ sum + $ e_num]
num = $ [$ num + 1]
avg = $ [$ sum / $ num]
Fi
fait
Le code ci-dessus obtient des numéros de l'utilisateur de 0 à 100. Si le numéro entré n'est pas 0 ou supérieur à 100, l'utilisateur recevra un message d'erreur en entrant le numéro souhaité. Presse A / A Pour obtenir la moyenne dans la sortie.
Conclusion:
Les constructions de boucle sont les constructions clés de la programmation et sont assez pratiques pour les programmeurs, en particulier pour automatiser les opérations répétitives. Des boucles sont utilisées pour exécuter des instructions à plusieurs reprises jusqu'à ce que la boucle évalue une instruction de test particulière. Les boucles ont diverses utilisations dans la programmation, comme la création d'algorithmes, l'automatisation, la création de boucles de jeu, etc. Bash propose trois types de structures en boucle: pour la boucle, pendant la boucle et jusqu'à la boucle. L'approche contrôlée peut également classer les boucles; tandis que les boucles et jusqu'à ce que les boucles soient contrôlées les boucles car la condition de test est vérifiée avant que les instructions en boucle ne soient exécutées. Le bash pour la boucle peut être initialisé de deux manières distinctes, au format bash typique et à la syntaxe du langage C. Basic for Loop est simplement utilisé pour parcourir la liste des éléments ou des tableaux. Dans l'implémentation pour la boucle pour, nous connaissons déjà le nombre d'itération, tandis que les boucles sont utilisées lorsque le nombre d'itérations est inconnu. La boucle while continue de boucler tant que l'instruction de vérification définie est vraie. Il est important de noter que si aucune condition n'est spécifiée, la boucle sera appelée boucle infinie. La boucle infinie continue d'exécuter les instructions en boucle tant qu'elle n'est pas interrompue.
Vient ensuite les déclarations contrôlées par la boucle, la pause et la déclaration de poursuite. L'instruction Break est utilisée pour terminer la boucle et exécute les instructions à l'extérieur du corps de la boucle. Cependant, l'instruction CONSTANT fonctionne de la manière opposée à l'instruction BREAK. Au lieu de mettre fin à la boucle, l'instruction CONSTANT force la boucle pour la nouvelle itération et saute les instructions restantes du corps de la boucle.
Toutes les structures de boucle bash peuvent également être utilisées de manière imbriquée. Les boucles imbriquées signifient des boucles à l'intérieur d'autres boucles, et elles sont extrêmement utiles pour itération de deux tableaux différents. La dernière section de la rédaction couvre quelques exemples de base et avancés de la mise en œuvre des boucles bash, bien qu'il existe des tonnes de façons d'utiliser des boucles bash dans les scripts bash.
Les boucles sont une structure de programmation convaincante et contiennent divers avantages; Ils simplifient les codes complexes et les rendent plus efficaces. Si vous souhaitez exécuter des commandes spécifiques, vous n'avez pas besoin de les taper; Les boucles sont conçues pour effectuer de telles tâches.