Guide Bash du débutant

Version française du livre Bash Guide for Beginners

Machtelt Garrels

Xalasys.com

Ykerb

Adaptation française 

Marc Blanc

Relecture de la version française 

Jerome Blondel

Relecture de la version française 

Jean-Philippe Guérard

Préparation de la publication de la v.f. 

Version 1.9.fr.1.1

2007-04-23

Table des matières

Introduction
1. Pourquoi ce guide ?
2. Qui devrait lire ce guide?
3. Nouvelles versions, traductions et disponibilité
4. Historique des révisions
5. Contributions
6. Observations et retours variés
7. information de Copyright
8. De quoi avez-vous besoin ?
9. Conventions employées dans ce document
10. Organisation de ce document
1. Bash et scripts Bash
1. Les langages de contrôle (Shell) courants
1.1. Les fonctions du Shell en général
1.2. Types de Shell
2. Avantages du Bourne Again SHell
2.1. Bash est le Shell GNU
2.2. Fonctionnalités offertes seulement par le Bash
3. L'exécution de commandes
3.1. Généralité
3.2. Les commandes intégrées du Shell
3.3. Exécuter un programme dans un script.
4. Construction de blocs
4.1. Construction de blocs Shell
5. Ecrire de bons scripts
5.1. Caractéristiques d'un bon script
5.2. Structure
5.3. Terminologie
5.4. Un mot sur l'ordre et la logique
5.5. Un exemple Bash script : mysystem.sh
5.6. Exemple : init script (NdT d'initialisation)
6. Résumé
7. Exercices
2. Ecrire et corriger des scripts
1. Créer et lancer un script
1.1. Écrire et nommer
1.2. script1.sh
1.3. Exécuter le script
2. Les bases du script
2.1. Quel Shell exécutera le script ?
2.2. Ajout de commentaires
3. Débugger (NdT : corriger) les scripts Bash
3.1. Débugger le script globalement
3.2. Débugger qu'une partie du script
4. Résumé
5. Exercices
3. L'environnement du Bash
1. Les fichiers d'initialisation du Shell
1.1. Les fichiers de configuration qui agissent sur tout le système
1.2. Les fichiers de configuration utilisateur
1.3. Modification des fichiers de configuration du Shell
2. Variables
2.1. Types de variables
2.2. Créer des variables
2.3. Exporter les variables
2.4. Variables réservées
2.5. Paramètres spéciaux
2.6. Script à finalités multiples grâce aux variables
3. Echappement et protection de caractères
3.1. Pourquoi protéger ou 'échapper' un caractère ?
3.2. Le caractère Echap (escape)
3.3. Les apostrophes
3.4. Les guillemets
3.5. Codage ANSI-C
3.6. Particularités
4. Le processus d'expansion de Shell
4.1. Généralité
4.2. L'expansion d'accolades
4.3. L'expansion du tilde
4.4. Paramètre Shell et expansion de variable
4.5. La substitution de commande
4.6. L'expansion arithmétique
4.7. La substitution de processus
4.8. Le découpage de mots
4.9. Expansion de noms de fichier
5. Alias
5.1. Que sont les alias ?
5.2. Créer et supprimer des alias
6. Plus d'options Bash
6.1. Afficher les options
6.2. Changer les options
7. Résumé
8. Exercices
4. Expressions régulières
1. Expressions régulières
1.1. Qu'est-ce qu'une expression régulière ?
1.2. Les métacaractères des expressions régulières
1.3. Expressions régulières basiques versus celles étendues
2. Exemples en utilisant grep
2.1. Qu'est-ce que grep ?
2.2. Grep et les expressions régulières
3. La correspondance de patron dans les fonctionnalités Bash
3.1. Intervalle de caractère
3.2. Classes de caractères
4. Résumé
5. Exercices
5. L'éditeur de flot GNU sed
1. Introduction
1.1. Qu'est-ce que sed ?
1.2. commandes sed
2. Opérations d'édition de modification
2.1. Afficher les lignes contenant un patron
2.2. Exclure les lignes contenant le patron
2.3. Intervalle de lignes
2.4. Trouver et remplacer avec sed
3. L'usage en mode différé de sed
3.1. Lire des commandes sed depuis un fichier
3.2. Ecrire des fichiers de résultat
4. Résumé
5. Exercices
6. Le langage de programmation GNU awk
1. Commencer avec gawk
1.1. Qu'est-ce que gawk ?
1.2. Commandes Gawk
2. Le programme d'affichage
2.1. Afficher les champs sélectionnés
2.2. Formater les champs
2.3. La commande print et les expressions régulières
2.4. Patrons particuliers
2.5. Les scripts Gawk
3. Les variables Gawk
3.1. Le séparateur de champs en entrée
3.2. Les séparateurs de résultat
3.3. Le nombre d'enregistrements
3.4. Les variables définies par l'utilisateur
3.5. Plus d'exemples
3.6. Le programme printf
4. Résumé
5. Exercices
7. Les instructions de condition
1. Introduction de if
1.1. Généralité
1.2. Applications simples de if
2. L'emploi avancé de if
2.1. les blocs if/then/else
2.2. Les blocs if/then/elif/else
2.3. Les instructions if imbriquées
2.4. Opérations booléennes
2.5. Emploi de l'instruction exit et du if
3. Utiliser les instructions case
3.1. Les conditions simplifiées
3.2. Exemple de script d'initialisation
4. Résumé
5. Exercices
8. Ecrire des scripts interactifs
1. Afficher les messages utilisateurs
1.1. Interactif ou pas ?
1.2. Utiliser la commande intégrée echo
2. Récupérer la saisie utilisateur
2.1. L'emploi de la commande intégrée read
2.2. Demander une entrée utilisateur
2.3. Redirection et descripteurs de fichiers
2.4. Fichier d'entrée et fichier de sortie
3. Résumé
4. Exercices
9. Tâches répétitives
1. La boucle loop
1.1. Comment ça marche ?
1.2. Exemples
2. La boucle while
2.1. Qu'est-ce que c'est ?
2.2. Exemples
3. La boucle until
3.1. Qu'est-ce que c'est ?
3.2. Exemple
4. Redirection d'entrée/sortie et boucles
4.1. Redirection des entrées
4.2. Redirection des sorties
5. Break et continue
5.1. L'intégrée break
5.2. L'intégrée continue
5.3. Exemples
6. Faire des menus avec l'intégrée select
6.1. Généralité
6.2. Sous-menus
7. L'intégrée shift
7.1. Qu'est-ce qu'elle fait ?
7.2. Exemples
8. Résumé
9. Exercices
10. Un peu plus sur les variables
1. Types de variables
1.1. Affectation générale de valeur.
1.2. Utiliser l'intégrée declare
1.3. Constantes
2. Variables tableau
2.1. Créer des tableaux
2.2. Invoquer les variables d'un tableau
2.3. Supprimer des variables tableau
2.4. Exemples de tableaux
3. Opérations sur les variables
3.1. Arithmétique sur les variables
3.2. Longueur de variable
3.3. Transformation de variables
4. Résumé
5. Exercices
11. Fonctions
1. Introduction
1.1. Qu'est-ce qu'une fonction ?
1.2. La syntaxe des fonctions
1.3. Les paramètres positionnels dans les fonctions
1.4. Afficher une fonction
2. Exemples de fonctions dans des scripts
2.1. Recyclage
2.2. Définir le chemin
2.3. Sauvegarde à distance
3. Résumé
4. Exercices
12. Trapper les signaux
1. Signaux
1.1. Introduction
1.2. Utilisation de signaux avec kill
2. Piéger les signaux
2.1. Généralité
2.2. Comment Bash interprète trap
2.3. Plus d'exemples
3. Résumé
4. Exercices
A. Possibilités du Shell
1. Fonctionnalités courantes
2. Fonctionnalités spécifiques
B. GNU Free Documentation License
1. Preamble
2. Applicability and definitions
3. Verbatim copying
4. Copying in quantity
5. Modifications
6. Combining documents
7. Collections of documents
8. Aggregation with independent works
9. Translation
10. Termination
11. Future revisions of this license
12. How to use this License for your documents
Glossaire
Index

Liste des illustrations

1. Couverture du Guide Bash du Débutant
2.1. script1.sh
3.1. Différentes invites pour des utilisateurs différents
6.1. Les champs dans awk
7.1. Test d'une ligne de commande avec if
7.2. Exemple employant les opérateurs booléens

Liste des tableaux

1. Conventions typographiques et d'usage
1.1. Vue générale des termes de programmation
2.1. Aperçu des options de débug
3.1. Variables réservées Bourne Shell
3.2. Les variables réservées de Bash
3.3. Les variables Bash spéciales
3.4. Opérateurs arithmétiques
4.1. Opérateurs d'expression régulière
5.1. Commandes d'édition Sed
5.2. Options Sed
6.1. Caractères de formatage pour gawk
7.1. Expressions primitives
7.2. Combinaison d'expressions
8.1. Séquences d'échappement reconnues par la commande echo
8.2. Options de l'intégrée read
10.1. Options de l'intégrée declare
12.1. Les signaux de contrôle dans Bash
12.2. Signaux courants de kill
A.1. Fonctionnalités courantes du Shell
A.2. Différences de fonctionnalités des Shell

Introduction

Table des matières

1. Pourquoi ce guide ?
2. Qui devrait lire ce guide?
3. Nouvelles versions, traductions et disponibilité
4. Historique des révisions
5. Contributions
6. Observations et retours variés
7. information de Copyright
8. De quoi avez-vous besoin ?
9. Conventions employées dans ce document
10. Organisation de ce document

La raison première de ce document est que beaucoup de gens trouvent le HOWTO trop court et incomplet, et le guide Bash Scripting trop poussé. Il n'y a rien entre ces deux extrêmes. J'ai aussi écrit ce guide selon le principe général que les guides de base devraient être gratuits, alors que peu le sont.

C'est un guide pratique qui, sans être toujours sérieux, essaye de donner des exemples d'usage plutôt que théoriques. Je l'ai en partie écrit parce que je ne suis pas emballée par les exemples dépouillés, hyper simplifiés écrits par des gens qui, sachant de quoi ils parlent, montrent de super possibilités du Bash, tellement hors contexte que vous ne pouvez vous imaginez leurs applications pratiques. Vous pouvez lire ce genre de documents après ce guide, lequel contient exercices et exemples qui aideront à survivre dans la vraie vie.

De par mon expérience en tant qu'utilisateur, administrateur et formateur sur système UNIX/Linux, je sais que des gens peuvent avoir des années d'interactions quotidiennes avec leur système sans avoir la moindre notion de l'automatisation de tâches. De sorte qu'ils pensent souvent que UNIX n'est pas convivial, et pire, ils ont l'impression que c'est lent et obsolète. Cette difficulté est de celles que peut palier ce guide.

Quiconque qui, travaillant sur un système de type UNIX, veut se simplifier la vie. Utilisateurs avancés ou administrateurs peuvent tirer bénéfice de la lecture de ce guide. Les lecteurs qui ont déjà pris en main le système via la ligne de commande apprendront les ficelles de l'écriture de 'shell' qui facilitent l'exécution des tâches quotidiennes. L'administration de système repose grandement sur l'écriture de 'shell'. Les tâches courantes sont automatisées avec de simples scripts. Ce document est plein d'exemples qui vous encourageront à écrire les vôtres et qui vous inciteront à améliorer ceux existants.

Prérequis — Ce qui n'est pas dans ce guide. Vous devriez :

Voir Introduction to Linux (ou votre miroir TLDP TLDP mirror) si vous ignorez l'un de ces aspects. Des informations complémentaires peuvent être trouvées dans la documentation de votre système (man ; info pages), ou là : the Linux Documentation Project.

La dernière édition se trouve à http://tille.xalasys.com/training/bash/. Vous devriez aussi la trouver à http://tldp.org/LDP/Bash-Beginners-Guide/html/index.html.

Ce guide est disponible imprimé chez Fultus.com.

Figure 1. Couverture du Guide Bash du Débutant

Couverture du guide, titre rouge vif sur fond bleu.

Ce guide a été traduit :

Une traduction française en cours, à relire.

Historique des versions
Version 1.9.fr.1.12007-04-23Y, JPG
Relectures de Marc Blanc et Jerome Blondel.
Version 1.9.fr.1.02007-04-01Y, JPG
Première version française.
Version 1.92006-10-10MG
Remarques des lecteurs ajoutées, index ajouté en utilisant les tags DocBook.
Version 1.82006-03-15MG
Exemple clarifié au Chap 4, correction du document « ici » au Chap 9, corrections typographiques, ajout d'un lien vers les traductions chinoises et ukrainienne, note et chose à savoir au sujet de awk au Chap 6.
Version 1.72005-09-05MG
Correction de typographie au Chap 3, 6 et 7, remarques de lecteurs ajoutées, ajout d'une note au Chap 7.
Version 1.62005-03-01MG
Debuggage mineur, ajout de mots clés, note au sujet du nouveau Bash 3.0, retrait d'une image vierge.
Version 1.52004-12-06MG
Changements du fait du nouveau domaine, corrections mineures.
Version 1.42004-10-18MG
Debuggage, ajout de quelques notes au Chap 9, repositionnement de vues écran avec les sections écran. Correction de typographie.
Version 1.32004-07-09MG
Ajout d'une image de traceur 1X1 pixel http://tille.xalasys.com/images/blank-bash.png, ajout object texte pour toutes les images, réparation d'un lien mort dans l'index, amélioration de la liste des signaux.
Version 1.22004-06-15MG
Ajout index, plus de repère dans les sections écrans.
Version 1.12004-05-22MG
Dernière relecture avant la mise sous presse, ajout d'exemples, vérification du sommaire, exercices, introduction arrangée.
Version 1.02004-04-27TM
Livraison initiale pour LDP, d'autres exercices, d'autres repères, moins d'erreurs et abus, ajout du glossaire.
Version 1.0-beta2003-04-20MG
Pre-version

Merci à tous les amis qui ont aidé (ou essayé) et à mon mari ; vos paroles d'encouragement ont rendu ce travail possible. Merci à tous les gens qui ont soumis anomalies, exemples et remarques — parmi plein, plein d'autres :

Remerciements special à Tabatha Marshall qui a bénévolement revu, et l'expression, et la grammaire. On forme une bonne équipe : elle travaille quand je dors. Et vice versa ; - )

Informations manquantes, liens invalides, erreurs de frappe, remarques ? Envoyer un mail à

La personne assurant le suivi du document.

Copyright © 2003-2005 Machtelt Garrels.

Permission est donnée pour copier, distribuer et/ou modifier ce document selon les termes de la Licence GNU Free Documentation, Version 1.1 ou ultérieure publiée par la Free Software Foundation, avec les Sections Invariantes : « New versions of this document », « Contributions », « Feedback » et « Copyright information », sans textes de couverture de garde ni de textes de couverture de dos. Une copie de la licence est incluse dans Annexe B, GNU Free Documentation License intitulée « GNU Free Documentation License ».

L'auteur et l'éditeur ont fait leur possible pour s'assurer de la validité des informations de ce livre. Cependant, le contenu de ce guide est mis à disposition sans garantie, que ce soit explicite ou implicite. Ni l'auteur, ni l'éditeur, ni un distributeur ne peuvent être tenu responsable des éventuels dommages ou conséquences résultant de l'application du contenu de ce guide.

Les logos, marques déposées et les symboles utilisés dans ce guide sont la propriété de leur dépositaire respectif.

Bash, téléchargeable à http://www.gnu.org/directory/GNU/. Le Bash accompagne à peu près tous les systèmes Linux, et se trouve maintenant sur un large éventail de systèmes UNIX.

Se compile aisément si vous avez besoin de le personnaliser, testé sur un large éventail d'UNIX, Linux, MS Windows, et autres systèmes.

Les conventions typographiques et d'usage suivantes apparaissent dans le texte :

Tableau 1. Conventions typographiques et d'usage

Type de textesens
« Texte entre guillemets »Citation de gens, texte rendu par l'ordinateur entre guillemets
reproduction de la vue du terminal
Capture des données saisies ou affichées sur le terminal, généralement rendue avec un fond gris clair.
commandeNom d'une commande qui peut être tapée sur la ligne de commande.
VARIABLENom d'une variable ou pointeur vers le contenu d'une variable, comme $VARNAME.
optionOption d'une commande, comme « l'option -a de la commande ls ».
argumentArgument d'une commande, comme dans « read man ls ».

commande options paramètres

Synopsis de commande ou emploi habituel, sur une ligne séparée.
NomDeFichierNom d'un fichier ou d'un répertoire, par exemple « se positionner dans le répertoire /usr/bin . »
ToucheTouches à frapper sur le clavier, exemple « taper Q pour quitter ».
BoutonBouton graphique sur lequel cliquer comme le bouton OK .
Menu → ChoixOptions à choisir dans un menu graphique, par exemple : « Choisir Aide → A propos de Mozilla dans votre navigateur. »
TerminologieTerme important ou concept : « Le noyau est le coeur du système. »
\
La barre oblique inversée affichée dans un terminal ou dans un synopsis de commande indique que la ligne n'est pas finie. (NdT : nous appelerons ce symbole l'échappement). En d'autres mots, si vous voyez une longue commande qui est découpée en plusieurs lignes, \ signifie « Ne pressez pas encore la touche Entrée encore ! »
Voir Chapitre 1, Bash et scripts BashLien vers sujets connexes dans ce guide.
L'auteurLien vers une ressource WEB externe.

