IntroProgBash.pdf

(866 KB) Pobierz
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 parfaite
1
, 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]
[2]
[3]
Mendel Cooper,
Advanced Bash Scripting Guide
(http://tldp.org/LDP/abs/html).
Une traduction en français est disponible (http://abs.traduc.org).
Arnold Robbins, Nelson H. F. Beebe,
Introduction aux scripts shell,
Ed. O’Reilly, Paris,
2005.
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.
1.2.
1.3.
1.4.
1.5.
1.6.
2.
Les shells --------------------------------------------------------------------------------------------------------------- 5
Syntaxe d’une commande -------------------------------------------------------------------------------------------- 8
Commandes internes et externes ------------------------------------------------------------------------------------ 9
Modes d’exécution d’une commande ------------------------------------------------------------------------------ 11
Commentaires -------------------------------------------------------------------------------------------------------- 12
Fichiers shell --------------------------------------------------------------------------------------------------------- 13
Substitution de paramètres ------------------------------------------------------------------------------------------------ 15
2.1.
2.2.
2.3.
2.4.
2.5.
Variables -------------------------------------------------------------------------------------------------------------- 15
Paramètres de position et paramètres spéciaux------------------------------------------------------------------ 18
Suppression des ambiguïtés----------------------------------------------------------------------------------------- 24
Paramètres non définis ---------------------------------------------------------------------------------------------- 24
Suppression de variables-------------------------------------------------------------------------------------------- 26
3.
Substitution de commandes------------------------------------------------------------------------------------------------ 27
3.1.
3.2.
Présentation ---------------------------------------------------------------------------------------------------------- 27
Substitutions de commandes et paramètres régionaux ---------------------------------------------------------- 29
4.
Caractères et expressions génériques ------------------------------------------------------------------------------------ 31
4.1.
4.2.
Caractères génériques----------------------------------------------------------------------------------------------- 32
Expressions génériques---------------------------------------------------------------------------------------------- 35
5.
Redirections élémentaires-------------------------------------------------------------------------------------------------- 37
5.1.
5.2.
5.3.
Descripteurs de fichiers --------------------------------------------------------------------------------------------- 37
Redirections élémentaires------------------------------------------------------------------------------------------- 37
Tubes------------------------------------------------------------------------------------------------------------------- 42
6.
7.
Groupement de commandes ----------------------------------------------------------------------------------------------- 44
Code de retour --------------------------------------------------------------------------------------------------------------- 47
7.1.
7.2.
7.3.
7.4.
7.5.
7.6.
Paramètre spécial ?------------------------------------------------------------------------------------------------- 47
Code de retour d'un programme shell ----------------------------------------------------------------------------- 50
Commande interne exit ---------------------------------------------------------------------------------------------- 50
Code de retour d'une suite de commandes------------------------------------------------------------------------ 51
Résultats et code de retour------------------------------------------------------------------------------------------ 52
Opérateurs && et || sur les codes de retour------------------------------------------------------------------- 52
8.
Structures de contrôle case et while-------------------------------------------------------------------------------------- 55
8.1.
8.2.
Choix multiple case -------------------------------------------------------------------------------------------------- 55
Itération while -------------------------------------------------------------------------------------------------------- 56
9.
Chaînes de caractères ------------------------------------------------------------------------------------------------------- 61
3
9.1.
9.2.
9.3.
9.4.
9.5.
10.
10.1.
10.2.
11.
11.1.
11.2.
11.3.
11.4.
11.5.
11.6.
12.
12.1.
12.2.
12.3.
12.4.
13.
13.1.
13.2.
14.
14.1.
14.2.
14.3.
14.4.
14.5.
14.6.
14.7.
14.8.
14.9.
14.10.
Protection de caractères -------------------------------------------------------------------------------------------- 61
Longueur d'une chaîne de caractères ----------------------------------------------------------------------------- 62
Modificateurs de chaînes-------------------------------------------------------------------------------------------- 62
Extraction de sous-chaînes ----------------------------------------------------------------------------------------- 64
Remplacement de sous-chaînes------------------------------------------------------------------------------------- 65
Structures de contrôle for et if----------------------------------------------------------------------------------------- 67
Itération for ---------------------------------------------------------------------------------------------------------- 67
Choix if --------------------------------------------------------------------------------------------------------------- 69
Entiers et expressions arithmétiques --------------------------------------------------------------------------------- 75
Variables de type entier --------------------------------------------------------------------------------------------- 75
Commande interne ((------------------------------------------------------------------------------------------------ 75
Valeur d'une expression arithmétique ----------------------------------------------------------------------------- 77
Opérateurs ------------------------------------------------------------------------------------------------------------ 78
Structure for pour les expressions arithmétiques ---------------------------------------------------------------- 83
Exemple : les tours de Hanoi --------------------------------------------------------------------------------------- 84
Tableaux ------------------------------------------------------------------------------------------------------------------- 86
Définition et initialisation d’un tableau --------------------------------------------------------------------------- 86
Valeur d'un élément d'un tableau ---------------------------------------------------------------------------------- 87
Caractéristiques d'un tableau -------------------------------------------------------------------------------------- 88
Suppression d'un tableau-------------------------------------------------------------------------------------------- 89
Alias------------------------------------------------------------------------------------------------------------------------- 90
Création d’un alias -------------------------------------------------------------------------------------------------- 90
Suppression d’un alias ---------------------------------------------------------------------------------------------- 92
Fonctions shell ------------------------------------------------------------------------------------------------------------ 93
Définition d’une fonction-------------------------------------------------------------------------------------------- 93
Suppression d’une fonction ----------------------------------------------------------------------------------------- 96
Trace des appels aux fonctions ------------------------------------------------------------------------------------- 96
Arguments d’une fonction------------------------------------------------------------------------------------------- 97
Variables locales à une fonction ----------------------------------------------------------------------------------- 99
Exporter une fonction---------------------------------------------------------------------------------------------- 101
Commande interne return----------------------------------------------------------------------------------------- 103
Substitution de fonction ------------------------------------------------------------------------------------------- 104
Fonctions récursives ----------------------------------------------------------------------------------------------- 104
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 GNU
2
. 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

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin