Rédaction de scripts en Bash. fonctions bash dans les scripts Qu'est-ce qu'un script bash

Tout le monde sait que le shell Bash contient des commandes intégrées qui ne se trouvent pas dans les dossiers /bin ou /usr/bin. Ils sont intégrés au shell et exécutés en tant que fonctions. Dans l'un des articles précédents, nous avons considéré. Nous avons discuté de presque tout là-bas, à quoi les scripts devraient ressembler, l'utilisation de conditions, de boucles, de variables, mais nous ne nous sommes pas arrêtés aux fonctions.

Dans l'article d'aujourd'hui, nous corrigerons cette lacune. Comme tout langage de programmation, Bash possède des fonctions qui peuvent être très utiles à utiliser. Nous verrons comment utiliser les fonctions bash, comment les écrire et même comment créer des bibliothèques à partir de ces fonctions.

Nous devons d'abord comprendre ce qu'est une fonction dans notre contexte. Une fonction est un ensemble de commandes, unies par un nom, qui exécutent une tâche spécifique. La fonction est appelée par son nom, peut prendre des paramètres et retourner le résultat du travail. En bref, les fonctions Bash fonctionnent exactement comme dans d'autres langages de programmation.

La syntaxe pour créer une fonction est très simple :

nom_fonction() ( liste de commandes )

Le nom de la fonction ne doit correspondre à aucune des commandes ou fonctions existantes, et toutes les commandes du corps de la fonction sont écrites sur une nouvelle ligne.

fonction simple

Écrivons une petite fonction qui affichera une chaîne à l'écran :

$ vi fonction.sh

#!/bin/bash
printstr()(
echo "bonjour le monde"
}
printstr

L'appel d'une fonction bash se fait en spécifiant son nom, comme pour toute autre commande. Lancez notre script pour exécution, n'oubliez pas qu'avant cela vous devez lui donner les droits d'exécution :

chmod u+x fonction.sh

Tout fonctionne, maintenant compliquons la tâche, essayons de passer des arguments à la fonction.

Arguments de la fonction

Les arguments de fonction doivent être passés lors de l'appel et ils sont lus de la même manière que les arguments de script. La syntaxe pour appeler une fonction avec des paramètres bash est :

nom_fonction argument1 argument2 ... argumentN

Comme vous pouvez le voir, tout est assez simple. Les paramètres sont séparés par un espace. Améliorons maintenant notre fonction afin qu'elle renvoie la chaîne que nous avons spécifiée :

!/bin/bas
printstr()(
écho $1
}
printstr "Bonjour le monde"

Vous pouvez avoir plusieurs options :

!/bin/bas
printstr()(
écho $1
écho $2
écho $3
écho $5
}
printstr "arg1" "arg2" "arg3" "arg4" "arg5"

Il existe une autre façon d'extraire des arguments, comme en C, en utilisant la pile. Nous récupérons le premier argument, puis avançons le pointeur de pile d'arguments de un, et récupérons à nouveau le premier argument. Et ainsi de suite:

!/bin/bas
printstr()(
écho $1
changement
écho $1
changement
écho $1
changement
écho $1
}
printstr "arg1" "arg2" "arg3" "arg4"

Renvoyer le résultat d'une fonction

Vous pouvez non seulement utiliser des fonctions avec des paramètres bash, mais également en obtenir le résultat. La commande return est utilisée pour cela. Il termine la fonction et retourne valeur numérique Code de retour. Il peut être compris entre 0 et 255 :

!/bin/bas
printstr()(
retour 134;
}
printstr
echo $?

Si vous devez utiliser la valeur de retour d'une fonction bash plutôt que le code d'état, utilisez echo. La chaîne n'est pas immédiatement envoyée au terminal, mais est renvoyée comme résultat de la fonction et peut être écrite dans une variable puis utilisée :

!/bin/bas
printstr()(
écho "tester"
}
VAR=$(printstr)
écho $VAR

Fonctions d'exportation

Vous pouvez rendre une fonction disponible en dehors d'un script avec la commande declare :

!/bin/bas
printstr()(
echo "bonjour le monde"
}
déclarer -x -f printstr

Exécutez ensuite le script avec la commande source :

fonction source.sh
$printstr

récursivité

Vous pouvez appeler une fonction depuis elle-même pour effectuer la récursivité :

!/bin/bas
printstr()(
echo "bonjour le monde"
printstr
}
printstr

Vous pouvez expérimenter l'utilisation de la récursivité, cela peut être utile dans de nombreux cas, n'oubliez pas de faire le premier appel de la fonction Bash.

Variables locales dans une fonction

Si vous déclarez une variable ordinaire dans une fonction, alors elle sera disponible dans tout le script, c'est pratique pour retourner la valeur de la fonction, mais parfois il peut être nécessaire d'en faire une variable locale. Il existe une commande locale pour cela :

!/bin/bas
printstr()(
VAR locale=$1
echo $(var)
}
printstr "Bonjour le monde"

Bibliothèques de fonctions

Nous pouvons prendre certaines fonctions bash et les combiner dans une bibliothèque afin de pouvoir importer ces fonctions avec une seule commande. Cela se fait de la même manière que pour exporter des fonctions. Commençons par créer un fichier de bibliothèque :

essai1()(
echo "Bonjour le monde de 1" ;
}
essai2()(
echo "Bonjour le monde de 2" ;
}
essai3()(
echo "Hello World from 3" ;
}

Créons maintenant un script qui utilisera nos fonctions. Vous pouvez importer la bibliothèque à l'aide de la commande source ou en spécifiant simplement le nom du script :

!/bin/bas
source lib.sh
test1
test2
test3

conclusion

Dans cet article, nous avons examiné les fonctions bash, comment les écrire, les appliquer et les combiner dans des bibliothèques. Si vous écrivez souvent des scripts dans Bash, ces informations vous seront utiles. Vous pouvez créer votre propre ensemble de fonctions à utiliser dans chaque script et ainsi faciliter votre travail.

Quelle que soit la simplicité de l'interface graphique de Linux et le nombre de fonctions, il existe toujours des tâches plus pratiques à résoudre via le terminal. Premièrement, parce que c'est plus rapide, et deuxièmement, toutes les machines n'ont pas d'interface graphique, par exemple, sur les serveurs, toutes les actions sont effectuées via le terminal, afin d'économiser les ressources informatiques.

Si vous avez déjà terminé utilisateur avancé, alors vous effectuez probablement souvent diverses tâches via le terminal. Il existe souvent des tâches pour lesquelles vous devez exécuter plusieurs commandes à tour de rôle, par exemple, pour mettre à jour le système, vous devez d'abord mettre à jour les référentiels, puis télécharger de nouvelles versions de packages. Ceci n'est qu'un exemple et il existe de nombreuses actions de ce type, même effectuer une sauvegarde et télécharger les fichiers copiés sur serveur distant. Ainsi, pour ne pas taper plusieurs fois les mêmes commandes, vous pouvez utiliser des scripts. Dans cet article, nous examinerons l'écriture de scripts dans Bash, examinerons les opérateurs de base, ainsi que leur fonctionnement, pour ainsi dire, des scripts bash à partir de zéro.

Un script, ou comme on l'appelle aussi - un script, est une séquence de commandes qui sont lues et exécutées à tour de rôle par un programme interpréteur, dans notre cas c'est un programme ligne de commande- bas.

