Dans cette section, vous découvrirez les boucles for, while et until. Pourquoi la boucle for ne s'exécute-t-elle pas dans la boucle bash de sortie du répertoire For

Cycle pour légèrement différent des analogues dans d'autres langages de programmation. Tout d'abord, il vous offre la possibilité d'effectuer des actions séquentielles sur des "mots" dans une chaîne.

Cycle tandis que exécute un morceau de code si l'expression de test est vraie ; et s'arrête s'il est faux (ou si une rupture de boucle explicitement spécifiée se produit à l'intérieur du code exécutable).

Cycle jusqu'à est presque identique à une boucle while. La seule différence est que le code est exécuté si l'expression testée est fausse.

Si vous supposez que while et until sont très similaires, vous avez raison.

7.1 Exemple de boucle

#! / bin / bash pour i dans $ (ls); faire écho à l'élément : $ j'ai fait

Sur la deuxième ligne, nous représentons i comme une variable qui reçoit les différentes valeurs contenues dans $(ls).

La troisième ligne pourrait être plus longue si nécessaire; ou il pourrait y avoir plusieurs lignes avant de terminer (4e ligne).

"done" (4ème ligne) indique que le code qui utilise la valeur de $ i se termine et que $ i obtient une nouvelle valeur.

Ce script a peu d'importance. Une utilisation plus utile de la boucle for serait de l'utiliser pour sélectionner uniquement des fichiers spécifiques dans l'exemple précédent.

7.2 C-like pour

fiesh a suggéré d'ajouter cette forme de boucle. Il s'agit d'une boucle for, très similaire à for en C, Perl, etc.

#! / bin / bash pour i dans `seq 1 10`; faire echo $ j'ai fait

7.3 Un exemple de boucle while :

#! / bin / bash COUNTER = 0 while [$ COUNTER -lt 10]; do echo Le compteur est $ COUNTER let COUNTER = COUNTER + 1 done

Ce script "émule" la structure bien connue (en C, Pascal, perl, etc.) "for".

Un bref résumé de la différence entre les types de cycles :

for - effectuera une action tant qu'il y a des objets à exécuter (par exemple, lire un flux à partir de stdin, d'un fichier ou d'une fonction) ;
while - effectue l'action jusqu'à ce que état est vrai;
jusqu'à - sera exécuté jusqu'à état ne deviendra pas vrai, c'est-à-dire alors que c'est faux.

boucle FOR

Considérez cette version d'un script avec une boucle :

$ cat loop.sh #! / bin / bash pour la variable dans `ls -1` do echo" $ variable "done

La syntaxe est très simple et est montrée assez clairement dans l'exemple :

for (démarrer la boucle) variable (déclarer la variable sur laquelle exécuter) in (envoyer le flux à la boucle) `ls -1` (la commande qui doit être exécutée et passée à la variable $ variable). Do et done sont le "corps" de la boucle, dans lequel les principales actions seront effectuées sur les données reçues, et echo "$ variable" est l'action réelle effectuée par la boucle.

Maintenant, nous allons légèrement modifier l'exemple, et au lieu de spécifier explicitement la commande, nous appliquerons la deuxième variable :

$ cat loop.sh #! / bin / bash ls = `ls -1` pour la variable dans $ ls do echo" $ variable "done

Maintenant, la commande ls -1 est passée dans une variable distincte, ce qui permet plus de flexibilité dans le travail avec la boucle. Au lieu d'une variable dans une boucle, vous pouvez également utiliser une fonction :

$ cat loop.sh #! / bin / bash lsl () (ls -1) pour la variable dans `lsl` do echo" $ variable "done

La condition principale de la boucle for est qu'elle sera exécutée tant que la commande qui lui est transmise contient des objets pour l'action. Sur la base de l'exemple ci-dessus - tant qu'il y a des fichiers à afficher dans la liste ls -1 - la boucle les passera dans une variable et exécutera le "corps de la boucle". Dès que la liste des fichiers du répertoire se termine, la boucle terminera son exécution.

