Un shell est l'interpréteur de commandes du système d'exploitation. Bash est mon shell préféré, mais chaque shell Linux interprète les commandes tapées par l'utilisateur ou l'administrateur système sous une forme que le système d'exploitation peut utiliser. Lorsque les résultats sont retournés au programme shell, il les envoie à STDOUT qui, par défaut, les affiche dans le terminal. Tous les shells que je connais sont aussi des langages de programmation.
Des fonctionnalités telles que l'achèvement des onglets, le rappel et l'édition de la ligne de commande et les raccourcis tels que les alias contribuent tous à sa valeur en tant que shell puissant. Son mode d'édition de ligne de commande par défaut utilise Emacs, mais l'une de mes fonctionnalités préférées de Bash est que je peux le changer en mode Vi pour utiliser des commandes d'édition qui font déjà partie de ma mémoire musculaire.
Cependant, si vous considérez Bash uniquement comme un shell, vous manquez une grande partie de son véritable pouvoir. En faisant des recherches sur mon cours d'autoformation Linux en trois volumes (sur lequel cette série d'articles est basée), j'ai appris des choses sur Bash que je n'avais jamais connues en plus de 20 ans de travail avec Linux. Certaines de ces nouvelles connaissances concernent son utilisation en tant que langage de programmation. Bash est un langage de programmation puissant, parfaitement conçu pour être utilisé en ligne de commande et dans des scripts shell.
Cette série en trois parties explore l'utilisation de Bash comme langage de programmation d'interface de ligne de commande (CLI). Ce premier article examine quelques programmations simples en ligne de commande avec Bash, des variables et des opérateurs de contrôle. Les autres articles explorent les types de fichiers Bash ; opérateurs logiques de chaîne, numériques et divers qui fournissent une logique de contrôle de flux d'exécution ; différents types d'extensions de coque ; et le pour , pendant , et jusqu'à boucles qui permettent des opérations répétitives. Ils examineront également certaines commandes qui simplifient et prennent en charge l'utilisation de ces outils.
La coque
Un shell est l'interpréteur de commandes du système d'exploitation. Bash est mon shell préféré, mais chaque shell Linux interprète les commandes tapées par l'utilisateur ou l'administrateur système sous une forme que le système d'exploitation peut utiliser. Lorsque les résultats sont renvoyés au programme shell, il les affiche dans le terminal. Tous les shells que je connais sont aussi des langages de programmation.
Bash signifie Bourne Again Shell car le shell Bash est basé sur l'ancien shell Bourne écrit par Steven Bourne en 1977. De nombreux autres shells sont disponibles, mais ce sont les quatre que je rencontre le plus fréquemment :
- csh : Le shell C pour les programmeurs qui aiment la syntaxe du langage C
- ksh : Le shell Korn, écrit par David Korn et populaire auprès des utilisateurs d'Unix
- tcsh : Une version de csh avec des fonctionnalités plus simples d'utilisation
- zsh : La coque Z, qui combine de nombreuses fonctionnalités d'autres coques populaires
Tous les shells ont des commandes intégrées qui complètent ou remplacent celles fournies par les utilitaires principaux. Ouvrez la page de manuel du shell et recherchez la section "BUILT-INS" pour voir les commandes qu'il fournit.
Chaque shell a sa propre personnalité et sa propre syntaxe. Certains fonctionneront mieux pour vous que d'autres. J'ai utilisé le shell C, le shell Korn et le shell Z. J'aime toujours le shell Bash plus que n'importe lequel d'entre eux. Utilisez celui qui vous convient le mieux, même si cela peut vous obliger à en essayer d'autres. Heureusement, il est assez facile de changer de coque.
Tous ces shells sont des langages de programmation, ainsi que des interpréteurs de commandes. Voici une présentation rapide de certaines constructions et outils de programmation qui font partie intégrante de Bash.
Bash comme langage de programmation
La plupart des administrateurs système ont utilisé Bash pour émettre des commandes qui sont généralement assez simples et directes. Mais Bash peut aller au-delà de la simple saisie de commandes, et de nombreux administrateurs système créent de simples programmes en ligne de commande pour effectuer une série de tâches. Ces programmes sont des outils courants qui permettent d'économiser du temps et des efforts.
Mon objectif lors de l'écriture de programmes CLI est de gagner du temps et des efforts (c'est-à-dire d'être l'administrateur système paresseux). Les programmes CLI prennent en charge cela en répertoriant plusieurs commandes dans une séquence spécifique qui s'exécutent l'une après l'autre, vous n'avez donc pas besoin de surveiller la progression d'une commande et de saisir la commande suivante lorsque la première se termine. Vous pouvez aller faire autre chose et ne pas avoir à surveiller en permanence la progression de chaque commande.
Qu'est-ce qu'un "programme" ?
Le Free On-line Dictionary of Computing (FOLDOC) définit un programme comme :"Les instructions exécutées par un ordinateur, par opposition à l'appareil physique sur lequel elles s'exécutent." Le WordNet de l'Université de Princeton définit un programme comme suit :"… une séquence d'instructions qu'un ordinateur peut interpréter et exécuter…" Wikipédia a également une bonne entrée sur les programmes informatiques.
Par conséquent, un programme peut consister en une ou plusieurs instructions qui exécutent une tâche spécifique et connexe. Une instruction de programme informatique est également appelée instruction de programme. Pour les administrateurs système, un programme est généralement une séquence de commandes shell. Tous les shells disponibles pour Linux, du moins ceux que je connais, ont au moins une forme de base de capacité de programmation, et Bash, le shell par défaut de la plupart des distributions Linux, ne fait pas exception.
Bien que cette série utilise Bash (parce qu'il est si omniprésent), si vous utilisez un shell différent, les concepts généraux de programmation seront les mêmes, bien que les constructions et la syntaxe puissent différer quelque peu. Certains shells peuvent prendre en charge certaines fonctionnalités que d'autres ne prennent pas en charge, mais ils offrent tous une certaine capacité de programmation. Les programmes shell peuvent être stockés dans un fichier pour une utilisation répétée, ou ils peuvent être créés sur la ligne de commande selon les besoins.
Programmes CLI simples
Les programmes de ligne de commande les plus simples sont une ou deux instructions de programme consécutives, qui peuvent être liées ou non, qui sont entrées sur la ligne de commande avant la Entrée touche est enfoncée. La deuxième instruction d'un programme, s'il y en a une, peut dépendre des actions de la première, mais ce n'est pas obligatoire.
Il y a aussi un peu de ponctuation syntaxique qui doit être clairement énoncée. Lorsque vous saisissez une seule commande sur la ligne de commande, appuyez sur Entrée key termine la commande avec un point-virgule implicite (; ). Lorsqu'il est utilisé dans un programme shell CLI saisi sur une seule ligne sur la ligne de commande, le point-virgule doit être utilisé pour terminer chaque instruction et la séparer de la suivante. La dernière instruction d'un programme shell CLI peut utiliser un point-virgule explicite ou implicite.
Un peu de syntaxe de base
Les exemples suivants clarifieront cette syntaxe. Ce programme consiste en une seule commande avec un terminateur explicite :
[student@studentvm1 ~]$ echo "Hello world." ;
Hello world.
Cela peut ne pas sembler être un programme, mais c'est le premier programme que je rencontre avec chaque nouveau langage de programmation que j'apprends. La syntaxe peut être un peu différente pour chaque langue, mais le résultat est le même.
Développons un peu ce programme trivial mais omniprésent. Vos résultats seront différents des miens car j'ai fait d'autres expériences, alors que vous n'aurez peut-être que les répertoires et fichiers par défaut qui sont créés dans le répertoire d'accueil du compte la première fois que vous vous connectez à un compte via le bureau de l'interface graphique.
[student@studentvm1 ~]$ echo "My home directory." ; ls ;
My home directory.
chapter25 TestFile1.Linux dmesg2.txt Downloads newfile.txt softlink1 testdir6
chapter26 TestFile1.mac dmesg3.txt file005 Pictures Templates testdir
TestFile1 Desktop dmesg.txt link3 Public testdir Videos
TestFile1.dos dmesg1.txt Documents Music random.txt testdir1
Cela a un peu plus de sens. Les résultats sont liés, mais les énoncés de programme individuels sont indépendants les uns des autres. Notez que j'aime mettre des espaces avant et après le point-virgule car cela rend le code un peu plus facile à lire. Essayez à nouveau ce petit programme CLI sans point-virgule explicite à la fin :
[student@studentvm1 ~]$ echo "My home directory." ; ls Il n'y a aucune différence dans la sortie.
Quelque chose à propos des variables
Comme tous les langages de programmation, le shell Bash peut gérer des variables. Une variable est un nom symbolique qui fait référence à un emplacement spécifique dans la mémoire qui contient une valeur quelconque. La valeur d'une variable est modifiable, c'est-à-dire qu'elle est variable.
Bash ne type pas les variables comme C et les langages associés, les définissant comme des entiers, des virgules flottantes ou des types de chaîne. Dans Bash, toutes les variables sont des chaînes. Une chaîne qui est un nombre entier peut être utilisée dans l'arithmétique des nombres entiers, qui est le seul type de calcul que Bash est capable de faire. Si des calculs plus complexes sont nécessaires, le bc La commande peut être utilisée dans les programmes et les scripts CLI.
Les variables sont des valeurs affectées et peuvent être utilisées pour faire référence à ces valeurs dans les programmes et les scripts CLI. La valeur d'une variable est définie à l'aide de son nom mais non précédée d'un $ signe. L'affectation VAR=10 définit la valeur de la variable VAR sur 10. Pour imprimer la valeur de la variable, vous pouvez utiliser l'instruction echo $VAR . Commencez par des variables textuelles (c'est-à-dire non numériques).
Les variables bash font partie de l'environnement shell jusqu'à ce qu'elles soient supprimées.
Vérifiez la valeur initiale d'une variable qui n'a pas été affectée ; il doit être nul. Attribuez ensuite une valeur à la variable et imprimez-la pour vérifier sa valeur. Vous pouvez faire tout cela dans un seul programme CLI :
[student@studentvm1 ~]$ echo $MyVar ; MyVar="Hello World" ; echo $MyVar ;
Hello World
[student@studentvm1 ~]$
Remarque :la syntaxe de l'affectation des variables est très stricte. Il ne doit y avoir aucun espace de part et d'autre de l'égal (= ) signer la déclaration d'affectation.
La ligne vide indique que la valeur initiale de MaVar est nul. La modification et la définition de la valeur d'une variable se font de la même manière. Cet exemple montre à la fois la valeur d'origine et la nouvelle valeur.
Comme mentionné, Bash peut effectuer des calculs arithmétiques entiers, ce qui est utile pour calculer une référence à l'emplacement d'un élément dans un tableau ou pour résoudre des problèmes mathématiques simples. Il ne convient pas au calcul scientifique ou à tout ce qui nécessite des décimales, comme les calculs financiers. Il existe de bien meilleurs outils pour ces types de calculs.
Voici un calcul simple :
[student@studentvm1 ~]$ Var1="7" ; Var2="9" ; echo "Result = $((Var1*Var2))"
Result = 63
Que se passe-t-il lorsque vous effectuez une opération mathématique qui aboutit à un nombre à virgule flottante ?
[student@studentvm1 ~]$ Var1="7" ; Var2="9" ; echo "Result = $((Var1/Var2))"
Result = 0
[student@studentvm1 ~]$ Var1="7" ; Var2="9" ; echo "Result = $((Var2/Var1))"
Result = 1
[student@studentvm1 ~]$
Le résultat est l'entier le plus proche. Notez que le calcul a été effectué dans le cadre de l'écho déclaration. Le calcul est effectué avant la commande echo englobante en raison de l'ordre de priorité Bash. Pour plus de détails, consultez la page de manuel de Bash et recherchez "priorité".
Opérateurs de contrôle
Les opérateurs de contrôle Shell sont l'un des opérateurs syntaxiques permettant de créer facilement des programmes de ligne de commande intéressants. La forme la plus simple du programme CLI consiste simplement à enchaîner plusieurs commandes dans une séquence sur la ligne de commande :
command1 ; command2 ; command3 ; command4 ; . . . ; etc. ;Ces commandes s'exécutent toutes sans problème tant qu'aucune erreur ne se produit. Mais que se passe-t-il lorsqu'une erreur survient ? Vous pouvez anticiper et autoriser les erreurs à l'aide de la fonction intégrée && et || Opérateurs de contrôle bash. Ces deux opérateurs de contrôle fournissent un certain contrôle de flux et vous permettent de modifier la séquence d'exécution du code. Le point-virgule est également considéré comme un opérateur de contrôle Bash, tout comme le caractère de saut de ligne.
Le && L'opérateur dit simplement, "si la commande1 réussit, alors exécutez la commande2. Si la commande1 échoue pour une raison quelconque, alors la commande2 est ignorée." Cette syntaxe ressemble à ceci :
command1 && command2Maintenant, regardez quelques commandes qui créeront un nouveau répertoire et, si cela réussit, en feront le répertoire de travail actuel (PWD). Assurez-vous que votre répertoire personnel (~ ) est le PWD. Essayez ceci d'abord dans /root , un répertoire auquel vous n'avez pas accès :
[student@studentvm1 ~]$ Dir=/root/testdir ; mkdir $Dir/ && cd $Dir
mkdir: cannot create directory '/root/testdir/': Permission denied
[student@studentvm1 ~]$
L'erreur a été émise par le mkdir commande. Vous n'avez pas reçu d'erreur indiquant que le fichier n'a pas pu être créé car la création du répertoire a échoué. Le && l'opérateur de contrôle a détecté le code de retour différent de zéro, donc le toucher la commande a été ignorée. Utilisation de && l'opérateur de contrôle empêche le toucher commande de s'exécuter car une erreur s'est produite lors de la création du répertoire. Ce type de contrôle de flux de programme en ligne de commande peut empêcher les erreurs de s'aggraver et de créer un véritable gâchis. Mais il est temps de se compliquer un peu.
Le || L'opérateur de contrôle vous permet d'ajouter une autre instruction de programme qui s'exécute lorsque l'instruction de programme initiale renvoie un code supérieur à zéro. La syntaxe de base ressemble à ceci :
command1 || command2 Cette syntaxe indique "Si la commande1 échoue, exécutez la commande2". Cela implique que si la commande1 réussit, la commande2 est ignorée. Essayez ceci en essayant de créer un nouveau répertoire :
[student@studentvm1 ~]$ Dir=/root/testdir ; mkdir $Dir || echo "$Dir was not created."
mkdir: cannot create directory '/root/testdir': Permission denied
/root/testdir was not created.
[student@studentvm1 ~]$
C'est exactement ce à quoi vous vous attendez. Comme le nouveau répertoire n'a pas pu être créé, la première commande a échoué, ce qui a entraîné l'exécution de la deuxième commande.
La combinaison de ces deux opérateurs offre le meilleur des deux. La syntaxe de l'opérateur de contrôle utilisant un certain contrôle de flux prend cette forme générale lorsque le && et || les opérateurs de contrôle sont utilisés :
preceding commands ; command1 && command2 || command3 ; following commandsCette syntaxe peut être énoncée comme suit :"Si la commande1 se termine avec un code de retour de 0, alors exécutez la commande2, sinon exécutez la commande3." Essayez-le :
[student@studentvm1 ~]$ Dir=/root/testdir ; mkdir $Dir && cd $Dir || echo "$Dir was not created."
mkdir: cannot create directory '/root/testdir': Permission denied
/root/testdir was not created.
[student@studentvm1 ~]$
Maintenant, essayez à nouveau la dernière commande en utilisant votre répertoire personnel au lieu de /root annuaire. Vous aurez la permission de créer ce répertoire :
[student@studentvm1 ~]$ Dir=~/testdir ; mkdir $Dir && cd $Dir || echo "$Dir was not created."
[student@studentvm1 testdir]$
La syntaxe de l'opérateur de contrôle, comme command1 &&command2 , fonctionne car chaque commande envoie un code de retour (RC) au shell qui indique si elle s'est terminée avec succès ou s'il y a eu un type d'échec lors de l'exécution. Par convention, un RC de zéro (0) indique un succès et tout nombre positif indique un certain type d'échec. Certains des outils que les administrateurs système utilisent renvoient simplement un (1) pour indiquer un échec, mais beaucoup utilisent d'autres codes pour indiquer le type d'échec qui s'est produit.
La variable shell Bash $? contient le RC de la dernière commande. Ce RC peut être vérifié très facilement par un script, la commande suivante dans une liste de commandes, ou même l'administrateur système directement. Commencez par exécuter une commande simple et vérifiez immédiatement le RC. Le RC sera toujours pour la dernière commande exécutée avant que vous ne la regardiez.
[student@studentvm1 testdir]$ ll ; echo "RC = $?"
total 1264
drwxrwxr-x 2 student student 4096 Mar 2 08:21 chapter25
drwxrwxr-x 2 student student 4096 Mar 21 15:27 chapter26
-rwxr-xr-x 1 student student 92 Mar 20 15:53 TestFile1
<snip>
drwxrwxr-x. 2 student student 663552 Feb 21 14:12 testdir
drwxr-xr-x. 2 student student 4096 Dec 22 13:15 Videos
RC = 0
[student@studentvm1 testdir]$
Le RC, dans ce cas, est égal à zéro, ce qui signifie que la commande s'est terminée avec succès. Essayez maintenant la même commande sur le répertoire personnel de root, un répertoire pour lequel vous n'avez pas les permissions :
[student@studentvm1 testdir]$ ll /root ; echo "RC = $?"
ls: cannot open directory '/root': Permission denied
RC = 2
[student@studentvm1 testdir]$
Dans ce cas, le RC est de deux ; cela signifie que l'autorisation a été refusée à un utilisateur non root pour accéder à un répertoire auquel l'utilisateur n'est pas autorisé à accéder. Les opérateurs de contrôle utilisent ces RC pour vous permettre de modifier la séquence d'exécution du programme.
Résumé
Cet article a examiné Bash en tant que langage de programmation et a exploré sa syntaxe de base ainsi que certains outils de base. Il a montré comment imprimer des données sur STDOUT et comment utiliser des variables et des opérateurs de contrôle. Le prochain article de cette série examine certains des nombreux opérateurs logiques Bash qui contrôlent le flux d'exécution des instructions.