Le scénario est normal fichier texte, qui répertorie les commandes habituelles que nous avons l'habitude de saisir manuellement, ainsi que le programme qui les exécutera. Le chargeur qui exécutera le script ne sait pas comment travailler avec Variables d'environnement, il faut donc lui transmettre le chemin exact du programme à exécuter. Et puis il passera votre script à ce programme et l'exécution commencera.

L'exemple le plus simple d'un script pour un shell Bash :

!/bin/bas
echo "Bonjour le monde"

L'utilitaire echo imprime la chaîne qui lui est transmise en tant que paramètre à l'écran. La première ligne est spéciale, elle précise le programme qui exécutera les commandes. De manière générale, nous pouvons créer un script dans n'importe quel autre langage de programmation et spécifier l'interpréteur souhaité, par exemple en python :

!/usr/bin/envpython
print("Bonjour le monde")

Ou en PHP :

!/usr/bin/envphp
echo "Bonjour le monde" ;

Dans le premier cas, nous pointons directement vers le programme qui exécutera les commandes ; dans les deux suivants, nous ne connaissons pas l'adresse exacte du programme, nous demandons donc à l'utilitaire env de le trouver par son nom et de l'exécuter. Cette approche est utilisée dans de nombreux scripts. Mais ce n'est pas tout. DANS Système Linux, afin que le système puisse exécuter le script, vous devez définir l'indicateur exécutable sur le fichier avec celui-ci.

Cet indicateur ne change rien au fichier lui-même, il indique seulement au système qu'il ne s'agit pas simplement d'un fichier texte, mais d'un programme et qu'il doit être exécuté, ouvrez le fichier, trouvez l'interpréteur et exécutez. Si aucun interpréteur n'est spécifié, l'interpréteur de l'utilisateur sera utilisé par défaut. Mais comme tout le monde n'utilise pas bash, vous devez le spécifier explicitement.

Courir:

chmod ugo+x fichier_script

Maintenant, nous exécutons notre petit premier programme :

./Fichier de script

Tout fonctionne. Vous savez déjà comment écrire un petit script pour, par exemple, une mise à jour. Comme vous pouvez le voir, les scripts contiennent les mêmes commandes qui sont exécutées dans le terminal, ils sont très faciles à écrire. Mais maintenant, nous allons compliquer un peu la tâche. Puisqu'un script est un programme, il doit prendre lui-même certaines décisions, stocker les résultats de l'exécution de la commande et exécuter des boucles. Tout cela peut être fait avec le shell Bash. Certes, tout est beaucoup plus compliqué ici. Commençons simple.

Variables dans les scripts

L'écriture de scripts dans Bash est rarement complète sans stocker des données temporaires, ce qui signifie créer des variables. Aucun langage de programmation ne peut se passer de variables, et notre langage shell primitif aussi.

Vous avez peut-être déjà rencontré des variables d'environnement. Ce sont donc les mêmes variables et elles fonctionnent de la même manière.

Par exemple, déclarons une variable chaîne :

string="Bonjour le monde"

La valeur de notre chaîne est entre guillemets. Mais en fait, les citations ne sont pas toujours nécessaires. Le principe principal de bash est conservé ici - un espace est un caractère spécial, un séparateur, donc si vous n'utilisez pas de guillemets, world sera déjà considéré comme une commande distincte, pour la même raison nous ne mettons pas d'espaces avant et après l'égal signe.

Le symbole $ est utilisé pour afficher la valeur d'une variable. Par exemple:

Modifions notre script :

!/bin/bas
chaîne1="bonjour"
string2=monde
chaîne=$chaîne1$chaîne2
echo $string

Et on vérifie :

Bash ne fait pas la distinction entre les types de variables comme le font les langages de haut niveau comme C++, vous pouvez attribuer à la fois un nombre et une chaîne à une variable. De même, tout cela sera considéré comme une chaîne. Le shell ne prend en charge que la fusion de chaînes, pour ce faire, écrivez simplement les noms des variables à la suite :

!/bin/bas
chaîne1="bonjour"
string2=monde
chaîne=$chaîne1$chaîne2\ et\ moi
chaîne3=$chaîne1$chaîne2" et moi"
echo $string3

Nous vérifions:

Veuillez noter que, comme je l'ai dit, les guillemets sont facultatifs s'il n'y a pas de caractères spéciaux dans la chaîne. Examinez de plus près les deux façons de fusionner des chaînes, le rôle des guillemets est également démontré ici. Si vous avez besoin de moyens plus sophistiqués pour gérer les chaînes, ou opérations arithmétiques, cela n'est pas inclus dans les capacités du shell, des utilitaires normaux sont utilisés pour cela.

Variables et sortie de commande

Les variables ne seraient pas aussi utiles si elles ne pouvaient pas stocker le résultat de l'exécution des utilitaires. La syntaxe suivante est utilisée pour cela :

$(équipe )

Avec cette construction, la sortie de la commande sera directement redirigée vers l'endroit d'où elle a été appelée, et non vers l'écran. Par exemple, l'utilitaire de date renvoie la date actuelle. Ces commandes sont équivalentes :

Comprenez vous? Écrivons un script où hello world et date seront affichés :

string1="bonjour le monde"
chaîne2=$(date)

chaîne=$chaîne1$chaîne2

Maintenant, vous en savez assez sur les variables et vous êtes prêt à créer un script bash, mais il y a plus à venir. Ensuite, nous examinerons les paramètres et les structures de contrôle. Permettez-moi de vous rappeler que ce sont toutes des commandes bash régulières et que vous n'avez pas besoin de les enregistrer dans un fichier, vous pouvez les exécuter immédiatement lors de vos déplacements.

Paramètres de script

Il n'est pas toujours possible de créer un script bash qui ne dépend pas de l'entrée de l'utilisateur. Dans la plupart des cas, vous devez demander à l'utilisateur quelle action entreprendre ou quel fichier utiliser. Lors de l'appel d'un script, nous pouvons lui transmettre des paramètres. Tous ces paramètres sont disponibles sous forme de variables nommées par des nombres.

La variable nommée 1 contient la valeur du premier paramètre, la variable 2, la seconde, etc. Ce script bash affichera la valeur du premier paramètre :

!/bin/bas
écho $1

Contrôler les constructions dans les scripts

La création d'un script bash ne serait pas aussi utile sans la capacité d'analyser certains facteurs et d'effectuer les actions nécessaires en réponse à ceux-ci. C'est un sujet assez complexe, mais il est très important pour créer un script bash.

Dans Bash, il existe une commande de vérification des conditions dont la syntaxe est la suivante :

si condition_commande
alors
équipe
autre
équipe
Fi

Cette commande vérifie le code de sortie de la commande de condition, et si 0 (succès) exécute alors la commande ou plusieurs commandes après le mot puis, si le code de sortie est 1, le bloc else est exécuté, fi signifie l'achèvement du bloc de commandes.

Mais comme nous nous intéressons le plus souvent non pas au code de retour de la commande, mais à la comparaison de chaînes et de nombres, la commande [[ a été introduite, qui vous permet d'effectuer diverses comparaisons et d'émettre un code de retour en fonction du résultat de la comparaison. Sa syntaxe est :

[[ paramètre1 opérateur paramètre2 ]]

À titre de comparaison, nous utilisons les opérateurs déjà familiers<,>,=,!= et ainsi de suite. Si l'expression est vraie, la commande renverra 0, sinon - 1. Vous pouvez tester un peu son comportement dans le terminal. Le code retour de la dernière commande est stocké dans la variable $? :

Maintenant, en combinant tout cela, nous obtenons un script avec une expression conditionnelle :

!/bin/bas
si [[ $1 > 2 ]]
alors
echo $1" est supérieur à 2"
autre
echo $1" est inférieur à 2 ou 2"
Fi

Bien sûr, cette conception a des fonctionnalités plus puissantes, mais il est trop compliqué de les couvrir dans cet article. Peut-être que je l'écrirai plus tard. Pour l'instant, passons aux cycles.

Boucles dans les scripts

L'avantage des programmes est que nous pouvons spécifier en plusieurs lignes quelles actions doivent être effectuées plusieurs fois. Par exemple, il est possible d'écrire des scripts bash composés de quelques lignes seulement, mais exécutés pendant des heures, en analysant les paramètres et en effectuant les actions nécessaires.

Regardons d'abord la boucle for. Voici sa syntaxe :

pour une variable dans la liste
faire
équipe
fait

Itère sur toute la liste et affecte la valeur de la liste à son tour à la variable, après chaque affectation, exécute les commandes situées entre do et done.

Par exemple, parcourons cinq chiffres :

pour index en 1 2 3 4 5
faire
echo $index
fait

Ou vous pouvez lister tous les fichiers du répertoire courant :

pour le fichier dans $(ls -l); faites echo "$fichier" ; fait

Comme vous l'avez compris, vous pouvez non seulement afficher les noms, mais également effectuer les actions nécessaires, ce qui est très utile lors de la création d'un script bash.

La deuxième boucle que nous allons examiner est la boucle while, qui s'exécute pendant que la commande de condition renvoie le code 0, succès. Considérez la syntaxe :

tant que condition de commande
faire
équipe
fait

Prenons un exemple :

!/bin/bas
indice=1
tandis que [[ $index< 5 ]]
faire
echo $index
laisser "index=index+1"
fait

Comme vous pouvez le voir, tout est fait, la commande let effectue simplement l'opération mathématique spécifiée, dans notre cas elle augmente la valeur de la variable de un.

Je voudrais noter autre chose. Les constructions telles que while, for, if sont conçues pour être écrites sur plusieurs lignes, et si vous essayez de les écrire sur une seule ligne, vous obtiendrez une erreur. Mais néanmoins il est possible, pour cela, là où il devrait y avoir un saut de ligne, de mettre un point-virgule ";". Par exemple, la boucle précédente aurait pu être exécutée sur une seule ligne :

indice=1 ; tandis que [[ $index< 5 ]]; do echo $index; let "index=index+1"; done;

Tout est très simple, j'ai essayé de ne pas compliquer l'article avec des termes et fonctionnalités bash supplémentaires, uniquement les plus basiques. Dans certains cas, vous devrez peut-être créer une interface graphique pour un script bash, puis vous pouvez utiliser des programmes tels que zenity ou kdialog, avec lesquels il est très pratique d'afficher des messages à l'utilisateur et même de lui demander des informations.

conclusion

Vous comprenez maintenant les bases des scripts sous Linux et vous pouvez écrire le script dont vous avez besoin, par exemple, pour Réserver une copie. J'ai essayé de regarder les scripts bash à partir de zéro. Par conséquent, tous les aspects n'ont pas été pris en compte. Peut-être reviendrons-nous sur ce sujet dans l'un des articles suivants.

Pour écrire un script bash simple nous devons suivre les étapes simples suivantes :

Comment ça marche :

La première ligne de notre script #!/bin/bash est essentielle pour que notre script fonctionne correctement.

la deuxième ligne mkdir testdir crée le répertoire testdir

la troisième ligne cd testdir vous permet de passer au répertoire créé testdir

équipe touche dans la ligne suivante touchez fichier1 fichier2 fichier3 crée trois fichiers

et la dernière commande de la ligne de notre script ls -al nous permet d'afficher le contenu du répertoire courant, dans lequel, grâce à la ligne précédente, trois fichiers vides sont apparus.

Comme nous pouvons le voir, dans notre scénario simple toutes les commandes commencent sur une nouvelle ligne. Chaque ligne, lorsque le script est lancé, effectue séquentiellement son travail, effectuant certaines actions.

Si vous exécutez une chaîne de commandes identiques (avec des paramètres constants) sous Linux tous les jours, il peut être judicieux pour vous d'écrire la même script bash simple, ce qui vous permettra de gagner du temps et d'automatiser votre travail.

Rédaction de scripts sous Linux (apprentissage par exemples)

———————————————————————————-

1. Introduction

Ce dont vous avez besoin pour écrire des scripts
Connaissance des outils de ligne de commande et de leurs options nécessaires.
Une connaissance de base de l'anglais au niveau de l'école primaire n'interférera pas.

Pourquoi les scripts sont nécessaires
Premièrement, l'administration d'un serveur Linux, à un degré ou à un autre, se résume à l'exécution systématique des mêmes commandes. De plus, il n'est pas nécessaire que ces commandes soient exécutées par une personne. Ils peuvent être programmés pour être exécutés par une machine.
Deuxièmement, même en faisant juste une tâche normale qui (soudain) s'élève à 20-1000 ... les opérations répétitives sont BEAUCOUP plus faciles à mettre en œuvre dans un script.

Qu'est-ce qu'un scénario
Un script est un ensemble d'instructions qu'un ordinateur doit exécuter dans un certain ordre et à un certain moment. Les instructions peuvent être soit des commandes shell internes (boucles, conditions, traitement d'informations textuelles, travail avec des variables d'environnement, etc.), soit tout programme que nous exécutons dans la console avec les paramètres nécessaires.

Comment écrire un scénario
Dans notre cas, le script sera un fichier texte avec des attributs d'exécution. Si un fichier de script commence par #!, appelé sha-bang dans le monde UNIX, cela indique au système quel interpréteur utiliser pour exécuter le script. Si cela est difficile à comprendre, rappelez-vous simplement que nous allons commencer à écrire tous les scripts avec la ligne #!/bin/bash ou #!/bin/sh, puis les commandes et les commentaires iront.

mot d'adieu
Je vous conseille sincèrement d'écrire autant de commentaires que possible sur presque chaque ligne du script. Le temps passera et vous devrez modifier ou moderniser le script écrit une fois. Si vous ne vous souvenez pas ou ne comprenez pas ce qui est écrit dans le script, il devient difficile de le modifier, il est plus facile d'écrire à partir de zéro.

De quels scripts pourrions-nous avoir besoin :

définir des règles de pare-feu au démarrage du système.

effectuer une sauvegarde des paramètres et des données.

ajouter des boîtes aux lettres au serveur de messagerie (plus précisément à la base de données mysql)

lancer à une certaine heure (de préférence chaque nuit) un programme qui analyse les journaux du serveur proxy et publie un rapport Web pratique sur la quantité de trafic téléchargé.

nous envoyer par e-mail des informations indiquant que quelqu'un a eu accès à notre serveur via ssh, l'heure de connexion et l'adresse du client.

À propos de la technique de script
Nous créons un fichier texte, le modifions, définissons les droits d'exécution, l'exécutons, vérifions les erreurs, le corrigeons, l'exécutons, vérifions les erreurs ...
Quand tout est léché et fonctionne correctement, on le met en autoload ou dans le scheduler pendant un certain temps.

———————————————————————————-

2. Apprendre à écrire des scripts dans le langage interne BASH
d'origine : https://www.linuxconfig.org/Bash_scripting_Tutorial

Ce didacticiel ne suppose aucune connaissance préalable de la manière d'écrire des scripts (ci-après dénommés scripts) à l'aide du langage interne de Bash. Avec l'aide de ce guide, vous découvrirez bientôt que l'écriture de scripts est une tâche très facile. Commençons notre tutoriel avec un script simple qui imprime la chaîne "Hello World!" (traduit de l'anglais - Bonjour à tous !)

1. Scénario "Bonjour tout le monde"
Voici votre premier exemple de script bash :

#!/bin/bash
echo "Bonjour le monde"

Accédez au répertoire contenant notre fichier hello_world.sh et rendez-le exécutable :

Code : Tout sélectionner $ chmod +x hello_world.sh

Exécutez le script pour l'exécution

Code : Sélectionnez tous les $ ./hello_world.sh

2. Un script bash d'archivage simple

#!/bin/bash
tar -czf myhome_directory.tar.gz /home/user

Code : Sélectionnez tous les $ ./backup.sh

$ du -sh myhome_directory.tar.gz
41M myhome_directory.tar.gz

3. Travailler avec des variables
DANS cet exemple on déclare une simple variable et on l'affiche à l'écran avec la commande echo

#!/bin/bash
CHAINE="BONJOUR MONDE !!!"
echo $CHAINE

Code : Sélectionnez tous les $ ./hello_world.sh
BONJOUR LE MONDE!!!

Notre script d'archivage avec variables :

#!/bin/bash
OF=myhome_directory_$(date +%Y%m%d).tar.gz
SI=/home/utilisateur
tar -czf $OF $IF

Code : Sélectionnez tous les $ ./backup.sh
tar : suppression du "\" de début des noms de membres
$ du -sh *tar.gz
41M myhome_directory_20100123.tar.gz

3.1 Variables globales et locales

#!/bin/bash
# Déclarer une variable globale
# Cette variable peut être utilisée n'importe où dans ce script
VAR="variable globale"
fonction bash(
# Déclarer une variable locale
# Une telle variable n'est valide que pour la fonction dans laquelle elle est déclarée
local VAR="variables locales"
écho $VAR
}
écho $VAR
frapper
# Notez que la variable globale n'a pas changé
écho $VAR

Code : Sélectionnez tous les $ ./variables.sh
variable globale
variable locale
variable globale

4. Passer des arguments au script

#!/bin/bash
# Utiliser des variables prédéfinies pour accéder aux arguments
# Afficher les arguments à l'écran
écho $1 $2 $3 ' -> écho $1 $2 $3'

#Nous pouvons également accéder aux arguments via un tableau spécial args=("$@")
# Afficher les arguments à l'écran
echo $(args) $(args) $(args) ‘ -> args=("$@"); echo $(args) $(args) $(args)'

# Utilisez la variable $@ pour afficher tous les arguments à la fois
echo $@ ' -> echo $@'

Utilisez la variable $# pour afficher le nombre d'arguments passés au script
echo Nombre d'arguments passés : $# ' -> echo Nombre d'arguments passés : $#'

Code : Tout sélectionner $ ./arguments.sh Tutoriel de script bash
Tutoriel de script bash -> echo $1 $2 $3
Tutoriel de script bash -> args=("$@"); echo $(args) $(args) $(args)
Tutoriel de script bash -> echo $@
Nombre d'arguments passés : 3 -> echo Nombre d'arguments passés : $#

5. Exécution de commandes Shell dans un script

#!/bin/bash
# utilisez des backticks » ` ` » pour exécuter une commande shell
echo `uname -o`
# maintenant essayons sans les guillemets
echo uname -o

Code : Tout sélectionner $ uname -o
GNU/Linux
$ ./bash_backtricks.sh
GNU/Linux
uname-o

Comme vous pouvez le voir, dans le second cas, la commande elle-même était affichée, et non le résultat de son exécution.

6. Lire l'entrée de l'utilisateur (interactivité)

#!/bin/bash
echo -e "Bonjour, veuillez taper le mot : \c"
lire le mot
echo "Le mot que vous avez saisi est : $mot"
echo -e "Pouvez-vous saisir deux mots ? »
lire mot1 mot2
echo "Voici votre saisie : \"$mot1\" \"$mot2\""
echo -e "Que pensez-vous des scripts bash ? »
# la commande de lecture stocke maintenant une réponse dans la variable intégrée par défaut $REPLY
lire
echo "Vous avez dit $REPLY, je suis content de l'entendre ! »
echo -e "Quelles sont vos couleurs préférées ? »
# -a rend la commande de lecture à lire dans un tableau
lire -a couleurs
echo "Mes couleurs préférées sont aussi $(colours), $(colours) et $(colours):-)"

Code : Sélectionnez tous les $ ./read.sh
Salut, s'il vous plaît tapez le mot: quelque chose
Le mot que vous avez entré est : quelque chose
Pouvez-vous saisir deux mots ?
Linux Debian
Voici votre entrée : "Debian" "Linux"
Que pensez-vous des scripts bash ?
bien
Vous avez dit bien, je suis content de l'entendre!
Quelles sont tes couleurs préférées?
bleu vert noir
Mes couleurs préférées sont aussi le bleu, le vert et le noir :-)

7. Utiliser le piège

#!/bin/bash
# déclarer un piège
piège bashtrap INT
# effacer l'écran
clair;
# la fonction hook est exécutée lorsque l'utilisateur appuie sur CTRL-C :
# Affichera => Exécution de la sous-routine bash trap !
# mais le script continuera à s'exécuter
bashtrap()
{
echo "CTRL+C détecté !…exécution de bash trap !"
}
# le script comptera jusqu'à 10
pour a dans `seq 1 10` ; faire
echo "$a/10 pour quitter."
sommeil1 ;
fait
echo "Exit Bash Trap Example !!!"

Code : Sélectionnez tous les $ ./trap.sh
1/10
2/10
3/10
4/10
5/10
6/10

7/10
8/10
9/10
CTRL+C détecté !...exécution d'un piège bash !
10/10
Exit Bash Trap Exemple !!!

Comme vous pouvez le voir, la combinaison de touches Ctrl-C n'a pas arrêté l'exécution du script.

8. Tableaux
8.1 Déclarer un tableau simple

#!/bin/bash
# Déclarer un tableau simple avec 4 éléments
TABLEAU=('Debian Linux' 'Redhat Linux' Linux Ubuntu)
# Récupère le nombre d'éléments du tableau
ÉLÉMENTS=$(#TABLEAU[@])

# boucle sur chaque élément du tableau
pour ((i=0;i<$ELEMENTS;i++)); do
echo $(TABLEAU[$(i)])
fait

Code : Sélectionnez tous les $./arrays.sh
Linux Debian
redhat linux
ubuntu
linux

8.2 Remplir un tableau avec des valeurs d'un fichier

#!/bin/bash
# Déclarer un tableau
déclarer -a TABLEAU
# commande exec # stdin (généralement le clavier) sera produit à partir de ce fichier. Cela permet de lire
# le contenu du fichier, ligne par ligne, et analyse chaque ligne entrée avec sed et/ou awk.
exécutable 10 letcount=0

en lisant LINE<&10; do

TABLEAU[$count]=$LINE
((compter++))
fait

echo Nombre d'éléments : $(#ARRAY[@])
# Afficher les valeurs du tableau
echo $(TABLEAU[@])
# fermer le fichier
exec 10>&-

Code : Sélectionnez tous les $ cat bash.txt
Linux Debian
redhat linux
ubuntu
linux
$ ./tableaux.sh
Nombre d'éléments : 4
Debian Linux Redhat Linux Ubuntu Linux

9. Conditions si-alors-sinon
9.1. Utilisation simple des conditions "if-else"
Faites attention aux espaces entre crochets, sans lesquels la condition ne fonctionnera pas.

#!/bin/bash
répertoire="./BashScripting"

# vérifie si le répertoire existe
if [ -d $répertoire ]; alors
echo "Le répertoire existe"
autre
echo "Le répertoire n'existe pas"
Fi

Code : Sélectionnez tous les $ ./if_else.sh
Le répertoire n'existe pas
$ mkdir BashScripting
$ ./if_else.sh
Le répertoire existe

9.2 Conditions if-else imbriquées

#!/bin/bash
# Déclarer une variable avec la valeur 4
choix=4
# Afficher
écho "1. frapper"
écho "2. Scénarisation»
écho "3. Didacticiel"

# Exécuter tant que la variable est égale à quatre
# boucle
tandis que [ $choix -eq 4 ]; faire

# lire l'entrée de l'utilisateur
choix de lecture
# condition "if-else" imbriquée
if [ $choix -eq 1 ] ; alors

echo "Vous avez choisi le mot : Bash"

if [ $choix -eq 2 ] ; alors
echo "Vous avez choisi le mot : Scripting"
autre

if [ $choix -eq 3 ] ; alors
echo "Vous avez choisi le mot : Tutoriel"
autre
echo "Veuillez faire un choix entre 1 et 3 !"
écho "1. frapper"
écho "2. Scénarisation»
écho "3. Didacticiel"
echo -n "Veuillez choisir un mot ? »
choix=4
Fi
Fi
Fi
fait

Code : Sélectionnez tous les $ ./nested.sh
1. frapper
2. Script
3. Tutoriel

5

1. frapper
2. Script
3. Tutoriel
Veuillez choisir un mot
4
Veuillez faire un choix entre 1 et 3 !
1. frapper
2. Script
3. Tutoriel
Veuillez choisir un mot
3
Vous avez choisi le mot : Tutoriel

Ainsi, le corps de la boucle "while" est d'abord exécuté, car la variable de choix est initialement fixée à quatre. Ensuite, nous y lisons l'entrée de l'utilisateur, et si l'entrée n'est pas égale à 1,2 ou 3, nous rendons à nouveau notre variable égale à 4, en relation avec laquelle le corps de la boucle se répète (vous devez saisir à nouveau 1,2 ou 3).

10. Comparaisons
10.1 Comparaisons arithmétiques

Lt<
-gt>
-le<=
-ge >=
-eq ==
-ne !=

#!/bin/bash

NUM1=2
NUM2=2
si [ $NUM1 -eq $NUM2 ] ; alors
echo "Les deux valeurs sont égales"
autre
echo "Les valeurs ne sont PAS égales"
Fi

Code : Sélectionnez tous les $ ./equals.sh
Les deux valeurs sont égales

#!/bin/bash
# Déclarer des variables avec des valeurs entières
NUM1=2
NUM2=3
si [ $NUM1 -eq $NUM2 ] ; alors
echo "Les deux valeurs sont égales"
autre
echo "Les valeurs ne sont PAS égales"
Fi

Code : Sélectionnez tous les $ ./equals.sh
Les valeurs ne sont PAS égales

#!/bin/bash
# Déclarer des variables avec des valeurs entières
NUM1=2
NUM2=1
si [ $NUM1 -eq $NUM2 ] ; alors
echo "Les deux valeurs sont égales"
elif [ $NUM1 -gt $NUM2 ] ; alors
echo "$NUM1 est supérieur à $NUM2"
autre
echo "$NUM2 est supérieur à $NUM1"
Fi

Code : Sélectionnez tous les $ ./equals.sh
2 est plus grand que 1

10.2 Comparaisons caractère-texte

Le même
!= pas pareil
< меньще чем
> plus de
-n s1 la variable s1 n'est pas vide
-z s1 la variable s1 est vide

#!/bin/bash

S1="Bash"

S2="Script"
si [ $S1 = $S2 ] ; alors

autre
echo "Les chaînes ne sont PAS égales"
Fi

Code : Sélectionnez tous les $ ./statement.sh
Les chaînes ne sont PAS égales

#!/bin/bash
# Déclarer la variable symbolique S1
S1="Bash"
# Déclarer la variable symbolique S2
S2="Bash"
si [ $S1 = $S2 ] ; alors
echo "Les deux chaînes sont égales"
autre
echo "Les chaînes ne sont PAS égales"
Fi

Code : Sélectionnez tous les $ ./statement.sh
Les deux chaînes sont égales

11. Vérification des fichiers

Nom du fichier B Bloc fichier spécial
-c nomfichier Fichier de caractères spéciaux
-d nom_répertoire Vérifie l'existence du répertoire
-e nom_fichier Vérifie l'existence du fichier
-f filename Vérifie l'existence d'un fichier normal et non d'un répertoire
-G filename Vérifie si le fichier existe et appartient à l'ID de groupe effectif.
-g filename true si le fichier existe et est set-group-id.
-k nom de fichier Sticky bit
-L nom du fichier Lien symbolique
-O filename Vrai si le fichier existe et appartient à l'ID utilisateur effectif.
-r filename Vérifie si le fichier est lisible
-S filename Vérifie si le fichier est socket
-s filename Vérifie si le fichier est de taille différente de zéro
-u filename Vérifie si le bit set-ser-id du fichier est défini
-w filename Vérifie si le fichier est accessible en écriture
-x filename Vérifie si le fichier est exécutable

#!/bin/bash
fichier="./fichier"
if [ -e $fichier ]; alors
echo "Le fichier existe"
autre
echo "Le fichier n'existe pas"
Fi

Code : Sélectionnez tous les $ ls
fichier.sh
$ ./fichier.sh
Fichier ne existe pas
$ touchez le fichier
$ls
fichier fichier.sh
$ ./fichier.sh
le fichier existe

De même pour l'exemple, nous pouvons utiliser des boucles "while" pour vérifier si le fichier n'existe pas. Ce script va dormir jusqu'à ce que le fichier existe. Notez le Bash négatif "!" qui annule (inverse) l'option -e.

12. Cycles
12.1. Pour la boucle

#!/bin/bash
# pour la boucle
pour f dans $(ls /var/); faire
echo $f
fait

Exécution d'une boucle for à partir de la ligne de commande bash :

Code : Sélectionnez tous les $ pour f dans $(ls /var/); faites echo $f; done Code : Sélectionnez tous les $ pour f dans $(ls /var/); faites echo $f; fait
sauvegardes
cache
accident
Jeux
bibliothèque
local
serrure
enregistrer
poster
opter
courir
bobine
tmp
www

12.2. boucle while

#!/bin/bash
COMPTER=6
# boucle while
tandis que [ $COUNT -gt 0 ] ; faire

soit COUNT=COUNT-1
fait

Code : Sélectionnez tous les $ ./while_loop.sh
La valeur du nombre est : 6
La valeur du compte est : 5
La valeur du compte est : 4
La valeur du nombre est : 3
La valeur du nombre est : 2
La valeur du nombre est : 1

12.3. jusqu'à la boucle

#!/bin/bash
COMPTER=0
boucle #jusqu'à
jusqu'à [ $COUNT -gt 5 ] ; faire
echo La valeur de count est : $COUNT
soit COUNT=COUNT+1
fait

Code : Sélectionnez tous les $ ./until_loop.sh
La valeur du compte est : 0
La valeur du nombre est : 1
La valeur du nombre est : 2
La valeur du nombre est : 3
La valeur du compte est : 4
La valeur du compte est : 5

12.4. Boucles avec conditions implicites
Dans l'exemple suivant, la condition de la boucle while est la présence d'une entrée standard.
Le corps de la boucle s'exécutera tant qu'il y aura quelque chose à rediriger de la sortie standard vers la commande de lecture.

#!/bin/bash
# Ce script trouvera et supprimera les espaces
# dans les fichiers, en les remplaçant par des traits de soulignement
DIR="."
Contrôle de la boucle avec la commande read en redirigeant la sortie dans la boucle.
trouver $DIR -type f | pendant la lecture du fichier ; faire
# utilise la classe POSIX [:space:] pour trouver des espaces dans les noms de fichiers
if [[ "$file" = *[[:space:]]* ]] ; alors
# remplacer les espaces par des traits de soulignement
mv "$fichier" `echo $fichier | tr ‘ ‘ ‘_’`
Fi;
fait

Code : Sélectionnez tous les $ ls -1
script.sh
$ touch "fichier avec espaces"
$ ls -1
fichier avec des espaces
script.sh
$ ./script.sh
$ ls -1
fichier_avec_espaces
script.sh

13. Fonctions

#!/bin/bash
# Les fonctions peuvent être déclarées dans n'importe quel ordre
fonction fonction_B(
écho Fonction B.
}
fonction fonction_A(
écho $1
}
fonction fonction_D(
écho Fonction D.
}
fonction_C(
écho $1
}
# Fonctions d'appel
# passer le paramètre à la fonction A
function_A "Fonction A."
fonction_B
# passer le paramètre à la fonction C fonction
function_C "Fonction C."
fonction_D

Code : Sélectionnez tous les $ ./functions.sh
Fonction A
Fonction B
Fonction C
Fonction D

14. Sélectionnez l'opérateur - Sélectionnez

#!/bin/bash
PS3='Choisissez un mot :'
# sélectionner
sélectionner un mot dans "linux" "bash" "script" "tutoriel"
faire
echo "Le mot que vous avez sélectionné est : $mot"
# Break, sinon la boucle sera infinie.
casser
fait
sortie 0

Code : Tout sélectionner $ ./select.sh
1) linux
2) frapper
3) script
4) tutoriel
Choisissez un mot : 4
Le mot que vous avez sélectionné est : tutoriel