Compliquons un peu l'exemple.

Le répertoire contient une liste de fichiers :

$ ls -1 fichier1 fichier2 fichier3 fichier4 fichier5 loop.sh nofile1 nofile2 nofile3 nofile4 nofile5

Nous devons choisir parmi eux uniquement ceux qui n'ont pas le mot " non«:

$ cat loop.sh #! / bin / bash lsl = `ls -1` pour la variable dans $ lsl do echo" $ variable "| grep -v "no" done $ ./loop.sh fichier1 fichier2 fichier3 fichier4 fichier5 boucle.sh

Dans la boucle, vous pouvez également utiliser des expressions conditionnelles ( expressions conditionnelles) […] Pour vérifier les conditions et une instruction break pour interrompre la boucle si la condition est déclenchée.

Considérez cet exemple :

$ cat loop.sh #! / bin / bash lsl = `ls -1` pour la variable dans $ lsl do if [$ variable! =" loop.sh "] then echo" $ variable " | grep -v "no" else break fi fait

La boucle continuera jusqu'à ce que le fichier loop.sh soit rencontré. Dès que l'exécution de la boucle atteint ce fichier, la boucle sera interrompue par la commande break :

$ ./loop.sh fichier1 fichier2 fichier3 fichier4 fichier5

Un autre exemple consiste à utiliser des opérations arithmétiques juste avant d'exécuter le corps de la boucle :

$ cat loop.sh #! / bin / bash for ((count = 1; count<11; count++)) do echo "$count" done

Ici, nous définissons trois commandes de contrôle - count = 1, condition de contrôle - tandis que count est inférieur à 11, et la commande à exécuter - count +1 :

Boucles WHILE et UNTIL

Un exemple simple qui montre bien comment fonctionne la boucle while :

$ cat loop.sh #! / bin / bash count = 0 while [$ count -lt 10] do ((count ++)) echo $ count done

Nous définissons la variable $ count à zéro, puis nous commençons la boucle whi le avec la condition « tant que $ count est inférieur à dix, exécutez la boucle ». Dans le corps de la boucle, nous exécutons incrément de suffixe+1 à la variable $ count et imprime le résultat sur stdout.

Résultat d'exécution :

$ ./boucle.sh 1 2 3 4 5 6 7 8 9 10

Dès que la valeur de la variable $ count est devenue 10, la boucle s'est terminée.

Un bon exemple de boucle "infinie" qui montre le fonctionnement de while :

$ cat loop.sh #! / bin / bash count = 10 while [1 = 1] do ((count ++)) echo $ count done $ ./loop.sh ... 5378 5379 5380 5381 5382 5383 ^ C

La boucle jusqu'à fonctionne de la même manière, mais "en sens inverse":

$ cat loop.sh #! / bin / bash count = 0 jusqu'à ce que [$ count -gt 10] do ((count ++)) echo $ count done

Ici, nous définissons une condition similaire, mais au lieu de « tant que la variable est inférieure à 10 » - nous indiquons « jusqu'à ce que la variable devienne supérieure à 10 ». Résultat d'exécution :

$ ./boucle.sh 1 2 3 4 5 6 7 8 9 10 11

Si l'exemple ci-dessus d'une "boucle infinie" est exécuté en utilisant jusqu'à - o ne sortira rien, contrairement à while :

$ cat loop.sh #! / bin / bash count = 10 jusqu'à ce que [1 = 1] do ((count ++)) echo $ count done $ ./loop.sh $

Parce que " état"Initialement" en vérité"- le corps de la boucle ne sera pas exécuté.

Comme dans une boucle for, les fonctions peuvent être utilisées pendant et jusqu'à. Par exemple, une boucle d'un script du monde réel qui vérifie l'état du serveur Matou(PID est pris dans le système SLES, peut différer sur d'autres systèmes), une version légèrement simplifiée :

