Dans la première partie de ce didacticiel sur les scripts Bash, nous avons expliqué comment écrire un script Bash. Nous avons exploré les différentes utilisations et les scénarios uniques dans lesquels les scripts Bash peuvent être utiles, ce qui en fait un excellent exemple de leur incroyable efficacité.
Dans cette partie du didacticiel, nous allons examiner le for commande, et la commande while commande. Nous allons montrer comment nous pouvons utiliser ces commandes pour créer des boucles pour itérer sur une série de valeurs.
La boucle For
Sous Linux, une boucle est ce que nous utilisons pour exécuter des commandes à un intervalle spécifié de manière répétée. Les boucles sont utilisées dans une grande variété de langages de programmation dans le même but.
Il existe plusieurs types de boucles différents dans Linux, mais dans cette section de l'article, nous nous concentrerons sur le for boucle.
#!/bin/bash for y in a b c d w x y z > do > echo $y done
Comme vous pouvez le voir dans la capture d'écran ci-dessus, nous avons attribué la variable "y" - qui n'est qu'un espace réservé sans signification utilisé pour la commande - à quelques lettres de l'alphabet.
Nous avons ensuite passé cette variable au echo commande, et il a pu sortir nos lettres ci-dessous.
Itérer sur des valeurs simples
Nous pouvons utiliser le for commande dans un script Bash. Pour ce faire, nous devons d'abord créer un fichier texte dans notre terminal Linux. Vous pouvez utiliser le touch commande pour créer facilement des fichiers texte.
$ touch script
La syntaxe ci-dessus créera un fichier texte que nous appellerons "script". Assurez-vous de créer votre fichier texte en utilisant le .sh extension de fichier. Lors de la création de script , nous voudrons éditer dans notre script réel contenant le for commande.
Nous pouvons y parvenir en exécutant quelques commandes d'édition de fichiers texte différentes, telles que nano commande, et la commande vi commande, etc.
Mais nous vous recommandons d'utiliser nano , car c'est l'un des éditeurs de texte de commande les plus simples et les plus faciles à utiliser sous Linux.
$ nano script
La syntaxe ci-dessus ouvrira notre script dans l'éditeur de texte nano. Ici, nous voudrons taper notre script.
Notez que ce fichier texte doit contenir #!/bin/bash , qui informe le script Bash du shell à utiliser, il s'agit donc d'un élément essentiel de la création réussie d'un script Bash.
#!/bin/bash for var in first second third fourth fifth; do echo The $var item done
Itération sur des valeurs complexes
Dans l'exemple précédent, nous avons montré comment utiliser for commande pour itérer sur des valeurs simples dans un script Bash créé par l'utilisateur. Le mot simple ici fait référence à des valeurs qui ne contiennent qu'un seul mot.
Mais parfois, vous aurez une liste qui comprend - au lieu de ce que nous avons vu dans l'exemple précédent avec "premier" - quelque chose comme "le premier", qui contient plus d'un mot pour une seule valeur. Ces valeurs sont ce que nous appelons des valeurs "complexes".
Si votre liste contient ces valeurs complexes, vous devrez les référencer en les entourant de guillemets, afin que le script comprenne qu'il ne s'agit que d'une seule valeur.
#!/bin/bash for var in first "the second" "the third" "I’ll do it"; do echo "This is: $var" done
Substitution de commande
Nous pouvons également utiliser la substitution de commande dans notre for commande dans notre script Bash.
#!/bin/bash
my_file="file01"
for var in $(cat $my_file); do
echo " $var"
done
Ici, nous avons utilisé la substitution de commande avec un sous-shell Bash, comme le montre l'utilisation de la commande cat à l'intérieur de $( ); cela nous permet d'utiliser la sortie du cat commande et obtenir le contenu du fichier en supposant que chaque ligne contient un mot.
Mais s'il y a des espaces dans l'une de ces lignes, chaque mot sera considéré comme un champ. Dans ce cas, vous devrez indiquer au shell de traiter les nouvelles lignes comme un séparateur au lieu d'espaces.
Le séparateur de champs
Par défaut, les caractères suivants sont considérés comme des champs par le shell Bash.
- Espace
- Onglet
- nouvelle ligne
Si votre texte comprend l'un de ces caractères, le shell supposera qu'il s'agit d'un nouveau champ et vous devrez modifier le séparateur de champ interne ou la variable d'environnement IFS si vous avez besoin d'utiliser ces caractères.
$ IFS=$’n’
La syntaxe ci-dessus amènera le shell Bash à considérer les nouvelles lignes comme un séparateur au lieu d'un espace.
#!/bin/bash file="/etc/passwd" IFS=$'n' for var in $(cat $file); do echo " $var" done
Vous pouvez également affecter le séparateur de champs aux deux-points avec IFS comme indiqué ci-dessous.
$ IFS=:
Plutôt fantastique, hein ?
Itération sur les fichiers de répertoire
Vous pouvez également utiliser le for boucle dans un script Bash pour lister les fichiers de votre répertoire personnel.
#!/bin/bash for obj in /home/ubuntu/*; do if [ -d "$obj" ]; then echo "$obj is a folder" elif [ -f "$obj" ]; then echo "$obj is a file" fi done
Ce processus nécessite que vous utilisiez le if déclaration pour vérifier les fichiers et les dossiers. Mais cela ne devrait pas vous poser trop de problème si vous avez lu le post précédent. Mais si par hasard vous avez besoin d'un rappel, je vous recommande de le revoir.
Nous avons utilisé un caractère générique appelé astérisque (*) dans notre script Bash qui contient un for boucle qui nous permet de lister les fichiers et dossiers de notre répertoire personnel. Dans les scripts Bash, ce processus s'appelle "globbing de fichiers .” Le regroupement de fichiers signifie tous les fichiers existants avec un nom.
Notez que les variables dans notre if instruction sont écrits avec des guillemets car les noms de fichiers ou de dossiers peuvent contenir des espaces. Si nous avions omis cette étape, nous n'aurions peut-être pas été en mesure de répertorier tous les fichiers et répertoires.
Itérer sur les lignes de fichier
Nous pouvons utiliser le for boucle dans un script Bash pour parcourir le contenu du fichier :
#!/bin/bash IFS=$'n' for text in $(cat /etc/passwd); do echo "This line $text ++ contains" IFS=: for field in $text; do echo " $field" done done
Ici, nous avons deux boucles, la première boucle itère sur les lignes du fichier, et le séparateur est la nouvelle ligne, la deuxième itération est sur les mots sur la ligne elle-même, et le séparateur est le deux-points :
données de fichier
Vous pouvez appliquer cette idée lorsque vous avez un fichier CSV ou tout autre fichier de valeurs séparées par des virgules. L'idée est la même; il vous suffit de changer le séparateur pour l'adapter à vos besoins.
Pour la boucle de style C
Si vous êtes familier avec le langage C, vous remarquerez peut-être qu'il y a quelque chose qui cloche dans for boucle parfois sous Linux.
C'est parce qu'il existe deux manières d'écrire for boucles; la méthode Linux standard, que nous avons déjà abordée au début de ce didacticiel, et la méthode "style C".
for (var= 0; var < 5; var++)
{
printf(“number is %dn”, var);
}
La syntaxe ci-dessus est pour le for boucle écrite en C. Le style C for La boucle sous Linux est écrite de manière très similaire à celle-ci avec quelques petites modifications, qui peuvent être observées ci-dessous.
pour (( variable =début; condition; pas d'itération))
for (( var = 1; var < 5; var++ ))
Pour aider à mieux peindre l'image, nous inclurons un exemple de script Bash utilisant le style C for boucle dans notre terminal Linux.
#!/bin/bash for ((var = 1; var <= 10; var++)); do echo "number is $var" done
Mettez ceci dans notre fichier texte et lancez-le.
La commande Continuer
Le Bash continue commande ignore les commandes à l'intérieur de la boucle externe pour l'itération en cours et donne le contrôle à la suivante. Vous pouvez utiliser cette commande pour arrêter l'exécution des commandes restantes à l'intérieur d'une boucle sans quitter la boucle.
Dans les deux exemples suivants, nous verrons comment cette commande peut être utilisée dans les boucles de script Bash sous Linux.
La commande Break
Vous pouvez utiliser la commande break pour sortir de n'importe quelle boucle, comme les boucles while et until.
#!/bin/bash for number in 10 11 12 13 14 15; do if [ $number -eq 14 ]; then break fi echo "Number: $number" done
La boucle s'exécute jusqu'à ce qu'elle atteigne 14, puis la commande quitte la boucle.
Nous aborderons d'autres exemples de cette commande un peu plus tard.
La boucle While
La boucle for n'est pas le seul moyen de boucler dans les scripts Bash. Le while loop fait le même travail, mais il vérifie une condition avant chaque itération. La structure du while boucle peut être vu ci-dessous.
while [ condition ]
do
commands
done
Nous allons fournir un exemple avec un script Bash.
#!/bin/bash number=10 while [ $number -gt 4 ]; do echo $number number=$(($number - 1)) done
Le fonctionnement de ce script Bash est simple; il commence par le while pour vérifier si le nombre est supérieur à zéro, il exécutera la boucle et la valeur du nombre sera diminuée à chaque fois de 1. À chaque itération de la boucle, le script imprimera la valeur du nombre. La boucle s'exécutera jusqu'à ce que ce nombre atteigne 0.
Boucles imbriquées
Vous pouvez créer des boucles à l'intérieur d'autres boucles, comme le while boucle par exemple. Ces boucles à l'intérieur d'une boucle sont appelées boucles imbriquées. Nous allons plonger dans ceux-ci en examinant d'abord comment créer un for imbriqué boucle dans l'exemple suivant.
Plusieurs boucles for (imbriquées pour)
Dans les exemples précédents de ce didacticiel, nous avons montré comment créer for boucles dans un script Bash sous Linux. Mais il existe aussi quelque chose que nous appelons imbriqué for boucles. Ce sont des boucles dans d'autres boucles, ou simplement plusieurs boucles, pour faire simple.
Nous allons vous montrer un exemple simple de ce à quoi cela ressemble, ainsi qu'un bref examen et une description ci-dessous.
for y in a b c d e f
do
for u in a b c d e f
do
echo "$y$u"
done
done
Comme vous pouvez le voir dans la capture d'écran ci-dessus, la sortie que nous recevons lors de l'exécution de notre script dans le terminal de ligne de commande Linux se lit comme suit :notre exemple de texte dans chaque for boucle est "a b c d e f".
Notre script fait écho au texte de la boucle externe à côté du texte de la boucle interne.
Le script continue à générer le premier champ (dans ce cas, les espaces, nous l'expliquerons un peu plus tard) du texte dans la boucle externe jusqu'à ce que chaque champ contenu dans la boucle interne ait été généré.
À la fin de la sortie de la boucle interne, notre script Bash commencera alors à produire le champ suivant du texte dans la boucle externe.
Tout ce processus sera répété jusqu'à ce que chaque champ de chaque boucle ait été complètement imprimé dans la sortie de votre terminal Linux.
Boucle while multiple (while imbriqué)
Comme le for imbriqué boucles de commande, il existe aussi des while imbriqués boucles de commande. Celles-ci fonctionnent exactement de la même manière que les boucles imbriquées pour le for commande; une boucle à l'intérieur d'une autre boucle.
La syntaxe ci-dessous aura une ressemblance frappante avec le while normal boucle, comme la structure d'un while imbriqué loop est simplement une forme développée de la base while boucle, qui peut être observée dans la syntaxe ci-dessous.
while [condition] do statements1 statements2 while [condition] do continue done statements3 done
La syntaxe ci-dessus effectuera des tâches spécifiées jusqu'à ce que les conditions que vous avez sélectionnées soient remplies. C'est ce qu'on appelle une boucle. Mais puisque la boucle dans l'exemple ci-dessus est imbriquée, cela signifie que l'une des tâches que nous avons mentionnées ci-dessus est une autre boucle elle-même.
En attendant
Nous avons montré comment le while boucle et le for loop peut être très utile pour exécuter des processus complexes à l'aide de scripts Bash sous Linux.
Mais parfois, pour diverses raisons, vous devrez tuer l'une des boucles de votre script Bash. Ce scénario, aussi brutal que cela puisse paraître, se produit souvent dans le travail d'administration système. Donc, vous voudrez peut-être vous familiariser avec ce concept.
Dans le shell Bash, le break commande et le continue La commande peut fournir les outils nécessaires pour contrôler le flux de vos boucles de script Bash.
Nous allons montrer comment ces commandes fonctionnent individuellement avec quelques exemples ci-dessous.
La syntaxe pour utiliser le brea commande pour quitter un while boucle est la suivante :
$ while [ condition ]
do
commands
continue
done
Le continue commande break la commande fonctionne de manière très similaire et peut être considérée comme opposée l'une à l'autre; le continue la commande fonctionne exactement comme la break commande, seulement elle continue la boucle au lieu de la tuer.
Quitter la boucle While
La break commande tue la boucle en cours et donne le contrôle à la commande suivante suivant cette boucle. Vous pouvez utiliser ce processus pour sortir de boucles telles que for ,while , etc. La syntaxe du break commande est la suivante :
$ while [ condition ]
do
commands
break
done
Mais comme nous l'avons mentionné ci-dessus, à la fois le continue commande et la break La commande peut être utilisée pour d'autres boucles de script Bash en plus de while boucle. Nous montrerons comment les utiliser dans le for boucle.
Quitter la boucle
Vous pouvez utiliser ces commandes de contrôle de boucle dans un for boucle. Nous utiliserons le break commande pour quitter le for boucle dans notre script Bash.
#!/bin/bash for number in 10 11 12 13 14 15; do if [ $number -eq 14 ]; then break fi echo "Number: $number" done
Le for boucle s'exécute jusqu'à ce qu'elle atteigne le nombre que nous avons spécifié dans le script bash, qui est 14. Une fois le nombre spécifié atteint, le break la commande quittera le for boucle.
Instruction Break If
Nous venons de montrer comment utiliser break commande pour quitter for boucles, mais nous pouvons également utiliser cette commande pour quitter le if déclaration à l'intérieur de ces boucles de script Bash.
i=0
while [[ $i -lt 10 ]]
do
echo "Number: $i"
((i++))
if [[ $i -eq 5 ]]; then
break
fi
done
Continuer la déclaration
Nous faisons la même chose que nous avons fait dans l'exemple précédent avec le continue commande comme nous l'avons fait avec le break commande dans un while boucle dans un script Bash.
i=0
while [[ $i -lt 10 ]]; do
((i++))
if [[ "$i" == '5' ]]; then
continue
fi
echo "Number: $i"
done
Réflexions finales
J'espère que vous avez appris une nouvelle chose ou deux. Ou, à tout le moins, j'espère que vous avez pu revoir ce que vous savez déjà. Mes derniers mots aujourd'hui pour vous seraient de continuer à lire et à pratiquer.
Merci.