15. Opérateur de sélection - Cas

#!/bin/bash
echo "Quel est votre langage de programmation/script préféré"
echo "1) bash"
echo "2) perle"
echo "3) phyton"
echo "4) c++"
echo "5) Je ne sais pas !"
lire la casse ;
# une structure de choix de cas simple
# notez que dans cet exemple $case n'est qu'une variable
# et n'a pas à s'appeler ainsi. C'est juste un exemple
$cas dans
1) echo "Vous avez sélectionné bash" ;;
2) echo "Vous avez sélectionné perl" ;;
3) echo "Vous avez sélectionné phyton" ;;
4) echo "Vous avez sélectionné c++" ;;
5) sortie
esac

Code : Tout sélectionner $ ./case.sh
Quel est votre langage de programmation/script préféré
1) frapper
2) perle
3) phyton
4) C++
5) Je ne sais pas !
4
Vous avez sélectionné c++

———————————————————————————-

Des informations plus détaillées peuvent être obtenues auprès de diverses sources, par exemple ici
d'origine : https://www.linuxconfig.org/Bash_scripting_Tutorial
https://ruslandh.narod.ru/howto_ru/Bash-Prog-Intro/
https://bug.cf1.ru/2005-03-17/programmin … -book.html

https://ubuntologia.ru/forum/viewtopic.php?f=109&t=2296