$ cat loop.sh #! / bin / bash check_tomcat_status () (RUN = `ps aux | grep tomcat | grep -v grep | grep java | awk" (print $ 2) "`) while check_tomcat_status do if [-n " $ RUN "] then printf" ATTENTION : Tomcat fonctionne toujours avec PID $ RUN. " else printf "Tomcat arrêté, en cours ... nn" pause fi fait

Résultat d'exécution :

$ ./loop.sh AVERTISSEMENT : Tomcat toujours en cours d'exécution avec le PID 14435 26548.AVERTISSEMENT : Tomcat toujours en cours d'exécution avec le PID 14435 26548.AVERTISSEMENT : Tomcat toujours en cours d'exécution avec le PID 14435 26548.AVERTISSEMENT : Tomcat toujours en cours d'exécution avec le PID 14435 26548.AVERTISSEMENT : Tomcat toujours en cours d'exécution avec le PID 14435 26548.AVERTISSEMENT : Tomcat toujours en cours d'exécution avec le PID 14435 26548.AVERTISSEMENT : Tomcat toujours en cours d'exécution avec le PID 14435 26548.AVERTISSEMENT : Tomcat toujours en cours d'exécution avec le PID 14435

Version complète:

Check_tomcat_status () (RUN = `ps aux | grep tomcat | grep -v grep | grep java | awk" (print $ 2) "`) while check_tomcat_status; do if [-n "$ RUN"] then printf "AVERTISSEMENT : Tomcat toujours en cours d'exécution avec PID $ RUN. Arrêtez-le ?" answer "Arrêter Tomcat ..." "Poursuivre l'installation ..." && $ CATALINA_HOME / bin / shutdown. sh 2 &> 1 / dev / null || break sleep 2 if [-n "$ RUN"] then printf " Tomcat toujours en cours d'exécution. Tuez-le ? " réponse " Killing Tomcat ... " " En cours d'installation ... n " && kill $ RUN || break sleep 2 fi else printf "Tomcat arrêté, en cours ... nn" break fi done

La fonction de réponse a été décrite dans l'article, mais ici une version légèrement améliorée est utilisée :

Answer () (lors de la lecture de la réponse; faire echo case $ réponse dans |) printf "$ 1n" return 0 break ;; |) printf "$ 2n" return 1 break ;; *) printf "S'il vous plaît, entrez O (oui) ou N (non)!" esac done)

Ici, vous pouvez utiliser à la fois while et until - mais pas une boucle for, car for aurait fonctionné une fois (obtenu le PID et terminé).

Le shell bash prend en charge les boucles, qui vous permettent d'itérer sur des séquences de valeurs. Voici la structure de base de telles boucles :

Pour var dans la liste, les commandes sont-elles effectuées
À chaque itération de la boucle, la valeur suivante de la liste sera écrite dans la variable var. Dans le premier passage de la boucle, par conséquent, la première valeur de la liste sera utilisée. Dans le second - le second, et ainsi de suite - jusqu'à ce que le cycle atteigne le dernier élément.

Itérer sur des valeurs simples

L'exemple le plus simple de boucle for dans les scripts bash est peut-être l'itération sur une liste de valeurs simples :

#! / bin / bash pour var dans le premier deuxième troisième quatrième cinquième do echo L'élément $ var fait
Les résultats de ce script sont indiqués ci-dessous. On voit clairement que les éléments de la liste sont entrés séquentiellement dans la variable $ var. Cela se produit jusqu'à ce que le cycle atteigne le dernier d'entre eux.


Boucle simple pour

Veuillez noter que la variable $ var conserve sa valeur à la sortie de la boucle, son contenu peut être modifié, en général, vous pouvez travailler avec elle comme avec n'importe quelle autre variable.

Itérer sur des valeurs complexes

La liste utilisée pour initialiser la boucle for peut contenir non seulement des chaînes simples constituées d'un mot, mais également des phrases entières, qui incluent plusieurs mots et signes de ponctuation. Par exemple, tout pourrait ressembler à ceci :