Ce guide expose des concepts utiles dans la vie de tous les jours de l'utilisateur Bash assidu. Bien qu'une connaissance basique du shell soit requise, nous commençons par aborder les composants et pratiques de base dans les 3 premiers chapitres.

Les chapitres 4 à 6 abordent les outils de base qui sont utilisés régulièrement dans les scripts.

Les chapitres 8 à 12 abordent les constructions les plus courantes dans les scripts.

Tous les chapitres sont accompagnés d'exercices qui testent votre aptitude à aborder le chapitre suivant.

Chapitre 1. Bash et scripts Bash

Table des matières

1. Les langages de contrôle (Shell) courants
1.1. Les fonctions du Shell en général
1.2. Types de Shell
2. Avantages du Bourne Again SHell
2.1. Bash est le Shell GNU
2.2. Fonctionnalités offertes seulement par le Bash
3. L'exécution de commandes
3.1. Généralité
3.2. Les commandes intégrées du Shell
3.3. Exécuter un programme dans un script.
4. Construction de blocs
4.1. Construction de blocs Shell
5. Ecrire de bons scripts
5.1. Caractéristiques d'un bon script
5.2. Structure
5.3. Terminologie
5.4. Un mot sur l'ordre et la logique
5.5. Un exemple Bash script : mysystem.sh
5.6. Exemple : init script (NdT d'initialisation)
6. Résumé
7. Exercices

Résumé

Dans ce module d'introduction nous

  • Décrivons quelques Shell courants

  • Mettons en avant les avantages et possibilités du Bash GNU

  • Décrivons les blocs de constructions du Shell

  • Abordons les fichiers d'initialisation du Bash

  • Voyons comment le Shell exécute les commandes

  • Examinons quelques exemples simples de scripts

Le Shell UNIX interprète les commandes de l'utilisateur, qui sont soit directement entrées par celui-ci, ou qui peuvent être lues depuis un fichier appelé un script shell ou programme. Ces scripts sont interprétés, donc non compilés. Le Shell lit les commandes de chaque ligne du script et cherche ces commandes dans le système (voir Section 2, « Avantages du Bourne Again SHell »), alors qu'un compilateur convertit un programme en une forme lisible par la machine, un fichier exécutable - lequel peut alors être employé dans un script.

A part de passer des commandes au noyau, la tâche principale du Shell est de mettre en place un environnement utilisateur qui peut être configuré individuellement par le biais de fichiers de configuration.

Tout comme les gens connaissent une variété de langages, votre système UNIX généralement offre une variété de types de Shell  :

Le fichier /etc/shells donne un aperçu des Shells connus du système Linux  :

mia:~> cat /etc/shells
/bin/bash
/bin/sh
/bin/tcsh
/bin/csh

Votre Shell par défaut est déclaré dans le fichier /etc/passwd , comme cette ligne pour l'utilisateur mia :

mia:L2NOfqdlPrHwE:504:504:Mia Maya:/home/mia:/bin/bash

Pour permuter d'un Shell à un autre, simplement entrez le nom du nouveau Shell actif dans le terminal. Le système trouve le répertoire où le nom apparaît au moyen des paramètres de PATH, et puisqu'un Shell est un fichier exécutable (programme), le Shell courant l'active et il s'exécute. Une nouvelle invite est souvent affichée, du fait que chaque Shell a une interface propre :

mia:~> tcsh
[mia@post21 ~]$

Le projet GNU (ne pas confondre GNU et UNIX) offre des outils pour l'administration de système de type UNIX qui sont libres et qui respectent les standards UNIX.

Bash est un Shell compatible avec sh qui incorpore des spécificités utiles du Korn Shell (ksh) et du C Shell (csh). Il est censé se conformer à la norme IEEE POSIX P1003.2/ISO 9945.2 Standards des Shell et Outils. Il offre des améliorations fonctionnelles par rapport à sh pour la programmation et l'utilisation interactive ; ce qui inclut l'édition de commande en ligne, historique illimité des commandes, contrôle des travaux, fonctions Shell et alias, tableau indexé de taille illimitée, et l'arithmétique d'entiers dans toutes les bases depuis la base 2 jusqu'à la base 64. Bash peut exécuter la plupart des scripts sh sans modification.

Comme les autres projets GNU, le projet bash a été lancé pour préserver, protéger et promouvoir la liberté d'utiliser, étudier, copier, modifier et redistribuer les logiciels. Il est généralement admis que de telles conditions stimulent la créativité. Cela a été le cas avec le programme Bash, qui a beaucoup de fonctionnalités que les autres Shells n'offrent pas.

En plus de l'option permettant des commandes Shell à un caractère qui peut être configuré généralement avec la commande intégrée set, il y a plusieurs options multi-caractères que vous pouvez employer. Nous verrons quelques unes de ces options les plus usitées dans les chapitres suivants ; la liste complète peut être trouvée dans les pages info de Bash, Bash features → Invoking Bash.

Les fichiers de démarrage sont des scripts qui sont lus et exécutés par Bash quand il démarre. Les sous-sections suivantes décrivent diverses façons de démarrer le Shell, et le fichier de démarrage lu en conséquence.

Interactif signifie que vous pouvez entrer des commandes. Le Shell n'est pas lancé parce qu'un script a été activé. Un Shell de connection vous donne accès au Shell après qu'il vous ait authentifié, généralement en contrôlant le nom d'utilisateur et le mot de passe.

Fichiers lus :

Des messages d'erreur s'affichent si les fichiers de configuration existent mais sont illisibles. Si un fichier n'existe pas, Bash cherche le suivant.

Un Shell sans connexion signifie que l'accès ne nécessite pas d'authentification par le système. Par exemple, quand vous ouvrez un terminal par le biais d'une icone, ou d'un menu.

Fichiers lus :

Ce fichier est habituellement référencé dans ~/.bash_profile :

if [ -f ~/.bashrc ]; then . ~/.bashrc; fi

Voir Chapitre 7, Les instructions de condition pour plus d'informations sur la construction if.

Tous les scripts utilisent un Shell non-interactif. Ils sont programmés pour faire certaines tâches et ne peuvent être utilisés pour faire autre chose que ce pour quoi ils ont été prévus.

Fichiers lus :

PATH n'est pas utilisé pour la recherche de ces fichiers, donc mettre le chemin complet dans la variable si vous souhaitez en faire usage.

Bash essaye de se comporter comme le programme historique Bourne sh tout en se conformant à la norme POSIX.

Fichiers lus :

Quand il est invoqué de façon interactive, la variable ENV peut pointer vers des informations de démarrage suplémentaires.

Cette option est activée soit en employant l'intégrée set :

set -o posix

ou en appelant le Bash avec l'option --posix option. Bash essayera alors de respecter autant que possible la norme POSIX des Shell. Déclarer la variable POSIXLY_CORRECT fait la même chose.

Fichiers lus :

Fichiers lus quand le Shell est invoqué par rshd :

[Avertissement]Eviter l'usage d'outils à distance

Ayez à l'esprit les dangers de ces outils tels que rlogin, telnet, rsh et rcp. Leur usage présente des risques pour la confidentialité et la sécurité de par leur mode d'accès parce que des données non cryptées parcourent le réseau. Si vous avez le besoin d'outils à distance, transfert de fichiers et autres, utilisez une version de Secure SHell, c'est à dire SSH, disponible gratuitement ici : http://www.openssh.org. Divers programmes client sont disponibles aussi pour les systèmes non-UNIX, consulter votre miroir de logiciels.

Aucun fichier de démarrage n'est lu dans ce cas.

Un Shell interactif généralement lit et écrit depuis et sur un terminal utilisateur : les flux d'entrée et de sortie sont dirigés vers le terminal. Le mode interactif de Bash est activé quand la commande bash est invoquée sans les options rendant inactif, et sauf avec l'option qui permet de prendre l'entrée depuis une chaîne de caractères ou quand le Shell est invoqué de façon à lire l'entrée standard, ce qui autorise les paramètres positionnels (voir Chapitre 3, L'environnement du Bash ).

Test en examinant la variable spéciale -, il contient un 'i' quand le Shell est interactif :

eddy:~> echo $-
himBH

Dans un Shell non interactif, l'invite PS1, n'est pas paramétrée.

Différences dans le mode interactif :

Plus d'informations :

Les expressions conditionnelles sont utilisées dans la commande composée [[ et par les intégrées test et [.

Les expressions peuvent être unaire ou binaire. Une expression unaire est souvent utilisée pour examiner le statut d'un fichier. Vous avez seulement besoin d'un objet, exemple un fichier, pour tester une condition dessus.

Il y a aussi des opérateurs de comparaison de textes et de nombres ; ils sont binaires, puisqu'ils requièrent 2 objets pour effectuer le test. Si l'option FICHIER d'une expression est de la forme /dev/fd/N, alors le descripteur de fichier N est utilisé. Si l'option FICHIER d'une expression est de la forme /dev/stdin, /dev/stdout ou /dev/stderr, alors le descripteur de fichier 0, 1 ou 2 respectivement est utilisé.

Les conditions sont discutées en détail au Chapitre 7, Les instructions de condition.

Plus d'informations au sujet des descripteurs de fichiers à la Section 2.3, « Redirection et descripteurs de fichiers ».

Le Shell permet aux expressions arithmétiques d'être évaluées, en tant que processus d'expansion ou par l'intégrée let.

L'évaluation utilise des entiers de longueur fixe sans vérification de possible débordement de capacité, mais avec un contrôle de la division par 0 qui renvoie une erreur. Les opérateurs, leur ordre et leur associativité, sont pareil que dans le langage C, voir Chapitre 3, L'environnement du Bash.

Les alias permettent à une chaîne d'être substituée par un mot quand il est utilisé comme le premier mot d'une commande simple. Le Shell maintient une liste d'alias qui peuvent être déclarés ou supprimés avec les commandes alias et unalias.

Bash lit toujours au moins une ligne complète saisie avant d'exécuter une des commandes de cette ligne. L'alias est interprété quand la commande est lue, non pas quand elle est exécutée. De ce fait, une définition d'alias apparaissant sur la même ligne qu'une autre commande ne prendra effet qu'à la lecture de la ligne suivante. Les commandes suivant la définition de l'alias sur la ligne ne seront pas affectées par le nouvel alias.

Un alias est interprété quand la définition d'une fonction est lue, pas quand la fonction est exécutée, parce que la définition de fonction est elle-même une commande composée. En conséquence, l'alias défini dans une fonction n'est pas utilisable tant que la fonction n'a pas été exécutée.

Nous aborderons les alias en détail à la Section 5, « Alias ».

Bash fournit les variables sous la forme d'un tableau à une dimension . Toute variable peut être utilisée comme un tableau ; l'intégrée declare déclarera explicitement un tableau. Il n'y a pas de limite supérieure à la taille d'un tableau, ni de besoin de trier ou d'assigner de façon contiguë les valeurs. Les tableaux sont basés sur le zéro. Voir Chapitre 10, Un peu plus sur les variables.

La pile de répertoires est une liste des répertoires récemment visités. L'intégrée pushd ajoute des répertoires à la pile tout en changeant le répertoire courant, et l'intégrée popd enlève les répertoires spécifiés de la pile en positionant le répertoire courant comme étant celui qui vient d'être enlevé.

Le contenu peut être affiché avec la commande dirs ou en visualisant la variable DIRSTACK.

Plus d'informations au sujet du fonctionnement de ces mécanismes se trouvent dans les pages Bash info.

Bash permet de jouer avec l'invite de façon amusante. Voir la section Controlling the Prompt dans les pages info de Bash.

Quand il est invoqué avec rbash ou avec --restricted ou l'option -r , il se produit ceci :

Quand une commande qui appele un script Shell est exécutée, rbash annule toute restriction dans le Shell lancé dans lequel s'exécute ce script.

Plus d'informations :

Bash determine le type de programme qui doit être exécuté. Les programmes standards sont les commandes système qui existent sous forme compilée dans le système. Quand un tel programme est exécuté, un nouveau processus est créé parce que Bash lance une copie exacte de lui-même. Ce processus fils a le même environnement que son parent, seul l'identifiant est différent. Cette procédure est appellée forking.

Une fois que le processus a fourché, l'espace d'adresse du processus fils est renseigné avec ses propres informations. Ceci est fait grâce à un appel système par exec.

Le mécanisme fork-and-exec cependant substitue une ancienne commande par une nouvelle, tandis que l'environnement dans lequel le nouveau programme est exécuté reste le même, y compris la configuration des entrées/sorties, des variables d'environnement et des priorités. Ce mécanisme est employé pour créer tous les processus UNIX, donc il s'applique aussi au système d'opération Linux. Même le premier processus, init, avec l'ID 1, fourche dans la procédure de démarrage appelée bootstrapping.

Les commandes intégrées sont parties intégrantes du Shell lui-même. Quand le nom d'une commande intégrée est employé comme le premier mot d'une commande simple, le Shell exécute la commande directement, sans créer un nouveau processus. Les commandes intégrées sont nécessaires pour implanter des fonctionnalités impossibles ou difficiles à mettre en oeuvre par des outils externes.

Bash possède 3 types de commandes intégrées :

La plupart de ces intégrées seront abordées dans les chapitres suivants. Pour les commandes qui ne le seront pas, se référer aux pages Info.

Quand le programme en exécution est un script Shell, Bash créera un nouveau processus Bash en activant un fork. Ce sous-Shell lit les lignes du script une par une. Les commandes de chaque ligne sont lues, interprétées et exécutées comme si elles avaient été entrées au clavier.

Tandis que le sous-Shell opère sur chaque ligne du script, le Shell parent attend que le processus fils ait fini. Quand il n'y a plus de ligne à lire dans le script, le sous-Shell se termine. Le Shell parent s'active et affiche l'invite de nouveau.

Si la saisie n'est pas commentée, le Shell la lit et la divise en mots et opérateurs, selon les règles d'analyse qui déterminent la signification de chaque caractère saisi. Alors ces mots et opérateurs sont transformés en commandes et autres constructions, lesquels retournent un statut d'exécution qui peut être exploité. Le schéma fork-and-exec ci-dessus est appliqué seulement après que le Shell ait analysé la saisie selon le processus suivant :

Une simple commande Shell telle que touch file1 file2 file3 consiste en la commande elle-même suivie par des arguments, séparés par des espaces.

Les commandes Shell plus complexes sont des compositions variées de commandes simples : en tube lequel délivre le résultat d'une commande sur le canal d'entrée de la suivante, en boucle ou en construction de conditions, et encore d'autres façons. Quelques exemples :

ls | more

gunzip file.tar.gz | tar xvf -

Les fonctions Shell sont un moyen de grouper des commandes pour une exécution ultérieure par l'appel d'un nom pour le groupe. Elles sont exécutées tout comme des commandes « régulières ». Quand le nom de la fonction Shell est employé comme le nom d'une commande simple, la liste des commandes associées à cette fonction est exécutée.

Les fonctions Shell sont exécutées dans le contexte en cours du Shell, elles ne sont pas interprétées dans un nouveau processus.

Les fonctions sont expliquées au Chapitre 11, Fonctions.

Un paramètre est une entité qui mémorise une valeur. Cela peut être un nom, un nombre ou une valeur spéciale. Pour les besoins du Shell, une variable est un paramètre qui mémorise un nom. Une variable a une valeur et zéro ou plus attributs. Les variables sont créées avec l'intégrée declare.

Si aucune valeur ne lui est assignée, une variable prend la valeur nulle. Une variable peut être invalidée seulement avec l'intégrée unset.

L'assignation de variables est traitée à la Section 2, « Variables », l'utilisation poussée de variables au Chapitre 10, Un peu plus sur les variables.

L'expansion par le Shell est effectuée après que chaque ligne de commande ait été découpée en jetons ou morceaux. Voici les opérations d'expansion :

Nous traiterons ces types d'expansion à la Section 4, « Le processus d'expansion de Shell ».

Avant qu'une commande soit exécutée, ses flux d'entrée et de sortie peuvent être redirigés en employant un symbole spécial interprété par le Shell. La redirection peut aussi être employée pour ouvrir et fermer des fichiers dans l'environnement d'exécution du Shell.

A l'exécution d'une commande, les mots que l'analyse syntaxique a marqué comme assignation de variables (précédant le nom de commande) et comme redirection sont conservés pour y faire référence ultérieurement. Les mots qui ne sont pas des assignations de variables ou des redirections sont analysés ; le premier mot restant après cette analyse est considéré comme étant le nom de la commande et le reste ses arguments. Alors les opérations de redirections sont effectuées, puis les valeurs assignées aux variables sont interprétées (expansion). Si le résultat ne donne aucun nom de commande, les variables sont affectées dans l'environnement en cours.

Une part importante du travail du Shell est de localiser les commandes. Bash le fait de cette façon :

Quand un fichier contenant des commandes Shell est utilisé comme le premier argument n'étant pas une option à l'invocation de Bash (sans l'option -c ou l'option -s) un Shell non-interactif est lancé. Ce Shell cherche d'abord le fichier de script dans le répertoire en cours, puis cherche dans ceux de PATH si le fichier ne peut pas y être trouvé.

Ce guide traite principalement du dernier bloc de construction Shell : les scripts. Quelques considerations générales avant de continuer :

  1. Un script devrait s'exécuter sans erreurs.

  2. Il devrait accomplir la tâche pour laquelle il a été conçu.

  3. La logique du programme est clairement définie et apparente.

  4. Un script n'exécute pas des instructions inutiles.

  5. Les scripts devraient être réutilisables.

La structure d'un script est très flexible. Même si Bash permet beaucoup de liberté, vous devez mettre en oeuvre une logique rigoureuse, un contrôle des données, une efficacité qui permet à l'utilisateur qui exécute le script de le faire facilement et correctement.

Au moment d'écrire un nouveau script, posez-vous les questions suivantes :

La table ci-dessous donne un aperçu des termes de programmation avec lesquels vous devez vous familiariser :

Tableau 1.1. Vue générale des termes de programmation

TermesQu'est-ce que c'est ?
Contrôle de commandeTest du statut d'exécution (NdT : code retour) d'une commande pour déterminer si une portion du code doit être exécutée ou pas.
Branchement conditionnelUne instruction logique du programme qui détermine quelle alternative du programme exécuter ensuite.
Enchaînement logiqueLa conception du programme dans ses grandes lignes. Détermine la séquence logique des opérations de sorte que cela aboutisse à un résultat contrôlé.
BouclePartie de code qui s'exécute zéro fois ou plus.
Saisie de l'utilisateurDonnée fournie par une source externe(NdT périphérique de saisie) pendant que le programme tourne, qui peut être mémorisée et exploitée au besoin.

Afin d'accélérer les phases de développement, l'ordre logique du programme devrait être pensé à l'avance. C'est votre première étape quand vous développez un script.

Diverses méthodes peuvent être utilisées ; une des plus courantes est la constitution de listes. Lister les opérations nécessaires au programme vous permet de décrire chaque tâche. Les opérations unitaires peuvent être référencées par leur numéro dans la liste.

En utilisant vos propres mots pour déterminer les opérations à exécuter par votre programme il vous sera plus facile de créer un programme compréhensible. Ensuite, vous écrivez le langage compris par Bash.

L'exemple ci-dessous montre un tel enchaînement logique. Il décrit la rotation des fichiers journaux. Cet exemple montre la possible réitération d'une boucle, en fonction du nombre de fichiers journaux sur lesquels vous voulez paramétrer une rotation.

  1. Voulez-vous paramétrer la rotation de journaux ?

    1. Si oui :

      1. Indiquez le répertoire contenant les journaux sur lesquels la rotation se fera.

      2. Entrez le nom générique du fichier journal.

      3. Entrez le nombre de jours durant lesquels le journal doit être conservé.

      4. Enregistrer le paramétrage dans le fichier utilisateur 'crontab'.

    2. Si non, aller à l'étape 3.

  2. Voulez-vous paramétrer la rotation d'un autre ensemble de journaux ?

    1. Si oui : répéter étape 1.

    2. Si non, aller à l'étape 3.

  3. Fin

L'utilisateur va devoir saisir des données pour que le programme effectue quelque chose. La saisie de l'utilisateur doit être sollicitée et mémorisée. L'utilisateur devrait être informé que 'son' crontab va être changé.

Le script mysystem.sh ci-dessous exécute des commandes bien connues (date, w, uname, uptime) pour afficher des informations au sujet de la machine et sur vous.

tom:~> cat -n mysystem.sh
     1  #!/bin/bash
     2  clear
     3  echo "This is information provided by mysystem.sh.  Le programme démarre maintenant."
     4
     5  echo "Bonjour, $USER"
     6  echo
     7
     8  echo "Nous sommes le `date`, semaine `date +"%V"`."
     9  echo
    10
    11  echo "Ces utilisateurs sont actuellement connectés :"
    12  w | cut -d " " -f 1 - | grep -v USER | sort -u
    13  echo
    14
    15  echo "`uname -s` est le système, `uname -m` le processeur."
    16  echo
    17
    18  echo "Le système fonctionne depuis :"
    19  uptime
    20  echo
    21
    22  echo "C'est pas plus compliqué !"

Un script commence toujours par ces 2 caractères : « #! ». Suit le nom du Shell qui exécutera les commandes suivant. Ce script commence en effaçant l'écran à la ligne 2. La ligne 3 fait afficher un message pour informer l'utilisateur de ce qui va se passer. La ligne 5 salue l'utilisateur. Les lignes 6, 9, 13, 16 et 20 ne sont là que pour aérer l'affichage des résultats. La ligne 8 affiche la date du jour et le numéro de la semaine. Ligne 11 encore un message informatif, ainsi que ligne 3, 18 et 22. La ligne 12 formate le résultat de la commande w ; la ligne 15 affiche le nom du système d'exploitation et le type de processeur. La ligne 19 donne la durée de fonctionnement du système ainsi que sa charge.

echo et printf sont des commandes intégrées de Bash. La première retourne toujours un statut à 0, et affiche simplement ses arguments terminés par un caractère de fin de ligne sur la sortie standard, tandis que la deuxième autorise des options de formatage de la chaîne et renvoie un statut différent de 0 en cas d'échec.

Voici le même script avec l'intégrée printf :

tom:~> cat mysystem.sh
#!/bin/bash
clear
printf "This is information provided by mysystem.sh.  Le programme démarre maintenant."

printf "Bonjour, $USER.\n\n"

printf "Nous sommes le `date`, semaine `date +"%V"`.\n\n"

printf "Ces utilisateurs sont actuellement connectés :\n"
w | cut -d " " -f 1 - | grep -v USER | sort -u
printf "\n"

printf "`uname -s` est le système, `uname -m` le processeur.\n\n"

printf "Le système fonctionne depuis :\n"
uptime
printf "\n"

printf "C'est pas plus compliqué\n"

L'écriture d'un script convivial en insérant des messages est traité au Chapitre 8, Ecrire des scripts interactifs.

[Note]La localisation standard du Bourne Again Shell

Ceci implique que le programme bash est installé dans /bin.

[Avertissement]Si stdout n'est pas disponible

Si vous exécutez un script par cron, fournir le chemin complet et rediriger les résultats et les erreurs. Du fait que le Shell tourne en mode non-interactif, toute erreur provoquera la fin du script prématurément si vous n'y songez pas.

Les chapitres suivants traiteront en détail les scripts ci-dessus.

Un script init démarre les services système sur des machines UNIX et Linux. Les démons de journalisation du système, de gestion des ressources, de contrôle d'accès et de mails en sont des exemples. Ces scripts, aussi appelés scripts de démarrage, sont stockés dans un endroit particulier de votre système, tel que /etc/rc.d/init.d ou /etc/init.d. Init, le processus initial, lit ses fichiers de configuration et décide quels services il démarre ou arrête en fonction du niveau d'exécution système. Le niveau d'exécution est un état de configuration du système (NdT qui correspond à une utilisation particulière du système) ; chaque système a un niveau d'exécution qui autorise un unique utilisateur, par exemple, pour exécuter des tâches administratives, pour lesquelles le système doit être dans un état aussi stable que possible. Comme par exemple récupérer un fichier système important depuis une sauvegarde. Les niveaux d'exécution de démarrage et d'arrêt sont habituellement aussi configurés.

Les tâches à exécuter au démarrage ou à l'arrêt d'un service sont listées dans le script de lancement. C'est l'une des tâches de l'administrateur système de configurer init, de façon que les services soient lancés et stoppés au bon moment. Quand vous êtes confrontés à cette tâche, vous avez besoin d'une bonne compréhension des procédures de démarrage et d'arrêt du système. Nous vous conseillons donc de lire les pages man pour init et inittab avant de vous lancer dans les scripts d'initialisation.

Voici un exemple très simple qui joue un son au démarrage et à l'arrêt de la machine :

#!/bin/bash

# This script is for /etc/rc.d/init.d
# Link in rc3.d/S99audio-greeting and rc0.d/K01audio-greeting

case "$1" in
'start')
  cat /usr/share/audio/at_your_service.au > /dev/audio
  ;;
'stop')
  cat /usr/share/audio/oh_no_not_again.au > /dev/audio
  ;;
esac
exit 0

L'instruction case souvent utilisée dans ce genre de script est décrite à la Section 2.5, « Emploi de l'instruction exit et du if ».

Bash est le Shell GNU, compatible avec Bourne shell, il incorpore beaucoup de fonctionnalités pratiques issues d'autres Shells. Quand le Shell est lancé, il lit ses fichiers de configuration. Les plus importants sont :

Bash agit différemment en mode interactif ; il a un mode à la norme POSIX et un autre restreint.

Les commandes Shell peuvent être classées en 3 groupes : les fonctions Shell, les intégrées Shell et les commandes réparties dans les répertoires du système. Bash admet des intégrées supplémentaires qui ne sont pas connues du classique Bourne Shell.

Les scripts Shell comportent ces commandes agencées selon la syntaxe dictée par Shell. Les scripts sont lus et exécutés ligne par ligne et devraient avoir une structure logique.

Ces exercices vont vous entraîner pour le prochain chapitre :

  1. Où le programme bash est localisé sur le système ?

  2. Utilisez l'option --version pour déterminer quelle version tourne.

  3. Quels fichiers de configuration du Shell sont lus quand vous vous faites authentifier par le système au moyen de l'interface graphique puis en ouvrant une fenêtre de console ?

  4. Les Shell suivants sont-ils interactifs ? Sont-ils des Shell d'authentification ?

  5. Pouvez-vous expliquer pourquoi bash ne quitte pas quand vous frapper les touches Ctrl+C sur la ligne de commande ?

  6. Afficher le contenu de la pile des répertoires.

  7. Si ce n'est pas déjà le cas, paramétrez l'invite de sorte qu'elle affiche votre localisation dans la hiérarchie système, par exemple ajoutez cette ligne à ~/.bashrc :

    export PS1="\u@\h \w> "

  8. Affichez les commandes mémorisées dans la table 'hash' de votre session de Shell en cours.

  9. Combien de processus sont en train de tourner sur votre système ? Utilisez ps et wc, la première ligne de résultat de ps n'est pas un processus !

  10. Comment afficher le nom du système ? Seulement le nom, rien de plus !

Chapitre 2. Ecrire et corriger des scripts

Table des matières

1. Créer et lancer un script
1.1. Écrire et nommer
1.2. script1.sh
1.3. Exécuter le script
2. Les bases du script
2.1. Quel Shell exécutera le script ?
2.2. Ajout de commentaires
3. Débugger (NdT : corriger) les scripts Bash
3.1. Débugger le script globalement
3.2. Débugger qu'une partie du script
4. Résumé
5. Exercices

Résumé

A la fin de ce chapitre vous serez capable de :

  • Ecrire un script simple

  • Définir le type de Shell qui doit exécuter le script

  • Ajouter des commentaires

  • Changer les permissions du script

  • Exécuter et débugger un script

Un script Shell est une séquence de commandes dont vous avez un usage répété. Cette séquence est en principe exécutée en entrant le nom du script sur la ligne de commande. Alternativement, vous pouvez utiliser des scripts pour automatiser des tâches via l'outil cron. Un autre usage des scripts est celui fait par la procédure de démarrage et d'arrêt d'UNIX où les opérations des services et démons sont définies dans des scripts « init ».

Pour créer un script Shell, ouvrez un nouveau fichier avec l'éditeur. N'importe quel éditeur fera l'affaire : vim, emacs, gedit, dtpad et cetera sont tous valides. Vous pouvez songer à utiliser un éditeur sophistiqué comme vim ou emacs, parce qu'ils peuvent être configurés pour reconnaître la syntaxe Shell et Bash et donc peuvent être d'une grande aide en évitant ces erreurs que les débutants font, tel que oublier un crochet ou un point-virgule.

[Astuce]Le vidéo-inverse dans vim

Pour activer le vidéo-inverse dans vim, passer la commande

:set syntax enable

Vous pouvez ajouter ce paramètre à votre fichier .vimrc pour rendre permanent cette configuration.

Entrez des commandes UNIX dans ce nouveau fichier, comme vous le feriez sur la ligne de commande. Ainsi que nous l'avons vu dans le chapitre précédent (voir Section 3, « L'exécution de commandes »), les commandes peuvent être des fonctions Shell, des commandes intégrées, des commandes UNIX et le nom d'un autre script.

Donnez à votre script un nom significatif qui donne une idée de ce qu'il fait. Assurez vous que ce nom ne soit pas en conflit avec une commande existante. Afin d'éviter des confusions, les noms de scripts souvent finissent par .sh ; mais même dans ce cas, il peut y avoir un autre script dans votre système qui porte le même nom. Vérifier avec which, whereis et les autres commandes qui renvoyent des informations sur les programmes et les fichiers :

which -a script_name

whereis script_name

locate script_name

Dans cet exemple nous employons l'intégrée echo pour informer l'utilisateur sur ce qui va se dérouler, avant que la tâche qui crééra le résultat s'exécute. Il est fortement recommandé d'informer les utilisateurs sur ce que fait le script, de façon à éviter qu'ils deviennent anxieux parce que le script ne fait rien. Nous reviendrons sur le sujet de la notification aux utilisateurs au Chapitre 8, Ecrire des scripts interactifs.

Figure 2.1. script1.sh

Exemple de script utilisant « echo hello », « echo hello $USER » et « VARIABLE=value ».

Ecrivez ce script. Ce peut être une bonne idée de créer un répertoire ~/scripts pour ranger vos scripts. Ajoutez le répertoire au contenu de la variable PATH variable :

export PATH="$PATH:~/scripts"

Si vous êtes tout nouveau avec Bash, utilisez un éditeur de texte qui emploie différentes couleurs pour les différentes constructions syntaxiques. Le code de couleur est une fonction de vim, gvim, (x)emacs, kwrite et de beaucoup d'autres éditeurs. Se référer à la documentation de votre éditeur.

[Note]Des invites différentes

L'invite varie au long de ce guide selon l'humeur de l'auteur. Ce qui ressemble plus à la vie réelle que l'invite classique $. La seule convention que nous avons gardé est que l'invite de root finit par #.

Le script doit avoir les permissions d'exécution pour le propriétaire afin d'être exécutable. Quand vous définissez des permissions, contrôlez que vous avez obtenu les permissions voulues. Une fois fait, le script peut être lancé comme toute autre commande :

willy:~/scripts> chmod u+x script1.sh

willy:~/scripts> ls -l script1.sh
-rwxrw-r--    1 willy	willy		456 Dec 24 17:11 script1.sh

willy:~> script1.sh
Le script démarre.
Salut, willy !

Je vais afficher une liste des utilisateurs connectés :

  3:38pm  up 18 days,  5:37,  4 users,  load average: 0.12, 0.22, 0.15
USER     TTY      FROM              LOGIN@   IDLE   JCPU   PCPU  WHAT
root     tty2     -                Sat 2pm  4:25m  0.24s  0.05s  -bash
willy	 :0       -                Sat 2pm   ?     0.00s   ?     -
willy    pts/3    -                Sat 2pm  3:33m 36.39s 36.39s  BitchX willy ir
willy    pts/2    -                Sat 2pm  3:33m  0.13s  0.06s  /usr/bin/screen

Je définis 2 variables, maintenant.
Ceci est une chaîne : noir
Et ceci est un nombre : 9

Je vous rends la main, maintenant.

willy:~/scripts> echo $COLOUR

willy:~/scripts> echo $VALUE

willy:~/scripts>

C'est la façon la plus courante d'exécuter un script. C'est préférable d'exécuter le script comme ça dans un sous-Shell. Les variables, fonctions et alias créés dans le sous-Shell sont seulement connus dans la session Bash de ce sous-Shell. Quand le sous-Shell finit et que le parent reprend le contrôle, tout est réinitialisé et les changements faits dans l'environnement du Shell par le script sont oubliés.

Si vous ne mettez pas le répertoire de scripts dans votre PATH, et si . (le répertoire courant) n'est pas dans le PATH non plus, vous pouvez lancer le script comme ça :

./script_name.sh

Un script peut aussi être explicitement exécuté par un Shell particulier, mais généralement on ne fait ça que pour obtenir un comportement spécial, comme vérifier que le script tourne avec un autre Shell ou afficher une trace pour debugger.

rbash script_name.sh

sh script_name.sh

bash -x script_name.sh

Le Shell spécifié démarrera en tant que sous-Shell de votre Shell actif et exécutera le script. On le fait quand on veut que le script démarre avec des options ou des conditions spécifiques qui ne sont pas indiquées dans le script.

Si vous ne voulez pas démarrer un nouveau Shell mais exécuter le script dans le Shell courant, vous faites source :

source script_name.sh

[Astuce]source = .

L'intégrée Bash source est un synonyme de la commande Bourne shell . (dot).

Le script n'a pas besoin de permission d'exécution dans ce cas. Les commandes sont exécutées dans l'environnement du Shell actif, par conséquent tout changement restera tel quel quand le script aura terminé :

willy:~/scripts> source script1.sh
--output ommitted--

willy:~/scripts> echo $VALUE
9

willy:~/scripts>

Quand un script s'exécute dans un sous-Shell, vous devriez définir quel Shell doit exécuter ce script. Le type de Shell pour lequel vous avez écrit le script peut ne pas être celui par défaut de votre système, alors les commandes peuvent ne pas être interprétées par un Shell inadéquat.

La première ligne du script définit le Shell à lancer. Les 2 premiers caractères de la première ligne devraient être #!, puis suit le chemin vers le Shell qui doit interpréter les commandes qui suivent. Les lignes blanches sont aussi prises en compte, donc ne commencez pas votre script par une ligne vide.

Dans ce guide, tous les scripts commenceront par la ligne

#!/bin/bash

Comme indiqué auparavant, ceci implique que le programme Bash doit se trouver dans /bin.

Vous devriez vous rappeler que vous ne serez peut-être pas la seule personne à lire votre code. Beaucoup d'utilisateurs et d'administrateurs système lancent des scripts qui ont été écrits par d'autres. Si ils veulent voir comment vous avez fait, les commentaires sont utiles pour éclairer le lecteur.

Les commentaires vous rendent aussi la vie plus facile. Par exemple vous avez lu beaucoup de pages man pour