Aujourd'hui, nous allons parler des scripts bash. Ce sont des scripts de ligne de commande écrits pour le shell bash. Il existe d'autres shells, tels que zsh, tcsh, ksh, mais nous nous concentrerons sur bash. Ce matériel est destiné à tout le monde, la seule condition est de pouvoir travailler sur la ligne de commande Linux.

Les scripts de ligne de commande sont des ensembles des mêmes commandes qui peuvent être saisies à partir du clavier, rassemblées dans des fichiers et unies par un objectif commun. Dans le même temps, les résultats du travail des équipes peuvent soit avoir une valeur indépendante, soit servir d'input pour d'autres équipes. Les scripts sont un moyen puissant d'automatiser les actions fréquemment effectuées.

Ainsi, si nous parlons de la ligne de commande, elle permet d'exécuter plusieurs commandes à la fois, en les saisissant avec un point-virgule :

pwd ; qui suis je
En fait, si vous avez essayé cela dans votre terminal, votre premier script bash utilisant deux commandes a déjà été écrit. Cela fonctionne comme ça. La commande pwd affiche d'abord des informations sur le répertoire de travail actuel, puis la commande whoami affiche des informations sur l'utilisateur sous lequel vous êtes connecté.

En utilisant une approche similaire, vous pouvez combiner autant de commandes que vous le souhaitez sur une seule ligne, la limite est uniquement le nombre maximum d'arguments pouvant être transmis au programme. Vous pouvez définir cette limite avec la commande suivante :