#! / bin / bash pour var dans le premier "le deuxième" "le troisième" "Je vais le faire" do echo "C'est : $ var" done
C'est ce qui se passe après que cette boucle parcourt la liste. Comme vous pouvez le voir, le résultat est tout à fait attendu.


Itérer sur des valeurs complexes
TNW-CUS-FMP - un code promo pour une remise de 10% sur nos services, disponible pour activation dans les 7 jours "

Initialisation de la boucle avec une liste obtenue à partir des résultats de la commande

Une autre façon d'initialiser une boucle for est de lui passer une liste, qui est le résultat d'une commande. C'est là que la substitution de commandes est utilisée pour les exécuter et obtenir les résultats de leur travail.

#! / bin / bash file = "myfile" for var in $ (cat $ file) do echo "$ var" done
Cet exemple utilise la commande cat pour lire le contenu d'un fichier. La liste de valeurs résultante est transmise à la boucle et affichée. Veuillez noter que le fichier auquel nous faisons référence contient une liste de mots séparés par des caractères de saut de ligne, aucun espace n'est utilisé.


Boucle qui parcourt le contenu du fichier

Il faut tenir compte du fait qu'une telle approche, si un traitement de données ligne par ligne est prévu, ne fonctionnera pas pour un fichier de structure plus complexe, dont les lignes peuvent contenir plusieurs mots séparés par des espaces. La boucle traitera des mots individuels, pas des lignes.

Et si ce n'était pas du tout ce que vous vouliez ?

Séparateurs de champs

La raison de la particularité ci-dessus réside dans une variable d'environnement spéciale appelée IFS (Internal Field Separator) qui vous permet de spécifier des séparateurs de champs. Par défaut, bash traite les caractères suivants comme délimiteurs de champ :
  • Espacer
  • Caractère de tabulation
  • Caractère de saut de ligne
Si bash rencontre l'un de ces caractères dans les données, il suppose que la prochaine valeur indépendante de la liste est devant lui.

Afin de résoudre le problème, vous pouvez modifier temporairement la variable d'environnement IFS. Voici comment procéder dans un script bash, en supposant que vous n'avez besoin que d'un saut de ligne comme séparateur de champ :

IFS = $ "\ n"
Après avoir ajouté cette commande à un script bash, cela fonctionnera comme prévu, en ignorant les espaces et les tabulations et en traitant uniquement les sauts de ligne comme délimiteurs de champ.

#! / bin / bash file = "/ etc / passwd" IFS = $ "\ n" for var in $ (cat $ file) do echo "$ var" done
Si vous exécutez ce script, il affichera exactement ce qui lui est demandé, donnant, à chaque itération de la boucle, accès à la ligne suivante écrite dans le fichier.


Parcourir un fichier ligne par ligne dans une boucle for

D'autres caractères peuvent être utilisés comme délimiteurs. Par exemple, ci-dessus, nous avons affiché le contenu du fichier /etc/passwd. Les données utilisateur dans les chaînes sont séparées par des deux-points. Si vous devez traiter de telles lignes en boucle, IFS peut être configuré comme ceci :

Contourner les fichiers contenus dans un répertoire

L'une des utilisations les plus courantes des boucles for dans les scripts bash consiste à parcourir des fichiers dans un répertoire et à traiter ces fichiers.

Par exemple, voici comment répertorier les fichiers et les dossiers :

#! / bin / bash for file in / home / likegeeks / * do if [-d "$ file"] then echo "$ file is a directory" elif [-f "$ file"] then echo "$ file is a fichier "fi fait
Si vous avez compris à partir de cette série d'articles, vous devez comprendre la structure de la construction if-then, ainsi que la façon de distinguer un fichier d'un dossier. Si vous avez des difficultés à comprendre le code ci-dessus, veuillez relire ce document.

C'est ce que le script affichera.


