Remerciez-le!

Remerciez @Admin pour avoir partagé cet document gratuitement, de la manière la plus simple, en partageant sur les réseaux sociaux.

Introduction à la programmation en Bash Version 0.1 Eric Sanchis IUT de Rodez,

Introduction à la programmation en Bash Version 0.1 Eric Sanchis IUT de Rodez, 33 avenue du 8 mai 1945, 12000 Rodez Tél : 05.65.77.10.80 – Fax : 05.65.77.10.81 – Internet : www.iut-rodez.fr Préface Interpréteur de commandes par défaut des systèmes GNU/Linux, bash est devenu pour les administrateurs système, un outil incontournable. Ce document présente les principales constructions syntaxiques de bash utilisées dans l’écriture des programmes shell (scripts shell). L’objectif premier a été de laisser de côté les redondances syntaxiques de ce langage de programmation, la subtilité des mécanismes de l’interpréteur, afin d’insister sur quelques concepts synthétiques tels que la substitution, la redirection ou le filtrage. Cet écrit étant destiné principalement aux étudiants de premier et deuxième cycle en informatique, j’ai choisi de le rédiger en adoptant un style 2Ex (1 Explication, 1 Exemple) qui devrait permettre au lecteur de mieux s’approprier chaque notion présentée. Ce dernier pourra ensuite aborder des publications plus extensives ou plus spécialisées. Cette publication étant loin d’être parfaite1, j’encourage le lecteur à me faire parvenir ses remarques ou suggestions, ainsi qu’à me signaler toute inexactitude (sanchis@iut-rodez.fr). Pour en savoir plus : [1] Mendel Cooper, Advanced Bash Scripting Guide (http://tldp.org/LDP/abs/html). Une traduction en français est disponible (http://abs.traduc.org). [2] Arnold Robbins, Nelson H. F. Beebe, Introduction aux scripts shell, Ed. O’Reilly, Paris, 2005. [3] Cameron Newham, Bill Rosenblatt, Le shell bash, 3ème édition, Ed. O’Reilly, Paris, 2006. Plate-forme logicielle utilisée : Interpréteur bash 3.1, système PC/Debian Licence : GNU Free Documentation License 1 Les exemples figurant dans ce document ont pour but d’illustrer les notions traitées. Il n’est donné aucune garantie quant à leur fonctionnement ou leurs effets. Table des matières 1. Introduction à bash ---------------------------------------------------------------------------------------------------------- 5 1.1. Les shells --------------------------------------------------------------------------------------------------------------- 5 1.2. Syntaxe d’une commande -------------------------------------------------------------------------------------------- 8 1.3. Commandes internes et externes ------------------------------------------------------------------------------------ 9 1.4. Modes d’exécution d’une commande ------------------------------------------------------------------------------11 1.5. Commentaires --------------------------------------------------------------------------------------------------------12 1.6. Fichiers shell ---------------------------------------------------------------------------------------------------------13 2. Substitution de paramètres ------------------------------------------------------------------------------------------------15 2.1. Variables --------------------------------------------------------------------------------------------------------------15 2.2. Paramètres de position et paramètres spéciaux------------------------------------------------------------------18 2.3. Suppression des ambiguïtés-----------------------------------------------------------------------------------------24 2.4. Paramètres non définis----------------------------------------------------------------------------------------------24 2.5. Suppression de variables--------------------------------------------------------------------------------------------26 3. Substitution de commandes------------------------------------------------------------------------------------------------27 3.1. Présentation ----------------------------------------------------------------------------------------------------------27 3.2. Substitutions de commandes et paramètres régionaux----------------------------------------------------------29 4. Caractères et expressions génériques------------------------------------------------------------------------------------31 4.1. Caractères génériques-----------------------------------------------------------------------------------------------32 4.2. Expressions génériques----------------------------------------------------------------------------------------------35 5. Redirections élémentaires--------------------------------------------------------------------------------------------------37 5.1. Descripteurs de fichiers ---------------------------------------------------------------------------------------------37 5.2. Redirections élémentaires-------------------------------------------------------------------------------------------37 5.3. Tubes-------------------------------------------------------------------------------------------------------------------42 6. Groupement de commandes-----------------------------------------------------------------------------------------------44 7. Code de retour ---------------------------------------------------------------------------------------------------------------47 7.1. Paramètre spécial ?-------------------------------------------------------------------------------------------------47 7.2. Code de retour d'un programme shell-----------------------------------------------------------------------------50 7.3. Commande interne exit----------------------------------------------------------------------------------------------50 7.4. Code de retour d'une suite de commandes------------------------------------------------------------------------51 7.5. Résultats et code de retour------------------------------------------------------------------------------------------52 7.6. Opérateurs && et || sur les codes de retour-------------------------------------------------------------------52 8. Structures de contrôle case et while--------------------------------------------------------------------------------------55 8.1. Choix multiple case --------------------------------------------------------------------------------------------------55 8.2. Itération while --------------------------------------------------------------------------------------------------------56 9. Chaînes de caractères-------------------------------------------------------------------------------------------------------61 3 9.1. Protection de caractères --------------------------------------------------------------------------------------------61 9.2. Longueur d'une chaîne de caractères -----------------------------------------------------------------------------62 9.3. Modificateurs de chaînes--------------------------------------------------------------------------------------------62 9.4. Extraction de sous-chaînes -----------------------------------------------------------------------------------------64 9.5. Remplacement de sous-chaînes-------------------------------------------------------------------------------------65 10. Structures de contrôle for et if-----------------------------------------------------------------------------------------67 10.1. Itération for ----------------------------------------------------------------------------------------------------------67 10.2. Choix if ---------------------------------------------------------------------------------------------------------------69 11. Entiers et expressions arithmétiques ---------------------------------------------------------------------------------75 11.1. Variables de type entier ---------------------------------------------------------------------------------------------75 11.2. Commande interne ((------------------------------------------------------------------------------------------------75 11.3. Valeur d'une expression arithmétique -----------------------------------------------------------------------------77 11.4. Opérateurs ------------------------------------------------------------------------------------------------------------78 11.5. Structure for pour les expressions arithmétiques ----------------------------------------------------------------83 11.6. Exemple : les tours de Hanoi ---------------------------------------------------------------------------------------84 12. Tableaux -------------------------------------------------------------------------------------------------------------------86 12.1. Définition et initialisation d’un tableau---------------------------------------------------------------------------86 12.2. Valeur d'un élément d'un tableau ----------------------------------------------------------------------------------87 12.3. Caractéristiques d'un tableau --------------------------------------------------------------------------------------88 12.4. Suppression d'un tableau--------------------------------------------------------------------------------------------89 13. Alias-------------------------------------------------------------------------------------------------------------------------90 13.1. Création d’un alias --------------------------------------------------------------------------------------------------90 13.2. Suppression d’un alias ----------------------------------------------------------------------------------------------92 14. Fonctions shell ------------------------------------------------------------------------------------------------------------93 14.1. Définition d’une fonction--------------------------------------------------------------------------------------------93 14.2. Suppression d’une fonction -----------------------------------------------------------------------------------------96 14.3. Trace des appels aux fonctions-------------------------------------------------------------------------------------96 14.4. Arguments d’une fonction-------------------------------------------------------------------------------------------97 14.5. Variables locales à une fonction -----------------------------------------------------------------------------------99 14.6. Exporter une fonction---------------------------------------------------------------------------------------------- 101 14.7. Commande interne return----------------------------------------------------------------------------------------- 103 14.8. Substitution de fonction ------------------------------------------------------------------------------------------- 104 14.9. Fonctions récursives----------------------------------------------------------------------------------------------- 104 14.10. Appels de fonctions dispersées dans plusieurs fichiers-------------------------------------------------------- 105 4 1. Introduction à bash 1.1. Les shells Sous Unix, on appelle shell l’interpréteur de commandes qui fait office d'interface entre l'utilisateur et le système d’exploitation. Les shells sont des interpréteurs : cela signifie que chaque commande saisie par l’utilisateur (ou lue à partir d’un fichier) est syntaxiquement vérifiée puis exécutée. Il existe de nombreux shells qui se classent en deux grandes familles : - la famille C shell (ex : csh, tcsh) - la famille Bourne shell (ex : sh, bash, ksh). zsh est un shell qui contient les caractéristiques des deux familles précédentes. Néanmoins, le choix d’utiliser un shell plutôt qu’un autre est essentiellement une affaire de préférence personnelle ou de circonstance. En connaître un, permet d’accéder aisément aux autres. Lorsque l’on utilise le système GNU/Linux (un des nombreux systèmes de la galaxie Unix), le shell par défaut est bash (Bourne Again SHell). Ce dernier a été conçu en 1988 par Brian Fox dans le cadre du projet GNU2. Aujourd’hui, les développements de bash sont menés par Chet Ramey. Un shell possède un double aspect : - un aspect environnement de travail - un aspect langage de programmation. 1.1.1. Un environnement de travail En premier lieu, un shell doit fournir un environnement de travail agréable et puissant. Par exemple, bash permet (entre autres) : - le rappel des commandes précédentes (gestion de l’historique) ; cela évite de taper plusieurs fois la même commande - la modification en ligne du texte de la commande courante (ajout, retrait, remplacement de caractères) en utilisant les commandes d’édition de l’éditeur de texte vi ou emacs - la gestion des travaux lancés en arrière-plan (appelés jobs) ; ceux-ci peuvent être démarrés, stoppés ou repris suivant les besoins - l’initialisation adéquate de variables de configuration (chaîne d’appel de l’interpréteur, chemins de recherche par défaut) ou la création de raccourcis de commandes (commande alias). Illustrons cet ajustement de configuration par un exemple. Le shell permet d’exécuter une commande en mode interactif ou bien par l'intermédiaire de fichiers de commandes (scripts). En mode interactif, bash affiche à l’écran une chaîne d’appel (appelée également prompt ou invite), qui se termine par défaut par le caractère # suivi d’un caractère espace pour l’administrateur système (utilisateur root) et par le caractère $ suivi d’un caractère espace pour les autres utilisateurs. Cette chaîne d’appel peut être relativement longue. Ex : sanchis@jade:/bin$ 2 http://www.gnu.org 5 Celle-ci est constituée du nom de connexion de l’utilisateur (sanchis), du nom de la machine sur laquelle l’utilisateur travaille (jade) et du chemin absolu du répertoire courant de l’utilisateur (/bin). Elle indique que le shell attend que l’utilisateur saisisse une commande et la valide en appuyant sur la touche entrée. Bash exécute alors la commande puis réaffiche la chaîne d’appel. Si l’on souhaite raccourcir cette chaîne d’appel, il suffit de modifier la valeur de la variable prédéfinie du shell PS1 (Prompt Shell 1). Ex : sanchis@jade:/bin$ PS1='$ ' $ pwd /home/sanchis => pwd affiche le chemin absolu du répertoire courant $ La nouvelle chaîne d’appel est constituée par le caractère $ suivi d’un caractère espace. 1.1.2. Un langage de programmation Les shells ne sont pas seulement des interpréteurs de commandes mais également de véritables langages de programmation. Un shell comme bash intègre : - les notions de variable, d’opérateur arithmétique, de structure de contrôle, de fonction, présentes dans tout langage de programmation classique, mais aussi - des opérateurs spécifiques (ex : |, ;) Ex : $ a=5 => affectation de la valeur 5 à la variable a $ $ echo $((a +3 )) => affiche la valeur de l’expression a+3 8 $ L’opérateur |, appelé tube, est un opérateur caractéristique des shells et connecte la sortie d’une commande à l’entrée de la commande suivante. Ex : $ ruptime iutbis up 56+22:50, 0 users, load 0.47, 0.48, 0.34 jade up 39+16:17, 2 users, load 0.00, 0.00, 0.00 mobile1 up 3+02:19, 0 users, load 0.00, 0.00, 0.00 mobile2 up 2+18:43, 0 users, load 0.00, 0.00, 0.00 quartz up 40+15:35, 2 users, load 0.00, 0.00, 0.00 sigma up 56+23:46, 1 user, load 0.00, 0.00, 0.00 $ $ ruptime | wc -l 6 $ La commande unix ruptime3 affiche les noms et autres informations relatives aux machines visibles sur le réseau. La commande unix wc munie de l’option l affiche le nombre de lignes qu’elle a été en mesure de lire. En connectant avec un tube la sortie de ruptime à l’entrée de la commande wc –l, on obtient le nombre de machines visibles du réseau. Même si au fil du temps de nouveaux types de données comme les entiers ou les tableaux ont été introduits dans certains shells, ces derniers manipulent essentiellement des chaînes de caractères : 3 La commande ruptime est contenue dans le paquetage rwho. Ce paquetage n’est pas systématiquement installé par les distributions Linux. 6 ce sont des langages de programmation orientés chaînes de caractères. C’est ce qui rend les shells à la fois si puissants et si délicats à utiliser. L’objet de ce document est de présenter de manière progressive les caractéristiques de bash comme langage de programmation. 1.1.3. Atouts et inconvénients des shells L’étude d’un shell tel que bash en tant que langage de programmation possède plusieurs avantages : - c’est un langage interprété : les erreurs peuvent être facilement localisées et traitées uploads/Industriel/ bash-linux.pdf