Getconf ARG_MAX
La ligne de commande est un excellent outil, mais vous devez y saisir des commandes chaque fois que vous en avez besoin. Et si nous écrivions un ensemble de commandes dans un fichier et appelions simplement ce fichier pour les exécuter ? En fait, le fichier dont nous parlons s'appelle le script de ligne de commande.

Comment fonctionnent les scripts bash

Créez un fichier vide à l'aide de la commande touch. Dans sa première ligne, vous devez spécifier quel shell nous allons utiliser. Nous sommes intéressés par bash , donc la première ligne du fichier sera :

#!/bin/bash
Ailleurs dans ce fichier, le symbole dièse est utilisé pour indiquer les commentaires que le shell ne traite pas. Cependant, la première ligne est un cas particulier, où un dièse suivi d'un point d'exclamation (appelé shebang) et le chemin vers bash indiquent au système que le script a été écrit spécifiquement pour bash .

Les commandes shell sont séparées par un saut de ligne, les commentaires sont séparés par un signe dièse. Voici à quoi ça ressemble :

#!/bin/bash # Ceci est un commentaire pwd whoami
Ici, tout comme sur la ligne de commande, vous pouvez écrire des commandes sur une seule ligne, en les séparant par un point-virgule. Cependant, si vous écrivez des commandes sur des lignes différentes, le fichier est plus facile à lire. Dans tous les cas, le shell les traitera.

Définition des autorisations sur un fichier de script

Enregistrez le fichier en le nommant myscript et vous avez presque terminé avec le script bash. Maintenant, la seule chose à faire est de rendre ce fichier exécutable, sinon, lorsque vous essayez de l'exécuter, vous rencontrerez une erreur d'autorisation refusée.