Sortie du contenu d'un dossier

Remarquez comment nous initialisons la boucle, à savoir le caractère générique "*" à la fin de l'adresse du dossier. Ce symbole peut être considéré comme un modèle, signifiant : "tous les fichiers avec n'importe quel nom". il vous permet d'organiser la substitution automatique des noms de fichiers qui correspondent au modèle.

Lorsque nous testons une condition dans une instruction if, nous mettons le nom de la variable entre guillemets. Ceci est fait car le nom d'un fichier ou d'un dossier peut contenir des espaces.

C-style pour les boucles

Si vous êtes familier avec le langage de programmation C, la syntaxe pour décrire les boucles bash for peut vous sembler étrange, puisque vous êtes évidemment habitué à une telle description de boucles :

Pour (i = 0; je< 10; i++) { printf("number is %d\n", i); }
Dans les scripts bash, vous pouvez utiliser des boucles for, dont la description ressemble beaucoup aux boucles de style C, bien qu'il y ait quelques différences ici. Le diagramme de boucle avec une approche similaire ressemble à ceci :

Pour ((valeur initiale variable ; condition de fin de boucle ; changement de variable))
En bash, cela peut s'écrire comme ceci :

Pour ((a = 1; un< 10; a++))
Et voici un exemple fonctionnel :

#! / bin / bash pour ((i = 1; je<= 10; i++)) do echo "number is $i" done
Ce code imprimera une liste de nombres de 1 à 10.

Boucle de style C

Alors que la boucle

La clause for n'est pas le seul moyen d'organiser les boucles dans les scripts bash. Vous pouvez également utiliser des boucles while ici. Dans une telle boucle, vous pouvez définir une commande pour vérifier une certaine condition et exécuter le corps de la boucle jusqu'à ce que la condition vérifiée renvoie zéro, ou un signal de la réussite d'une certaine opération. Lorsque la condition de boucle renvoie une valeur différente de zéro, ce qui signifie une erreur, la boucle s'arrête.

Voici un diagramme de la façon dont les boucles while sont organisées.
tandis que la commande de vérification des conditions
faire
autres équipes
terminé

Jetons un coup d'œil à un exemple de script avec une telle boucle :

#! / bin / bash var1 = 5 while [$ var1 -gt 0] do echo $ var1 var1 = $ [$ var1 - 1] done
A l'entrée de la boucle, on vérifie si la variable $ var1 est supérieure à zéro. Si c'est le cas, le corps de la boucle est exécuté, dans lequel un est soustrait de la valeur de la variable. Cela se produit à chaque itération, pendant que nous imprimons la valeur de la variable sur la console avant de la modifier. Dès que $ var1 vaut 0, la boucle se termine.

Le résultat de la boucle while

Si vous ne modifiez pas la variable $ var1, cela conduira le script à tomber dans une boucle infinie.

Boucles imbriquées

Toutes les commandes peuvent être utilisées dans le corps de la boucle, y compris le lancement d'autres boucles. De telles constructions sont appelées boucles imbriquées :

#! / bin / bash pour ((a = 1; a<= 3; a++)) do echo "Start $a:" for ((b = 1; b <= 3; b++)) do echo " Inner loop: $b" done done
Vous trouverez ci-dessous ce que ce script affichera. Comme vous pouvez le voir, d'abord, la première itération de la boucle externe est effectuée, puis trois itérations de la boucle interne, après son achèvement, la boucle externe revient en jeu, puis la boucle interne à nouveau.

Boucles imbriquées

Traitement du contenu du fichier

L'utilisation la plus courante des boucles imbriquées est de traiter des fichiers. Ainsi, la boucle externe est occupée à parcourir les lignes du fichier, tandis que la boucle interne fonctionne déjà avec chaque ligne. Par exemple, voici à quoi ressemble le traitement du fichier /etc/passwd :

#! / bin / bash IFS = $ "\ n" pour l'entrée dans $ (cat / etc / passwd) do echo "Values ​​​​in $ entry -" IFS =: pour la valeur dans $ entry do echo "$ value" done terminé
Il y a deux boucles dans ce script. Le premier est bouclé sur les lignes, en utilisant le caractère de saut de ligne comme séparateur. L'interne est occupé à analyser des chaînes, dont les champs sont séparés par des deux-points.

Traitement des données de fichiers

Cette approche peut être utilisée lors du traitement de fichiers CSV, ou de tout fichier similaire, en écrivant un caractère délimiteur dans la variable d'environnement IFS si nécessaire.

Contrôle de cycle

Peut-être qu'après être entré dans la boucle, il sera nécessaire de l'arrêter lorsque la variable de boucle atteint une certaine valeur, qui ne correspond pas à la condition initialement spécifiée pour la fin de la boucle. Faudra-t-il dans une telle situation attendre la fin normale du cycle ? Bien sûr que non, et dans de tels cas, les deux commandes suivantes sont utiles :
  • Pause
  • Continuez

Commande de pause

Cette commande permet d'interrompre l'exécution de la boucle. Il peut être utilisé à la fois pour les boucles for et les boucles while :

#! / bin / bash pour var1 in 1 2 3 4 5 6 7 8 9 10 do if [$ var1 -eq 5] then break fi echo "Number: $ var1" done
Une telle boucle, dans des conditions normales, parcourra toute la liste des valeurs de la liste. Cependant, dans notre cas, son exécution sera interrompue lorsque la variable $ var1 vaut 5.

Quitter la boucle for tôt

Voici la même chose pour la boucle while :

#! / bin / bash var1 = 1 while [$ var1 -lt 10] do if [$ var1 -eq 5] then break fi echo "Iteration: $ var1" var1 = $ (($ var1 + 1)) done
L'instruction break exécutée lorsque la valeur de $ var1 est égale à 5 interrompt la boucle. La console affichera la même chose que dans l'exemple précédent.

Continuer la commande

Lorsque cette commande est rencontrée dans le corps de la boucle, l'itération en cours se termine plus tôt et la suivante commence, et la boucle ne se termine pas. Jetons un coup d'œil à la commande continue dans la boucle for :

#! / bin / bash pour ((var1 = 1; var1< 15; var1++)) do if [ $var1 -gt 5 ] && [ $var1 -lt 10 ] then continue fi echo "Iteration number: $var1" done
Lorsque la condition à l'intérieur de la boucle est remplie, c'est-à-dire lorsque $ var1 est supérieur à 5 et inférieur à 10, le shell exécute la commande continue. Cela conduit à sauter les commandes restantes dans le corps de la boucle et à passer à l'itération suivante.

La commande continue dans une boucle for

Traitement de la sortie exécuté dans une boucle

Les données de sortie de la boucle peuvent être traitées en redirigeant la sortie ou en la redirigeant. Cela se fait en ajoutant des commandes de traitement de sortie après l'instruction done.

Par exemple, au lieu d'afficher à l'écran ce qui est affiché en boucle, vous pouvez tout écrire dans un fichier ou le transférer ailleurs :

#! / bin / bash pour ((a = 1; a< 10; a++)) do echo "Number is $a" done >monfichier.txt echo "terminé".
L'encapsuleur créera le fichier myfile.txt et redirigera la sortie de la construction for vers ce fichier. Ouvrons le fichier et assurez-vous qu'il contient exactement ce qui est attendu.

Rediriger la sortie d'une boucle vers un fichier

Exemple : recherche de fichiers exécutables

Utilisons ce que nous avons couvert jusqu'à présent et écrivons quelque chose d'utile. Par exemple, si vous avez besoin de savoir quels fichiers exécutables sont disponibles sur le système, vous pouvez analyser tous les dossiers écrits dans la variable d'environnement PATH. Nous avons déjà tout l'arsenal d'outils dont nous avons besoin pour cela, il nous suffit de tout assembler :