Tentative d'exécution d'un fichier de script avec des autorisations mal configurées

Rendons le fichier exécutable :

Chmod +x ./monscript
Essayons maintenant de l'exécuter :

./monscript
Après avoir défini les autorisations, tout fonctionne comme il se doit.

Exécuter avec succès le script bash

Sortie des messages

La commande echo est utilisée pour imprimer du texte sur la console Linux. Utilisons la connaissance de ce fait et éditons notre script, en ajoutant des explications aux données qui génèrent déjà les commandes :

#!/bin/bash # notre commentaire est ici echo "Le répertoire courant est :" pwd echo "L'utilisateur connecté est :" whoami
Voici ce qui se passe après l'exécution du script mis à jour.

Sortie de messages à partir d'un script

Nous pouvons maintenant afficher des étiquettes explicatives à l'aide de la commande echo. Si vous ne savez pas comment modifier un fichier à l'aide des outils Linux ou si vous n'avez jamais rencontré la commande echo auparavant, consultez cet article.

Utilisation de variables

Les variables vous permettent de stocker des informations dans le fichier de script, par exemple, les résultats des commandes à utiliser par d'autres commandes.

Il n'y a rien de mal à exécuter des commandes individuelles sans stocker les résultats de leur travail, mais les possibilités de cette approche sont très limitées.

Il existe deux types de variables pouvant être utilisées dans les scripts bash :

• Variables d'environnement
• Variables utilisateur

Variables d'environnement

Parfois, les commandes shell doivent fonctionner avec certaines données système. Par exemple, voici comment afficher le répertoire personnel de l'utilisateur actuel :

#!/bin/bash # display user home echo "La maison de l'utilisateur actuel est : $HOME"
Veuillez noter que nous pouvons utiliser la variable système $HOME entre guillemets doubles, cela n'empêchera pas le système de la reconnaître. Voici ce qui se passe si vous exécutez le script ci-dessus.

Utilisation d'une variable d'environnement dans un script

Mais que se passe-t-il si vous souhaitez afficher un signe dollar ? Essayons ça:

Echo "J'ai 1 $ en poche"
Le système détectera un signe dollar dans une chaîne délimitée par des guillemets et supposera que nous avons référencé une variable. Le script essaiera d'afficher la valeur de la variable indéfinie $1 . Ce n'est pas ce dont nous avons besoin. Ce qu'il faut faire?

Dans une situation comme celle-ci, l'utilisation du caractère de contrôle antislash avant le signe dollar aide :

Echo "J'ai \$1 dans ma poche"
Le script affichera maintenant exactement ce qui est attendu.

Utilisation d'une séquence d'échappement pour générer un signe dollar

Variables utilisateur

En plus des variables d'environnement, les scripts bash vous permettent de définir et d'utiliser vos propres variables dans le script. Ces variables conservent une valeur jusqu'à la fin du script.

Comme pour les variables système, les variables utilisateur sont accessibles à l'aide du signe dollar :
TNW-CUS-FMP - code promotionnel pour 10% de réduction sur nos services, disponible pour activation dans les 7 jours
#!/bin/bash # testing variables grade=5 person="Adam" echo "$person est un bon garçon, il est en classe $grade"
Voici ce qui se passe après l'exécution d'un tel script.

Variables personnalisées dans le script

Substitution de commande

L'une des fonctionnalités les plus utiles des scripts bash est la possibilité d'extraire des informations de la sortie des commandes et de les affecter à des variables, ce qui vous permet d'utiliser ces informations n'importe où dans le fichier de script.

Ceci peut être fait de deux façons.

• Avec le caractère de backtick "`"
• Avec la construction $()

Lorsque vous utilisez la première approche, veillez à ne pas utiliser un guillemet simple au lieu d'un backtick. La commande doit être entourée de deux icônes de ce type :

monrep=`pwd`
Dans la deuxième approche, la même chose s'écrit comme ceci :

monrep=$(mot de passe)
Et le script, au final, pourrait ressembler à ceci :

#!/bin/bash monrep=$(mot de passe) echo $monrep
Au cours de son travail, la sortie de la commande pwd sera stockée dans la variable mydir, dont le contenu, à l'aide de la commande echo, tombera dans la console.

Script qui enregistre les résultats de la commande dans une variable

Opérations mathématiques

Pour effectuer des opérations mathématiques dans un fichier de script, vous pouvez utiliser une construction comme $((a+b)) :

#!/bin/bash var1=$((5 + 5)) echo $var1 var2=$(($var1 * 2)) echo $var2

Opérations mathématiques dans un script

structure de contrôle si-alors

Dans certains scénarios, il est nécessaire de contrôler le flux d'exécution des commandes. Par exemple, si une certaine valeur est supérieure à cinq, une action doit être effectuée, sinon une autre. Ceci est applicable dans de nombreuses situations, et la construction de contrôle si-alors nous aidera ici. Dans sa forme la plus simple, cela ressemble à ceci :

Si commande alors commandes fi
Et voici un exemple de travail :

#!/bin/bash if pwd then echo "Ça marche" fi
Dans ce cas, si la commande pwd se termine avec succès, le texte "ça marche" sera affiché sur la console.

Utilisons les connaissances dont nous disposons et écrivons un scénario plus complexe. Disons que vous voulez trouver un utilisateur dans /etc/passwd , et si vous pouvez le trouver, signalez qu'il existe.

#!/bin/bash user=likegeeks if grep $user /etc/passwd then echo "L'utilisateur $user Existe" fi
C'est ce qui se passe après l'exécution de ce script.

Recherche d'utilisateurs

Ici, nous avons utilisé la commande grep pour trouver l'utilisateur dans le fichier /etc/passwd. Si la commande grep ne vous est pas familière, sa description se trouve ici.

Dans cet exemple, si l'utilisateur est trouvé, le script affichera un message approprié. Que faire si l'utilisateur est introuvable ? Dans ce cas, le script terminera simplement l'exécution sans rien nous dire. J'aimerais qu'il nous en parle également, alors améliorons le code.

La construction de contrôle if-then-else

Pour que le programme puisse rapporter à la fois les résultats d'une recherche réussie et d'un échec, nous utiliserons la construction if-then-else. Voici comment il est configuré :

si commande alors commandes sinon commandes fi
Si la première commande renvoie zéro, ce qui signifie qu'elle a réussi, la condition sera vraie et l'exécution ne descendra pas dans la branche else. Sinon, si quelque chose d'autre que zéro est renvoyé, ce qui signifie un échec ou un résultat faux, les commandes après le else seront exécutées.

Écrivons le script suivant :

#!/bin/bash user=anotherUser if grep $user /etc/passwd then echo "L'utilisateur $user existe" else echo "L'utilisateur $user n'existe pas" fi
Son exécution est allée le long de la branche else.

Exécution d'un script avec une construction if-then-else

Bon, passons à autre chose et interrogeons-nous sur des conditions plus difficiles. Que faire si vous devez vérifier non pas une condition, mais plusieurs ? Par exemple, si l'utilisateur requis est trouvé, un message doit s'afficher, si une autre condition est remplie, un autre message doit s'afficher, et ainsi de suite. Dans une telle situation, les conditions imbriquées nous aideront. Il ressemble à ceci :

Si commande1 alors commande elif commande2 alors commande fi
Si la première commande renvoie zéro, ce qui indique un succès, les commandes du premier bloc then seront exécutées, sinon, si la première condition est fausse, et si la deuxième commande renvoie zéro, le deuxième bloc de code sera exécuté.

#!/bin/bash user=anotherUser if grep $user /etc/passwd then echo "L'utilisateur $user existe" elif ls /home then echo "L'utilisateur n'existe pas mais de toute façon il y a un répertoire sous /home" fi
Dans un tel script, vous pouvez, par exemple, créer un nouvel utilisateur à l'aide de la commande useradd si la recherche ne renvoie aucun résultat, ou faire autre chose d'utile.

Comparaison des nombres

Dans les scripts, vous pouvez comparer des valeurs numériques. Vous trouverez ci-dessous une liste des commandes pertinentes.

n1 -eq n2 Renvoie true si n1 est égal à n2 .
n1 -ge n2 Renvoie true si n1 est supérieur ou égal à n2 .
n1 -gt n2 Renvoie true si n1 est supérieur à n2 .
n1 -le n2 Renvoie true si n1 est inférieur ou égal à n2 .
n1 -lt n2 Renvoie true si n1 est inférieur à n2 .
n1 -ne n2 Renvoie true si n1 n'est pas égal à n2 .

Par exemple, essayons l'un des opérateurs de comparaison. Notez que l'expression est entre crochets.

#!/bin/bash val1=6 if [ $val1 -gt 5 ] then echo "La valeur de test $val1 est supérieure à 5" else echo "La valeur de test $val1 n'est pas supérieure à 5" fi
Voici ce que cette commande affichera.

Comparer des nombres dans des scripts

La valeur de la variable val1 est supérieure à 5, par conséquent, la branche then de l'opérateur de comparaison est exécutée et le message correspondant est affiché dans la console.

Comparaison de chaînes

Les scripts peuvent également comparer des valeurs de chaîne. Les opérateurs de comparaison semblent assez simples, mais les opérateurs de comparaison de chaînes ont certaines particularités, que nous aborderons ci-dessous. Voici une liste d'opérateurs.

str1 = str2 Teste l'égalité des chaînes, renvoie vrai si les chaînes sont identiques.
s tr1 != str2 Renvoie vrai si les chaînes ne sont pas identiques.
chaîne1< str2 Возвращает истину, если str1 меньше, чем str2 .
str1 > str2 Renvoie vrai si str1 est supérieur à str2 .
-n str1 Renvoie true si la longueur de str1 est supérieure à zéro.
-z str1 Renvoie vrai si la longueur de str1 est zéro.

Voici un exemple de comparaison de chaînes dans un script :

#!/bin/bash user ="likegeeks" if [$user = $USER] then echo "L'utilisateur $user est l'utilisateur actuellement connecté" fi
À la suite de l'exécution du script, nous obtenons ce qui suit.

Comparaison de chaînes dans les scripts

Voici une caractéristique de la comparaison de chaînes qui mérite d'être mentionnée. A savoir, les opérateurs ">" et "<» необходимо экранировать с помощью обратной косой черты, иначе скрипт будет работать неправильно, хотя сообщений об ошибках и не появится. Скрипт интерпретирует знак «>' en tant que commande de redirection de sortie.

Voici à quoi ressemble le travail avec ces opérateurs dans le code :

#!/bin/bash val1=text val2="un autre texte" if [ $val1 \>
Voici les résultats du script.

Comparaison de chaînes, avertissement émis

Notez que le script, bien qu'il soit en cours d'exécution, donne un avertissement :

./monscript : ligne 5 : [ : trop d'arguments
Pour vous débarrasser de cet avertissement, placez $val2 entre guillemets :

#!/bin/bash val1=text val2="un autre texte" if [ $val1 \> "$val2" ] then echo "$val1 est supérieur à $val2" else echo "$val1 est inférieur à $val2" fi
Maintenant, tout fonctionne comme il se doit.

Comparaison de chaînes

Une autre caractéristique des ">" et "<» заключается в том, как они работают с символами в верхнем и нижнем регистрах. Для того, чтобы понять эту особенность, подготовим текстовый файл с таким содержимым:

Comme les geeks comme les geeks
Enregistrez-le sous le nom myfile , puis exécutez la commande suivante dans le terminal :

Trier monfichier
Il triera les lignes du fichier comme suit :

Comme les geeks Comme les geeks
La commande sort, par défaut, trie les chaînes dans l'ordre croissant, c'est-à-dire que la lettre minuscule dans notre exemple est inférieure à la lettre majuscule. Préparons maintenant un script qui comparera les mêmes chaînes :

#!/bin/bash val1=Likegeeks val2=likegeeks if [ $val1 \> $val2 ] then echo "$val1 est supérieur à $val2" else echo "$val1 est inférieur à $val2" fi
Si vous l'exécutez, il s'avère que le contraire est vrai - la lettre minuscule est maintenant plus grande que la majuscule.

Commande de tri et comparaison de chaînes dans le fichier de script

Dans les commandes de comparaison, les lettres majuscules sont plus petites que les lettres minuscules. La comparaison de chaînes se fait ici en comparant les codes de caractères ASCII, l'ordre de tri dépend donc des codes de caractères.

La commande de tri, à son tour, utilise l'ordre de tri spécifié dans les paramètres de langue du système.

Contrôles de fichiers

Les commandes ci-dessous sont peut-être utilisées le plus souvent dans les scripts bash. Ils vous permettent de vérifier diverses conditions concernant les fichiers. Voici une liste de ces commandes.

-d fichier Vérifie si le fichier existe et est un répertoire.
-e fichier Vérifie si un fichier existe.
-f fichier Vérifie si un fichier existe et est un fichier.
-r fichier Vérifie si le fichier existe et est lisible.
-s fichier Vérifie si le fichier existe et n'est pas vide.
-w fichier Vérifie si le fichier existe et est accessible en écriture.
-x fichier Vérifie si le fichier existe et est exécutable.
file1 -nt file2 Vérifie si file1 est plus récent que file2 .
file1 -ot file2 Vérifie si file1 est plus ancien que file2 .
-O fichier Vérifie si le fichier existe et appartient à l'utilisateur actuel.
-G fichier Vérifie si le fichier existe et si son ID de groupe correspond à l'ID de groupe de l'utilisateur actuel.

Ces commandes, ainsi que de nombreuses autres discutées aujourd'hui, sont faciles à retenir. Leurs noms, abréviations de divers mots, indiquent directement les contrôles qu'ils effectuent.

Essayons l'une des commandes en pratique :

#!/bin/bash mydir=/home/likegeeks if [ -d $mydir ] then echo "Le répertoire $mydir existe" cd $ mydir ls else echo "Le répertoire $mydir n'existe pas" fi
Ce script, pour un répertoire existant, affichera son contenu.

Lister le contenu d'un répertoire

Nous pensons que vous pouvez expérimenter vous-même le reste des commandes, elles s'appliquent toutes selon le même principe.

Résultats

Aujourd'hui, nous avons parlé de la façon de commencer à écrire des scripts bash et couvert certaines choses de base. En fait, le sujet de la programmation bash est énorme. Cet article est une traduction de la première partie d'une grande série de 11 matériaux. Si vous voulez continuer maintenant - voici une liste des originaux de ces documents. Par commodité, celui dont vous venez de lire la traduction est inclus ici.