#! / bin / bash IFS =: pour le dossier dans $ PATH do echo "$ dossier:" pour le fichier dans $ dossier / * do if [-x $ file] then echo "$ file" fi done done
Un tel script, petit et simple, permettait d'obtenir une liste de fichiers exécutables stockés dans des dossiers à partir de PATH.

Rechercher des fichiers exécutables dans les dossiers à partir de la variable PATH

Résultats

Aujourd'hui, nous avons parlé des boucles for et while dans les scripts bash, comment les exécuter, comment les gérer. Maintenant, vous pouvez traiter des chaînes avec différents délimiteurs dans des boucles, vous savez comment rediriger les données de sortie dans des boucles vers des fichiers, comment afficher et analyser le contenu des répertoires.

En supposant que vous soyez un développeur de scripts bash qui ne sache que ce qui est décrit dans cette série d'articles, et dans cette seconde, vous pouvez déjà écrire quelque chose d'utile. A venir la troisième partie, après avoir compris laquelle, vous apprendrez comment passer des paramètres et des commutateurs de ligne de commande aux scripts bash, et quoi faire avec tout cela.

Dans cette conférence, nous continuons à nous familiariser avec frapper... Je tiens à vous rappeler que nous considérons ces éléments frapper pour nous aider à comprendre les scripts du système d'exploitation. Les boucles et les fonctions sont certainement de tels éléments. Si quelqu'un a étudié la programmation, il n'y aura aucune difficulté à comprendre ces problèmes.

Pour boucle

Cycle pour v frapper a deux types. Considérons d'abord la version classique pour... La vue générale est la suivante :

Entre les éléments pour et dans une variable est définie, qui à son tour prend une valeur à partir d'une séquence de valeurs spécifiées entre dans et faire... Entre faire et terminé il y a des commandes qui sont exécutées chaque fois qu'une variable change de valeur. La boucle s'arrête lorsque la variable prend la dernière valeur de la séquence. Les valeurs de la séquence sont séparées par un espace.

Et voici un exemple pratique :

La séquence de valeurs peut être spécifiée de différentes manières. Explicitement - comme dans l'exemple ci-dessus, ou en utilisant d'autres variables, ou en utilisant des commandes spéciales. Regardons quelques exemples. Étant donné que les valeurs sont définies séparées par des espaces, ces valeurs peuvent être n'importe quelle variable contenant une chaîne avec des espaces :

Le résultat sera le même que dans le premier exemple.

Si vous devez spécifier une séquence de nombres, vous pouvez utiliser la commande seq et un mécanisme de substitution. Commander seq renvoie une séquence de valeurs numériques à l'écran. La syntaxe est simple et ressortira clairement de l'exemple ci-dessous :

Résultat:

Revenons au deuxième type pour... Souvent dans les scripts, vous pouvez trouver la variante dite de type C pour qui est utilisé pour les boucles basées sur des nombres. Prenons tout de suite un exemple :

La boucle est exécutée tant que la condition vérifiée dans l'expression est vraie. Dès que l'expression retourne false, l'exécution de la boucle est terminée.

Exemple pratique :

#! / bin / bash
je = 1
tandis que [$ i -lt 7]
faire
écho $ i
soit i = i + 1
terminé

Dans notre exemple, on vérifie que la variable je less (-lt), numéro 7 et si c'est le cas, alors la valeur de la variable est affichée. Expression soit i = i + 1, incrémente la variable de un, vérifie à nouveau, et ainsi de suite. let indique à l'interpréteur de traiter les arguments comme des valeurs numériques. Cette ligne pourrait s'écrire laisse je ++(option c-like). Avec une augmentation du nombre de plus d'un, vous pouvez l'écrire comme ceci : soit i + = 2- dans ce cas je augmentera par incréments de 2. Une autre option pour augmenter une variable consiste à utiliser la calculatrice intégrée (fonctionne uniquement avec des nombres entiers). Le calculateur est accessible via des doubles crochets : i = $ (($ i + 1)) ou par des carrés : i = $ [$ i + 1] Vous pouvez également utiliser la calculatrice sur la ligne de commande :

Avec les boucles, vous devez faire attention à ne pas avoir l'option d'une boucle infinie. Au fait pour le débogage frapper scripts, vous pouvez remplacer la première ligne par #! / bin / bash -x ou lancez le script avec la commande bash -x:

[email protégé]: ~ / linux $ bash -x ./testfor.sh
+ je = 1
+ '[' 1 -gt 5 ']'
+ écho i = 1
je = 1
+ soit i = i + 1
+ '[' 2 -gt 5 ']'
+ écho i = 2
je = 2
+ soit i = i + 1
+ '[' 3 -gt 5 ']'
+ écho i = 3
je = 3
+ soit i = i + 1
+ '[' 4 -gt 5 ']'
+ écho i = 4
je = 4
+ soit i = i + 1
+ '[' 5 -gt 5 ']'
+ écho i = 5
je = 5
+ soit i = i + 1
+ '[' 6 -gt 5 ']'

Assurez-vous de vous entraîner à écrire de petits scripts pour consolider votre compréhension du fonctionnement des boucles dans frapper.

Fonctions dans bash

Les fonctions sont appliquées dans frapper très large. Les fonctions sont décrites de deux manières : avec un mot-clé fonction, et sans.

Première façon :

fonction nom_fonction
{
corps de fonction
}

Deuxième façon :

nom_fonction ()
{
corps de fonction
}

La fonction est appelée par son nom n'importe où dans le script, mais seulement après la description de la fonction elle-même. Vous pouvez également transmettre des paramètres aux fonctions, qui sont spécifiés avec un espace après l'appel (nom) de la fonction. Considérons un exemple de script frapper:

#! / bin / bash
amorce de fonction
{
si [$ # -ne 0]
alors
local a = 1
echo "Nombre de paramètres passés - $ #"
pour moi dans [email protégé]
faire
echo "$ un-ième paramètre est $ i"
laissez un ++
terminé
retourner 0
autre
echo "Aucun paramètre n'a été passé"
retour 1
Fi
}
echo "Appel de la fonction avec paramètres :"
amorce a b c
écho $?
echo "Appel de la fonction sans paramètres :"
apprêt
écho $?

Dans cet exemple, une fonction nommée apprêt... Appel de fonction avec paramètres : amorce a b c et sans paramètres : apprêt... Dans le corps de la fonction, toutes les constructions doivent vous être familières, à l'exception de $# , $ je et [email protégé] .$# - renvoie le nombre de paramètres passés à la fonction. Dans notre exemple, ce sera le nombre 3 .[email protégé] renvoie tous les paramètres sur une ligne. Dans l'exemple, ce serait un b c... Et après $1 , $2 , $3 etc. vous pouvez adresser chaque paramètre personnellement. $? - contient le code pour exécuter la dernière commande. Dans notre exemple, le code d'exécution de la fonction.

La fonction peut également renvoyer une valeur numérique via un mot-clé revenir... En règle générale, ils renvoient 0 si la fonction a été exécutée sans erreur, ou une valeur différente de zéro si quelque chose s'est mal passé. Dans l'exemple, si une fonction est appelée avec des paramètres, la valeur 0 est retournée, et si la fonction a été appelée sans paramètres, alors le code 1 sera retourné.

Tout ce qui concerne le passage de paramètres à une fonction fonctionne de la même manière pour un script. Le script peut également passer des paramètres de la même manière et les manipuler de la même manière en utilisant $#, [email protégé], $ N... De la même catégorie et option - $0 - qui renvoie le nom de la commande qui a lancé le script. Si le script a été exécuté par la commande ./script.sh puis écho $0 retournera la valeur ./script.sh, et si sur commande /home/igor/linux/script.sh alors la valeur sera retournée /home/igor/linux/script.sh.