> Linux Reviews > man >

bash

Interpréteur de commandes GNU BourneAgain SHell.


  1. bash.1.man


1. bash.1.man

Manpage of BASH

BASH

Section: Manuel de l'utilisateur Linux (1)
Updated: 20 Janvier 1999
Index Return to Main Contents
 

NOM

bash - Interpréteur de commandes GNU Bourne-Again SHell.  

SYNOPSIS

bash [options] [fichier]  

COPYRIGHT

Bash est sous Copyright (C) 1989, 1999 de la Free Software Foundation, Inc.  

DESCRIPTION

Bash est un interpréteur (Shell) compatible sh qui exécute les commandes lues depuis l'entrée standard, ou depuis un fichier. Bash incopore également des fonctionnalités provenant des interpréteurs Korn et C-shell (ksh et csh).

Bash est entièrement concu pour être conforme aux spécifications IEEE concernant les shells et les outils Posix (Groupe de travail de l'IEEE 1003.2).  

OPTIONS

En plus des caractères d'options documentés dans la description de la commande interne set, bash accepte les arguments suivants lorsqu'on l'invoque :

-c chaîne
Si l'argument -c est présent, les commandes sont interprétées depuis la chaîne fournie. S'il existe d'autres arguments après la chaîne, ils sont transmis comme paramètres positionnels, en commencant par $0.
-r
Si l'option -r est présente, l'interpréteur est restreint (voir les "SHELLS RESTREINTS").
-i
Si l'option -i est présente, l'interpréteur est interactif.
-s
Si l'argument -s est présent, ou s'il n'y a que des options sur la ligne de commande, L'interprétation se fera depuis l'entrée standard. Cette option permet de remplir les paramètres positionnels tout en invoquant un shell interactif.
-D
Une liste de toutes les chaînes entre '"' et précédées de $ est affichée sur la sortie standarde. Ce sont les chaînes qui sont sujettes à une traduction quand les locales ne sont ni celles du C ni celles du standard POSIX. Cela implique l'option -n ; aucune commande ne sera executée.
--
Deux caractères -- permettent d'indiquer la fin des options, et empêchent le traitement des arguments restants. Ces derniers sont alors traités comme des noms de fichiers et des paramètres. - est équivalent à --.

Bash reconnait également plusieurs options multi-caractères. Ces options doivent apparaitre sur la ligne de commande avant les options mono-caractère.

--dump-po-strings
Équivalent à -D, mais la sortie est dans le format des fichiers po de GNU gettext (objet portable).
--dump-strings
Équivalent à -D.
--help
Affiche un message sur l'usage de bash sur la sortie standard et quitte en renvoyant un code de retour de succès.
--login
Se comporter comme un shell de login. (Voir INVOCATION).
--noediting
Ne pas utiliser la bibliothèque GNU readline pour la lecture des lignes de commande, lorsque le shell est interactif.
--noprofile
Ne lire ni le fichier de configuration générale /etc/profile ni les fichiers personnalisés ~/.bash_profile, ~/.bash_login, ou ~/.profile. Par défaut bash lit ces fichiers lorsqu'il est invoqué comme shell de login (voir le paragraphe INVOCATION plus bas).
-norc
Ne pas lire le fichier de configuration personnalisée ~/.bashrc lorsque le shell est interactif. Cette option est activée par défaut lorsque l'interpréteur est invoqué sous le nom sh.
--posix
Aligner le comportement de bash sur le standard Posix 1003.2, en ce qui concerne les options dont le comportement par défaut est différent de ce standard.
--rcfile fichier
Executer les commandes contenues dans le fichier mentionne, plutot que celles du fichier de configuration personnelle ~/.bashrc, si le shell est interactif. (voir le paragraphe INVOCATION plus bas).
--restricted
Le shell devient restreint (voir les SHELLS RESTREINTS).
--verbose
Équivalent à -v
--version
Afficher le numéro de version de bash sur la sortie standard et terminer en retournant 0.
 

ARGUMENTS

S'il reste des arguments sur la ligne de commande après le traitement des options, et si ni l'option -c, ni l'option -s ne sont présentes, le premier argument est supposé être le nom du fichier dans lequel lire les commandes. Lorsque bash est invoqué de cette maniere, $0 contient le nom du fichier, et les autres paramètres positionnels contiennent les arguments restants. Bash lit, et exécute, les commandes depuis ce fichier, puis se termine. Le code de retour de bash est celui de la derniere commande exécutée dans le fichier script. Si aucune commande n'a été exécutée, le code de retour est 0.  

INVOCATION

Un shell est dit de login si le premier caractère de son argument numéro zéro est un -, ou s'il est invoqué avec l'option -login.

Un shell est interactif si son entrée standard et sa sortie standard sont toutes deux connectées à un terminal (déterminé par la fonction isatty(3)), ou s'il est invoqué avec l'option -i. Le paramètre PS1 est positionné, et le paramètre $- contient la lettre i si bash est interactif, ce qui permet à un script ou à un fichier de démarrage de vérifier l'état du shell.

Le paragraphe suivant décrit comment bash éxécute ses fichiers de d'initialisation. Si l'un de ces fichiers existe mais n'est pas accessible en lecture, bash signale une erreur. Les tildes sont remplacées par des noms de fichiers comme décrit dans Développement du Tilde dans la section Développement.

Les Shells de Login (interactifs ou non) :
  Au login :
        Si /etc/profile existe, il est exécuté.

        Si ~/.bash_profile existe, il est exécuté,
          Sinon Si ~/.bash_login existe, il est exécuté,
            Sinon Si ~/.profile existe, il est exécuté.
  L'option -noprofile permet d'empêcher la lecture de ces fichiers

  A la sortie :
        Si ~/.bash_logout existe, il est exécuté.

Shells interactifs, mais pas de Login :
  Au démarrage :
        Si ~/.bashrc existe, il est exécuté.
  L'option -norc permet d'empêcher cette lecture. L'option -rcfile)
  permet d'utiliser un autre fichier.

Shells non-interactifs:
  Au démarrage:
        Si la variable d'environnement BASH_ENV est non-nulle, elle est
        développée, et le fichier dont elle contient le nom est exécuté,
        comme si l'on appliquait la commande
                if [ "$BASH_ENV" ]; then . $BASH_ENV; fi
        mais on n'utilise pas PATH pour rechercher le chemin d'accès.

Si Bash est invoqué sous le nom sh, il essaye d'imiter au maximum le comportement de la version "historique" de sh autant que possible, tout en essayant de se conformer au standard POSIX. Pour un shell de login, il n'essaye d'exécuter que /etc/profile et ~/.profile, dans cet ordre. L'option -noprofile peut toujours être utilisée pour désactiver ce comportement. Quand il est invoqué en tant que shell interactif sous le nom sh, bash consulte la variable ENV, développe sa vakeur si elle est définie et utilise son développement en tant que nom de fichier à lire et exécuter. Comme un shell invoqué sous le nom sh n'essaye pas d'exécuter aucun autre fichier de démarrage, l'option --rcfile n'a aucun effet. Un shell non interactif invoqué sous le nom sh ne lit aucun autre fichier d'initialisation. Quand il est invoqué sous le nom sh, bash entre en mode posix après avoir lu les fichiers d'initialisation.

Quand bash est invoqué en mode posix, avec l'option -posix sur la ligne de commande, il suit ce standard en ce qui concerne les fichiers de démarrage. Dans ce cas, la variable ENV est développée, et le fichier qui en résulte est exécuté. On n'exécute pas d'autre fichier d'initialisation.

Bash tente de déterminer s'il est exécuté par le démon éxécutant des shells à distances (généralement appellé rshd). Si bash se rend compte qu'il est exécuté par rshd , il lit et exécute les commandes de ~/.bashrs , si ce fichier existe et est accessible en lecture. Il ne fera pas cela comme le ferait sh . L'option --norc peut être utilisé pour interdire ce comportement, et l'option --rcfile permet de forcer l'utilisation d'un autre fichier, mais rshd n'utilise généralement pas ces options ni n'autorise leur utilisation.

Si le shell est lancé avec un numéro de groupe effectif différend du groupe réel de l'utilisateur (GID), et si l'option -p n'est pas appliquée, aucun fichier d'initialisation n'est lu, les fonctions du shell ne sont pas héritées de l'environnement, la variable SHELLOPTS est ignorée si elle apparaît dans l'environnement, et le numéro effectif de l'utilisateur (EUID) est remplacé par l'UID. Si l'option -p est appliquée lors de cette invocation, le comportement au démarrage est le même maie l'EUID n'est pas réinitialisé.

Note du traducteur: Sous Linux, le paragraphe précédent est inutile car pour des raisons de sécurités, le noyau ignore les bits Set-User-Id et Set-Group-Id. Donc l'EUID sera toujours égal à l'UID, de même pour le GID et l'EGID.  

DÉFINITIONS

Les définitions suivantes sont utilisées tout au long de ce document.
blanc
Un espace ou une tabulation.
mot
une séquence de caractères considerée comme une unité élémentaire par le shell. On parle également de token (jeton).
nom
un mot ne contenant que des caractères alpha-numériques, ou le caractère de soulignement (underscore), commençant par une lettre ou un soulignement. On s'y refère également sous le terme identificateur.
méta-caractère
Un caractère qui, lorsqu'il n'est pas protégé, sépare les mots. Un de ceux-ci :

| & ; ( ) < > espace tabulation

opérateur de contrôle
Un token ayant une fonction de contrôle. L'un des symboles suivants :

|| & && ; ;; ( ) | <retour-chariot>

 

MOTS RÉSERVÉS

Les mots réservés ont une signification spéciale pour le shell. Les mots suivants sont réservés et interprétés par le shell lorsqu'ils ne sont pas protégés, et s'il s'agit soit du premier mot d'une commande simple, soit du troisième mot d'une commande case ou for (voir le paragraphe GRAMMAIRE DU SHELL ci-dessous).

! case do done elif else esac fi for function if in select then until while { } time [[ ]]  

GRAMMAIRE DU SHELL

 

Commandes simples

Une commande simple est une séquence d'affectations de variables facultative, suivie de mots séparés par des blancs et des redirections, et terminée par un opérateur de controle. Le premier mot indique la commande à exécuter. Les mots suivants sont transmis en argument à cette commande.

La valeur de retour d'une commande simple est son code de sortie, ou 128+n si la commande a été interrompue par le signal n.  

Tubes (Pipelines)

Un tube est une séquence d'une ou plusieurs commandes séparées par le caractère |. Le format d'un tube est :

[ ! ] commande_1 [ | commande_2 ... ]

La sortie standard de la commande_1 est connectée à l'entrée standard de la commande_2. Cette connexion est établie avant toute redirection indiquée dans une commande elle-même (voir le paragraphe REDIRECTION plus bas).

Si le mot réservé ! précède un tube, la valeur de sortie de celui-ci sera la NÉGATION logique de la valeur de retour de la dernière commande. Sinon, le code de retour d'un tube sera celui de la dernière commande. L'interpréteur attend la fin de toutes les commandes du tube avant de renvoyer une valeur.

Si le mot réservé time précède le tube, les temps écoulés, consommés par le programme et par le système pour le programme sont indiqués quand le tube se termine. L'option -p change le format de sortie pour celui spécifié par POSIX. La variable TIMEFORMAT peut être affectée avec une chaîne de format indiquant comment les informations doivent être affichées; consultez la descriptions de TIMEFORMAT dans Variables du Shell.

Chaque commande du tube est exécutée comme un processus indépendant (c'est à dire dans un sous-shell).  

Listes

Une liste est une séquence d'un ou plusieurs tubes séparés par l'un des opérateurs ;, &, &&, ou ||, et terminée par ;, &, ou <retour-chariot>.

Dans cette liste d'operateurs, && et || ont une précédence identique, suivis par ; et &, qui ont également une précédence identique.

Si une commande se termine par l'opérateur de contrôle &, l'interpréteur l'exécute en arrière-plan, dans un sous-shell. L'interpréteur n'attend pas que la commande se termine et retourne un code 0. Les commandes séparées par un ; sont exécutées successivement, l'interpréteur attend que chaque commande se termine avant de lancer la suivante. Le code de retour est celui de la dernière commande exécutée.

Les opérateurs de contrôle && et || indiquent respectivement une liste liée par un ET, et une liste liée par un OU. Une liste ET a la forme

commande_1 && commande_2

commande_2 est exécutée si, et seulement si, commande_1 renvoie un code de retour nul.

Une liste OU a la forme

commande_1 || commande_2

commande_2 est exécutée si, et seulement si commande_1 renvoie un code de retour non-nul. La valeur de retour des listes ET et OU est celle de la dernière commande exécutée dans la liste.  

Commandes composées

Une commande composée est l'une des constructions suivantes :

(liste)
liste est exécutée dans un sous-shell. Les affectations de variables, et les commandes internes qui affectent l'environnement de l'interpréteur n'ont pas d'effet une fois que la commande se termine. Le code de retour est celui de la liste.
{ liste; }
liste est simplement exécutée avec l'environnement du shell en cours. Cette construction est connue sous le nom de commandes groupées. Le code de retour est celui de la liste. liste doit obligatoirement se terminer par un caractère fin-de-ligne ou un point-virgule.
L'expression est évaluaée selon les règles décrites dans ÉVALUATIONARITHMÉTIQUES. Si la valeur de l'expression n'est pas zéro, la valeur renvoyée est zéro; sinon 1 est renvoyé. Cela est strictement identique à "expression".
[[ expression ]]
Renvoie 1 ou 0 selon la valeur de la condition expression. les expressions sont composées d'éléments primaires décrits dans EXPRESSIONSCONDITIONELLES. Le coupage des mots et l'expansion des chemins ne sont pas réalisés sur les mots entre [[ et ]]; l'expansion des tildes, des paramètres, des variable, des expressions arithmétiques, la substitution des commandes et des processus, ainsi que la disparition des apostrophes sont réalisés.

Quand les opérateurs == et != sont utilisés, la chaîne placée à la droite de l'opérateur est considéré comme étant un motif et est recherché selon les règles décrites dans Motifs Matching. La valeur renvoyée est 0 si la recherche est fructueuse et 1 sinon. Toute partie du motif peut être protégée avec des apostrophes pour forcer sa comparaison en tant que chaîne (sans développement).

Les expressions peuvent être combinées en utilisant les opérateurs suivants, lisés par ordre décroissant de priorité :

( expression )
Retourne la value de expression. Cela peut être utilisé pour outrepasser la priorité normale des opérateurs.
! expression
Vraie si expression est vraie.
expression1 && expression2
Vraie si expression1 et expression2 sont toutes les deux vraies.
expression1 || expression2 Vraie si expression1 ou expression2 est vraie.

Les opérateurs && et || n'exécutent pas expression2 si la valeur de expression1 est suffisante pour déterminer le code de retour de l'expression conditionnelle entière.

for nom [ in mot; ] do liste ; done
La liste de mots à la suite de in est développée, créant une liste d'éléments. La variable nom prend sucessivement la valeur de chacun des éléments, et liste est exécutée à chaque fois. Si in mot est omis, la commande for exécute la liste une fois pour chacun des paramètres positionnels ayant une valeur (voir le paragraphe PARAMÈTRES plus bas). Le code de retour est celui de la dernière commande exécutée. Si le développement de ce qui suit in est une liste vide, aucune commande n'est exécutée et 0 est renvoyé.
select nom [ in mot; ] do liste ; done
La liste de mots à la suite de in est développée, créant une liste d'éléments. L'ensemble des mots développés est imprimé sur la sortie d'erreur standard, chacun précédé par un nombre. Si in mot est omis, les paramètres positionnels sont imprimés (voir le paragraphe PARAMÈTRES plus bas).

Le symbole d'accueil PS3 est affiché, et une ligne est lue depuis l'entrée standard. Si la ligne est constituée d'un nombre correspondant à l'un des mots affichés, la variable nom est remplie avec ce mot.

Si la ligne est vide, les mots et le symbole d'accueil sont affichés à nouveau. Si une fin de fichier est lue (EOF), la commande se termine. Pour toutes les autres valeurs, la variable nom est nulle. La ligne lue est stockée dans la variable REPLY. La liste est exécutée après chaque sélection, jusqu'à ce qu'une commande break ou return soit atteinte. Le code de retour de select est celui de la dernière commande exécutée dans la liste, ou zéro si aucune commande n'est exécutée.

case mot in [ motif [ | motif ]
Une commande case commence d'abord par développer le mot, puis essaye de le mettre en correspondance successivement avec chacun des motifs en utilisant les mêmes règles de correspondance que pour les expansions de noms de fichiers (voir le paragraphe Développement des noms de fichiers plus bas). Quand une correspondance est trouvée, la liste associée est exécutée. Dès qu'un motif correct a été trouvé, il n'y a plus d'autre essais de correspondance. Le code de retour est zéro si aucun motif ne correspond, sinon il s'agit du code de la liste exécutée.
if liste then liste [ elif liste then liste ] ... [ else liste ] fi
La liste suivant le if est exécutée. Si son code de retour est nul, la liste suivant le then est exécutée. Sinon, chacune des listes des elif est exécutée successivement, et si un code de retour est nul, la liste du then associé est exécutée, et la commande se termine. En dernier ressort, la liste du else est exécutée. Le code de retour est celui de la dernière commande exécutée, ou zéro si aucune condition n'a été vérifiée.
while liste; do liste done
until liste; do liste done
La commande while répète la liste suivant le do tant que la dernière commande de la liste suivant le while renvoie un code de retour nul. La commande until agit de même manière, sauf que le test est négatif, et la liste du do est exécutée tant que la liste du until renvoie un code non-nul. Le code de retour des commandes while et until est celui de la dernière commande exécutée dans la liste do, ou zéro si aucune commande n'a été exécutée.
[ function ] nom () { liste; }
Ceci définit une fonction possédant le nom mentionné. Le corps de cette fonction est la liste de commandes entre { et }. Cette liste est exécutée dès que le nom de la fonction est invoqué en tant que commande simple. Le code de retour est celui de la dernière commande exécutée dans le corps de la fonction. (voir le paragraphe FONCTIONS plus bas)
 

COMMENTAIRES

Dans un shell non-interactif, ou dans un shell interactif avec l'option -o interactive-comments activée par la commande interne shopt (voir COMMANDES INTERNES DU SHELL), un mot commençant par # permettra d'ignorer tous les caractères restants sur la ligne. Un shell interactif sans l'option interactive-comments n'autorise pas les commentaires. L'option interactive_comments est activée par défaut dans les shells interactifs.  

PROTECTION

Les protections (quoting) permettent de forcer l'interpréteur à ignorer la signification spéciale de certains caractères ou mots. Les protections peuvent être utilisées pour empêcher le traitement de certains caractères spéciaux, pour éviter que des mots-réservés ne soient reconnus comme tels, ou pour empêcher le développement des paramètres.

Tous les méta-caractères mentionnés dans le paragraphe DÉFINITIONS ci-dessus ont des significations spéciales pour le shell, et doivent être protégés pour garder leur propre valeur. Il y a trois mécanismes de protection : Le caractère d'échappement, les apostrophes (quote) et les guillemets (double-quote).

Un caractère backslash (\), quand il n'est pas protégé, représente le caractère d'échapement. Il préserve la valeur littérale du caractère qui le suit, à l'exception du <retour-chariot>. Si une séquence \<retour-chariot> apparaît, et si le backslash n'est pas protégé, l'ensemble \<retour-chariot> est considéré comme une continuation de ligne (autrement dit, il est ignoré).

Encadrer des caractères entre des apostrophes simples préserve la valeur littérale de chacun des caractères. Une apostrophe ne peut pas être placée entre deux apostrophes, même si elle est précédée d'un backslash.

Encadrer des caractères entre des guillemets préserve la valeur littérale de chacun des caractères sauf $, `, et \. Les caractères $ et ` conservent leurs significations spéciales, même entre guillemets. Le backslash ne conserve sa signification que lorsqu'il est suivi par $, `, ", \, ou <fin-de-ligne>. Un guillemet peut être protégé entre deux guillemets, à condition de le faire précéder par un backslash.

Les caractères spéciaux * et @ ont des significations spéciales lorsqu'ils se trouvent entre guillemets (voir le paragraphe PARAMÈTRES ci-dessous).

Les mots de la forme $'chaîne' sont traités différemment. Le mot est développé en chaîne avec les séquences d'échappement remplacées par les séquences standards du C ANSI:

\a
alerte (cloche alias bip)
\b
effacement arrière
\e
un caractère escape
\f
fin de page

fin de ligne
\r
retour chariot
\t
tabulation horizontale
\v
tabulation verticale
\\
anti-slash
\nnn
le caractère dont le code ASCII en octal est nnn (un à trois chiffres)
\xnnn
le caractère dont le code ASCII en hexadécimal est nnn (un à trois chiffres)

Le résultat après traduction est protégé par des apostrophes comme si le symbole dollar n'avait pas été présent.

Une chaîne entre guillemets précédée d'un symbole dollar ($) sera traduite selon les locales en vigueur. Si la locale courante est C [Ndt: valeur par défaut] ou POSIX, le symbole dollar est ignoré. Si la chaîne a subi une traduction ou des remplacements, le résultat est protégé par des guillemets.  

PARAMÈTRES

Un paramètre est une entité permettant de stocker des valeurs, un peu comme les variables dans les langages de programmation courants. Un paramètre peut se présenter sous forme d'un nom, d'un nombre, ou d'un des caractères spéciaux décrits plus bas, dans le paragraphe Paramètres Spéciaux. Au niveau du shell, une variable est un paramètre muni d'un nom.

Un paramètre existe dès qu'on lui attribue une valeur. Une chaîne vide est une valeur valide. Une fois qu'une variable existe, elle ne peut être détruite qu'en utilisant la commande interne unset (voir COMMANDES INTERNES DU SHELL plus bas).

Une variable peut recevoir une valeur par une affectation de la forme

nom=[valeur]

Si aucune valeur n'est indiquée, la variable reçoit une chaîne vide. Toute valeur est soumise aux principes de développement du tilde, des paramètres et des variables, de la substitution de commandes, de l'évaluation arithmétique, et de la suppression des protections. Si une variable a son attribut -i activé (voir declare plus bas, dans le paragraphe COMMANDESINTERNESDUSHELL) alors la valeur est soumise à l'évaluation arithmétique, même si la syntaxe $[...] n'apparaît pas. Les mots ne sont pas tronqués, sauf avec la séquence "$@" comme cela est expliqué dans le paragraphe Paramètres Spéciaux ci-dessous. Le développement des noms de fichiers n'est pas effectué.  

Paramètres Positionnels

Un paramètre positionnel est un paramètre indiqué par un ou plusieurs chiffres (à l'exception du chiffre 0 seul). Les paramètres positionnels sont remplis avec les arguments du shell lors de son invocation. Ils peuvent être modifiés avec la commande interne set. On ne peut pas utiliser d'assignation pour modifier le contenu d'un paramètre positionnel.

Les paramètres positionnels sont temporairement modifiés lors de l'exécution d'une fonction du shell (voir le paragraphe FONCTIONS plus bas).

Un paramètre positionnel constitué de plusieurs chiffres doit être encadré par des accolades lors de son développement (voir le paragraphe EXPANSION plus bas).  

Paramètres Spéciaux

Il existe plusieurs paramètres de l'interpréteur ayant un comportement particulier. Ces paramètres peuvent uniquement être consultés, on ne peut pas les modifier.

*
Se développe en l'ensemble des paramètres positionnels, en commençant par 1. Quand le développement se produit entre des guillemets, * se transforme en un seul mot constitué de la valeur de tous les paramètres positionnels séparées par le premier caractère de la variable spéciale IFS. Ceci signifie que ``$*'' est équivalent à ``$1c$2c...'', dans laquelle c est le premier caractère de la valeur de la variable IFS. Si IFS est nulle ou inexistante, les paramètres sont séparés par des espaces.
@
Se développe en l'ensemble des paramètres positionnels, en commençant par 1. Quand le développement se produit entre des guillemets, chaque paramètre se transforme en un mot distinct. Ceci signifie que `` $@'' est équivalent à ``$1'' ``$2'' ... Quand il n'y a pas de paramètres positionnels, ``$@'' et $@ sont simplement éliminés.
#
Se développe pour fournir le nombre de paramètres positionnels, en base décimale.
?
Fournit le code de retour du tube exécuté en arrière-plan le plus récemment.
-
Est remplacé par la liste des options du shell indiquées durant l'invocation, configurées avec la commande interne set ou positionnées par le shell lui-même (comme le drapeau -i).
$
Se transforme en PID du shell. Dans un sous-shell (), il se transforme en PID du shell, et non pas du sous-shell.
!
Se transforme en PID de la commande (asynchrone) exécutée en arrière-plan le plus récemment.
0
Se développe pour donner le nom du shell ou du script. Ce paramètre est rempli lors de l'initialisation de l'interpréteur. Si bash est invoqué avec un fichier de commandes, $0 correspond au nom de ce fichier. Si bash est lancé avec l'option -c, alors $0 contient le premier argument, s'il y en a un, après la chaîne de commandes à exécuter. Sinon, ce paramètre contient le chemin d'accès utilisé pour invoquer bash, comme il l'a reçu en argument zéro.
_
Au lancement du shell, contient le chemin absolu du shell ou du script en cours d'exécution passé sur la ligne de commande. Devient le dernier argument de la commande précédente, après développement. Correspond aussi au chemin d'accès complet de chaque commande exécutée, et se retrouve dans l'environnement exporté à cette commande. Lors de la vérification de l'arrivée de courrier, contient le nom du fichier de courrier en cours de vérification [Ndt: généralement /var/mail/nom_de_l_utilisateur].
 

Variables du Shell

Les variables suivantes sont assignées par l'interpréteur de commandes :

PPID
L'ID du processus parent du shell. Cette variables est protégée en écriture.
PWD
Le répertoire de travail en cours, tel qu'il est configuré par la commande cd.
OLDPWD
Le répertoire de travail précédent, configuré par la commande cd.
REPLY
Contient la ligne d'entrée lue par la commande interne read lorsqu'elle n'a pas d'argument.
UID
Contient l'U-ID de l'utilisateur, initialisé au démarrage du shell.
EUID
Contient l'UID effectif de l'utilisateur, initialisé au démarrage du shell [Ndt: sous Linux, il ne devrait jamais être différent de l'UID car le Set-User-Bit est inactif sur les scripts et inutile voire dangereux sur un shell (i.e: imaginer une redirection sur /etc/passwd) ]
GROUPS
Variable de type tableau contenant la liste des groupes dont l'utilisateur courant est membre. Cette variables est protégée en écriture.
BASH
Se développe en chemin d'accès complet utilisé pour invoquer l'instance de bash en cours d'exécution.
BASH_VERSION
Correspond au numéro de version de cette instance de bash.
BASH_VERSINFO
Une variable-tableau protégée en écriture dont les nombres représentent la version de cette instance de bash. Cette valeur est renseignée de la manière suivante:

BASH_VERSINFO[0]
Le nombre majeur de la version (release).
BASH_VERSINFO[1]
Le nombre mineur de la version (version).
BASH_VERSINFO[2]
Le niveau de patch.
BASH_VERSINFO[3]
Le numéro de compilation.
BASH_VERSINFO[4]
Le statut de cette version (e.g., beta1).
SHLVL
(NDT : Lire SH LVL - Shell Level - Niveau d'interpréteur) Incrémenté de 1 à chaque invocation d'une instance de bash.
RANDOM
A chaque fois que ce paramètre est référencé, un entier aléatoire est engendré. Cette séquence de nombres aléatoires peut être initialisée en assignant une valeur à RANDOM. Si RANDOM est détruit (commande unset), il perd son comportement spécial, même s'il est recréé plus tard.
SECONDS
A chaque fois que ce paramètre est lu, le nombre de secondes écoulées depuis le lancement de l'interpréteur est renvoyé. Si une valeur est affectée à SECONDS, il renverra lors des lectures ultérieures le nombre de secondes écoulées depuis l'assignation, augmenté de la valeur fournie. Si SECONDS est détruit (commande unset), il perd son comportement spécial, même s'il est recréé plus tard.
LINENO
Chaque fois que ce paramètre est référencé, le shell le remplace par un nombre décimal représentant le numéro de la ligne actuelle (commençant à 1), au sein du script ou de la fonction. Quand on n'est ni dans un script, ni dans une fonction, la valeur renvoyée n'a pas nécéssairement de sens. Dans une fonction, la valeur n'est pas le numéro de ligne dans le fichier source (cette valeur a déjà été perdue lorsque la fonction est exécutée), mais une approximation du nombre de commandes simples exécutées dans le corps de cette fonction. Si LINENO est détruit (commande unset), il perd son comportement spécial, même s'il est recréé plus tard.
HISTCMD
Le numéro d'historique, ou le rang dans la liste d'historique, de la commande en cours. Si HISTCMD est détruit (commande unset), il perd son comportement spécial, même s'il est recréé plus tard.
DIRSTACK
Une variable-tableau (voir Arrays) représentant le contenu courant de la pile de répertoire. Les répertoires apparaissent dans la pile dans l'ordre dans lequel la commande interne dirs les affiche. Il est possible de modifier directement cette variables mais les commandes internes pushd et popd doivent être utilisées pour ajouter et enlever des répertoires. Modifier cette variable ne modifiera pas le répertoire courant. Si DIRSTACK n'est pas assignée, elle perd ses propriétés spéciales, même si elle est recréée.
PIPESTATUS
Une variable-tableau (voir Arrays) contenant une liste des codes de retour des derniers processus exécutés en avant-plan (éventuellement une seule commande).
OPTARG
La valeur du dernier argument d'option traité par la commande interne getopts (voir le paragraphe COMMANDES INTERNES DU SHELL plus bas).
OPTIND
Le rang du prochain argument à traiter avec la commande getopts (voir le paragraphe COMMANDES INTERNES DU SHELL plus bas).
HOSTNAME
Automatiquement affectée avec le nom de l'ordinateur.
HOSTTYPE
Automatiquement rempli avec une chaîne qui décrit de manière unique le type de machine sur laquelle bash s'exécute. La valeur par défaut dépend du système.
OSTYPE
Automatiquement rempli avec une chaîne qui décrit le système d'exploitation sur lequelle bash s'exécute. La valeur par défaut dépend du système.
MACHTYPE
Automatiquement affectée avec une chaîne décrivant le type du système sur lequel bash s'éxécute, dans le format standard de GNU processeur-compagnie-système. La valeur par défaut dépend du système.
SHELLOPTS
Liste des options activées du shell, séparées par des virgules. Chaque mot de la liste est un argument valide pour l'option -o de la commande interne set (voir COMMANDES INTERNES DU SHELL). Les options apparaissant dans SHELLOPTS sont celle indiquées comme actives par set -o. Si cette variable est dans l'environnement au lancement de bash, chaque option de la liste est activée avant de lire les fichiers d'initialisation. Cette variable est protégée en écriture.

Les variables suivantes sont utilisées par l'interpréteur. Dans certains cas, bash affecte des valeurs par défaut aux variables, ces cas sont décrits plus bas.

IFS
Le Séparateur de Champs Interne (Internal Field Separator) qui est utilisé pour séparer les mots après les développements, et pour decouper les lignes en mots avec la commande interne read. La valeur par défaut est ``<espace><tabulation><retour-chariot>''.
PATH
Le chemin de recherche des commandes à exécuter. Il s'agit d'une liste de répertoires, séparés par des doubles-points (`:') que l'interpréteur consulte lorsqu'il recherche une commande (voir le paragraphe ÉXÉCUTION DES COMMANDES plus bas). Le chemin par défaut dépend du système, et de la configuration choisie par la personne installant bash. Une configuration fréquente est ``/bin:/usr/bin:/usr/local/bin:/usr/gnu/bin:.''.
HOME
Le répertoire personnel de l'utilisateur. C'est l'argument par défaut de la commande interne cd.
CDPATH
Le chemin de recherche de la commande interne cd. Il s'agit d'une liste de répertoires, séparés par des doubles-points (`:') que l'interpréteur consulte lorsqu'il cherche un sous-répertoire destination de la commande cd. Voici une configuration possible ``.:~:/usr''.
BASH_ENV
Si ce paramètre est configuré lorsque bash exécute un script, sa valeur est considérée comme un nom de fichier, contenant les commandes d'initialisation de l'interpréteur, comme .bashrc. La valeur de BASH_ENV est soumise au remplacement des paramètres, à la substitution de commandes, et à l'évaluation arithmétique avant d'être interprétée comme un nom de fichier. Le chemin d'acccès PATH n'est pas utilisé pour rechercher le fichier obtenu.
MAIL
Si ce paramètre correspond à un nom de fichier, et si la variable MAILPATH n'est pas configurée, bash informera l'utilisateur si un courrier arrive dans le fichier indiqué.
MAILCHECK
Indique une fréquence (en secondes) à laquelle bash vérifiera si un nouveau courrier est arrivé. La valeur par défaut est 60 secondes. Lorsque le délai est ecoulé, le shell vérifiera la présence d'un courrier avant d'afficher son symbole d'accueil. Si cette variable est détruite (unset), le shell cessera de vérifier le courrier.
MAILPATH
Il s'agit d'une liste de fichiers séparés par des doubles-points (`:'), dans lesquels on verifiera l'arrivée de courrier. Le nom d'un fichier peut être suivi d'un point d'interrogation, puis d'une chaîne de caractères indiquant le message à afficher en cas de courrier. Dans cette chaîne, le paramètre $_ correspond au nom du fichier. Exemple:

MAILPATH='/usr/spool/mail/bfox?"Tu as du courrier":~/shell-mail?"$_ a du courrier"'

Bash fournit une valeur par defaut pour cette variable, mais l'emplacement du fichier boîte à lettres depend du système (par exemple /usr/spool/mail/$USER).

PS1
La valeur de ce paramètre est développée puis utilisée comme symbole d'accueil principal (voir le paragraphe SYMBOLE D'ACCUEIL ci-dessous). La valeur par défaut est ``bash\$ ''.
PS2
La valeur de ce paramètre est développée puis utilisée comme symbole d'accueil secondaire. Par défaut il s'agit de ``> ''.
PS3
La valeur de ce paramètre est développée puis utilisée comme symbole d'accueil pour la commande select (voir GRAMMAIRE DU SHELL plus haut).
PS4
La valeur de ce paramètre est développée puis affichée entre chaque commande lors d'un suivi d'exécution. Le premier caractère de PS4 est répété autant de fois que nécéssaire pour indiquer le niveau d'imbrication. La valeur par défaut est ``+ ''.
TIMEFORMAT
La valeur de ce paramètre est utilisée en tant que chaîne de format pour afficher le temps consommé dans les tubes préfixés avec le mot réservé time. Le caractère % introduit une séquence d'échappement qui est développée avec une valeur de temps ou une autre information. Les séquences d'échappement et leurs significations sont les suivantes; les accolades entourent les parties facultatives.

%%
Un % seul (non interprété).
%[p][l]R
Le temps écoulé en secondes.
%[p][l]U
Le temps processeur écoulé en mode utilisateur en secondes.
%[p][l]S
Le temps processeur écoulé en mode système en secondes.
%P
Le pourcentage de temps processeur utilisé calculé avec (%U + %S) / %R.
La séquence facultative p est un chiffre indiquant la précision, le nombre de chiffres après la virgule. Une valeur de 0 provoque l'affichage de nombre entiers. Trois chiffres au plus peuvent être affichés après la virgule; tout chiffre supérieur à 3 sera changé en 3. Si p n'est pas indiqué, 3 est utilisé.
La séquence optionnelle l spécifie un format étendu, incluant les minutes, de la forme MMmSS.FFs. La valeur de p détermine si la partie décimale est affichée ou non.
Si cette variable n'est pas assignée, bash réagit comme si la valeur $'
real\t%3lR
user\t%3lU
sys %3lS'
avait été affectée. Si la variable est vide, aucune information n'est affichée. Un caractère fin-de-ligne est ajouté à la fin de l'affichage.
HISTSIZE
Le nombre de commandes à mémoriser dans l'historique (voir le paragraphe HISTORIQUE plus bas). La valeur par défaut est 500.
HISTFILE
Le nom du fichier d'historique pour la mémorisation des commandes(voir le paragraphe HISTORIQUE plus bas). Par défaut, il s'agit de ~/.bash_history. Si cette variable est détruite (commande unset), l'historique n'est pas enregistré lors de la fin d'un shell interactif.
HISTFILESIZE
Le nombre maximal de lignes contenues dans le fichier historique. Quand cette variable contient une valeur, le fichier historique est tronqué, si besoin est, pour ne contenir que ce nombre de lignes. La valeur par défaut est 500. Ce fichier est tronqué quand un shell interactif existe.
OPTERR
Si cette variable contient la valeur 1, bash affiche les messages d'erreurs déclenchés par la commande interne getopts (voir le paragraphe COMMANDES INTERNES DU SHELL plus bas). OPTERR est initialisé avec la valeur 1 à chaque invocation du shell, ou au lancement d'un script.
LANG
Détermine la localisation pour toutes les catégories non spécifiquement précisées par une variable commencant par LC_.
LC_ALL
Cette variable surcharge LANG et toute autre variable LC_.
LC_COLLATE
Cette variable détermine l'ordre lors du tri des chemins ainsi que le comportement des expressions des intervalles, des classes d'équivalences, et de la comparaison de chaînes lors de la recherche de motifs et le développement des chemins.
LC_CTYPE
Cette variable détermine l'interprétation des caractères et le comportement des classes de caractères [Ndt: ex: [:alpha] ] lors du développement des chemins et de la recherche de motifs.
LC_MESSAGES
Cette variable détermine le langage des messages et celui utilisé pour traduire les chaînes entre guillemets précédés par un $.
PROMPT_COMMAND
Lorsque cette variable contient une valeur, celle-ci est exécutée en tant que commande, avant l'affichage de chacun des symboles d'accueil principaux.
IGNOREEOF
Cette variable contrôle le comportement du shell lorsqu'il reçoit un caractère EOF (fin de fichier) comme unique entrée. Si elle configurée, la valeur de cette variable correspond au nombre d' EOF consécutifs apparaissant comme caractère initial d'une ligne, que bash ignore avant de se terminer. Si cette variable existe mais que sa valeur n'est pas numérique, ou si elle n'a pas de valeur, bash accepte par defaut 10 EOF consécutifs avant de se terminer. Si elle n'existe pas, EOF est considéré comme un terminateur de saisie pour le shell. Seuls les shells interactifs sont concernés.
TMOUT
Si cette variable contient une valeur supérieure a zéro, celle-ci est considérée comme un delai en secondes, à partir de l'affichage du symbole d'accueil principal. Lorsque ce délai sera écoulé, Bash se terminera si aucune saisie n'a eu lieu.
FCEDIT
L'éditeur par défaut utilisé par la commande interne fc.
FIGNORE
Une liste de suffixes, séparés par des doubles-points `:', que bash ignorera lors de la complétion des noms de fichiers (voir le paragraphe READLINE plus bas). Un nom de fichier dont le suffixe correspond à l'un de ceux mentionnés dans FIGNORE est exclus de la liste des fichiers. Par exemple, cette variable peut prendre la valeur ``.o:~''.
GLOBIGNORE
Une liste de motifs séparés par des double-points,définissant la liste des noms de fichiers à ignorer lors du développement des chemins. Si un nom de fichier correspondant à un motif d'expansion, correspond également à un motif dans GLOBIGNORE, il est supprimé de la liste des correspondances.
INPUTRC
Le nom du fichier de configuration de readline, par défaut ~/.inputrc (voir le paragraphe READLINE plus bas).
notify
Si cette variable existe, bash affichera un rapport dès qu'un travail en arrière-plan se termine. Sinon, il attendra d'avoir à presenter un symbole d'accueil principal pour afficher son rapport (voir également l'option -b de la commande interne set).
history_control
HISTCONTROL
Si cette variable contient la valeur ignorespace, les lignes commençant par un caractère d'espacement ne seront par mémorisées dans l'historique. Si elle contient la valeur ignoredups, une ligne correspondant exactement à la ligne de commande précédente ne sera pas dupliquée dans l'historique. La valeur ignoreboth permet de combiner ces deux comportements. Si la variable est détruite (commande unset), ou si elle contient une valeur différente des trois mentionnées ci-dessus, tous les lignes lues par l'interpréteur seront mémorisées dans la liste d'historique.
command_oriented_history
Lorsque cette variable existe, bash essaye de sauver en une seule entrée d'historique toutes les lignes d'une même commande. Ceci facilite la ré-édition des commandes s'étendant sur plusieurs lignes.
glob_dot_filenames
Lorsque cette variable est positionnée, bash inclut les fichiers dont le nom commence par un `.' lors du développement des paramètres.
allow_null_glob_expansion
Si cette variable existe, bash développe les motifs des noms de fichiers n'ayant aucune correspondance en une chaîne nulle, plutot que de conserver leur propre valeur (voir le paragraphe Développement des noms de fichiers plus bas).
histchars
Cette variable contient deux ou trois caractères contrôlant le développement de l'historique, et le découpage en token (voir le paragraphe EXPANSION DE L'HISTORIQUE plus bas). Le premier caractère est le caractère de développement de l'historique, c'est à dire celui qui indique le début d'un développement d'historique (normalement `!'). Le second caractère est celui de subsitution rapide, utilise comme raccourci pour relancer la commande précédente, en modifiant une partie de la chaîne. Par défaut il s'agit de `^'. L'éventuel troisième caractère est celui qui indique, lorsqu'on le trouve en début de mot que le reste de la ligne est un commentaire. Normalement on utilise le caractère `#'. Ce caractère de commentaire empêche l'expansion de l'historique pour tous les mots restants sur la ligne. Par contre, il ne s'agit pas obligatoirement du caractère indiquant un commentaire pour l'interpréteur.
nolinks
Si cette variable existe, le shell ne suit pas les liens symboliques lorsqu'il exécute une commande modifiant le répertoire de travail. Il utilise la structure physique des répertoires à la place. Par défaut, bash suit la chaîne logique des répertoires lorsqu'il exécute des commandes modifiant le répertoire en cours, comme cd. Voir aussi la description de l'option -P de la commande interne set ( COMMANDES INTERNES DU SHELL plus bas).
hostname_completion_file
HOSTFILE
Contient le nom d'un fichier ayant le même format que /etc/hosts qui sera consulté lorsque le shell devra compléter un nom d'hôte. Ce fichier peut être changé de manière interactive. Lors de la prochaîne tentative pour compléter un nom d'hôte, bash ajoutera le nouveau fichier à sa base de données déjà existantes.
noclobber
Si cette variable existe, bash n'écrasera pas un fichier existant avec les opérateurs de redirection >, >&, et <>. Cette variable peut être contournée lorsqu'on crée un fichier de sortie en utilisant l'opérateur >| à la place de > (voir également l'option -C de la commande interne set).
auto_resume
Cette variable configure le comportement du shell interactif vis à vis de l'utilisateur et du contrôle de jobs. Si cette variable existe, les commandes simples constituées d'un seul mot sont considérées comme de possibles relances de travaux arrêtés. Aucune ambiguïté n'est possible, si plusieurs travaux arrêtés commencent par la chaîne saisie, bash sélectionne le job manipulé le plus récemment. Le nom du job arrêté correspond, dans ce contexte, à la ligne de commande utilisée pour le lancer. Si cette variable contient la valeur exact, la chaîne fournie doit correspondre exactement au nom d'un job arrêté. Si elle contient la valeur substring, la chaîne fournie doit correspondre à une sous-chaîne du nom du job arrêté. La valeur substring fournit un comportement analogue au job id %? (voir CONTRÔLE DES JOBS plus bas). Si la variable contient n'importe quelle autre valeur, la chaîne fournie doit correspondre à un préfixe du nom d'un job arrêté. C'est analogue au fonctionnement du job id %.
no_exit_on_failed_exec
Si cette variable existe, un shell non-interactif ne se terminera pas immédiatement si il ne peut pas exécuter un fichier avec la commande interne exec. Un shell interactif ne se termine pas si un exec échoue.
cdable_vars
Si cette variable existe, un argument de la commande interne cd qui ne soit pas un répertoire, est supposé être un nom de variable dont le contenu indique le répertoire destination désiré.
 

EXPANSION

Les expansions sont appliquées à la ligne de commande après qu'elle ait été divisée en mots. Il existe sept types de développements : expansion des accolades, développement du tilde, remplacement des paramètres et variables, substitution de commandes, évaluation arithmétique, découpage des mots, et développement des noms de fichiers.

L'ordre est : expansion des accolades, du tilde, des paramètres, des variables, des commandes, évaluation arithmétique (selon la méthode gauche-à-droite), découpage des mots et développement des noms de fichiers.

Sur les systèmes qui le suppportent, un développement supplémentaire a lieu : la substitution de processus.

Seuls l'expansion des accolades, le découpage des mots, et le développement des noms de fichiers peuvent modifier le nombre de mots. Les autres développement transforment un mot unique en un autre mot unique. La seule exception à cette règle est l'expansion de ``$@'' comme on l'a vu plus haut (voir le paragraphe PARAMÈTRES).  

Expansion des accolades

L' expansion des accolades est un mécanisme permettant la création de chaînes quelconques. Il est similaire au développement des noms de fichiers, mais les noms de fichiers créés n'existent pas nécessairement. Les motifs qui seront développes prennent la forme d'un préambule facultatif, suivi d'une série de chaînes séparées par des virgules, encadrée par des accolades. Un postambule peut éventuellement suivre la série de chaînes. Le préambule est inséré devant chacune des chaînes contenues entre les accolades, et le postambule est ajouté à la fin de chacune des chaînes résultantes, le développement se faisant de gauche à droite.

Plusieurs développements d'accolades peuvent être imbriqués les uns dans les autres. Les chaînes résultant de chaque développement ne sont pas triées, l'ordre gauche à droite est conservé. Par exemple a{d,c,b}e se développe en `ade ace abe'.

L'expansion des accolades est effectuée avant tout autre type de développement, et tous les caractères ayant une signification spéciale pour les autres développement sont conservés dans le résultat. Il s'agit d'une modification purement littérale. Bash n'effectue aucune interprétation syntaxique du texte entre les accolades.

Une formule correcte pour le développement doit contenir des accolades ouvrantes et fermantes non protégées, et au moins une virgule non protégée. Toute formule incorrecte n'est pas développée et reste inchangée.

Cette construction est généralement utilisée comme raccourci lorsque le préfixe commun aux différentes chaînes est relativement long :

mkdir /usr/local/src/bash/{old,new,dist,bugs}

ou
chown root /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}}

Le développement des accolades induit une légère incompatibilité avec les versions traditionnelles de sh, l'interpréteur Bourne. sh n'effectue aucun traitement sur les accolades ouvrantes et fermantes lorsqu'elles apparaissent dans un mot, et les laisse inchangées. Bash suppprime les accolades dans les mots, après développement. Par exemple si l'on fournit à sh le mot file{1,2}, il reste inchangé en sortie. Par contre, il est tranformé en file1 file2 par bash. Si une compatibilité stricte avec sh est nécessaire, lancez bash avec l'attribut -nobraceexpansion (voir OPTIONS plus haut) ou désactivez le développement des accolades avec l'option +o braceexpand de la commande set (voir le paragraphe COMMANDES INTERNES DU SHELL plus bas).  

Développement du Tilde

Si un mot commence avec le caractère tilde (`~'), tous les caractères précédant le premier slash (voire tous les caractères s'il n'y a pas de slash), sont considérés comme un nom de login possible. Si ce nom de login est une chaîne nulle, le tilde est remplacé par la valeur du paramètre HOME. Si HOME n'existe pas, le tilde est remplacé par le répertoire de connexion de l'utilisateur exécutant le shell.

Si un `+' suit le tilde, ils seront remplacés par la valeur du paramètre PWD. Si un `-' suit, ils seront remplacés par la valeur de OLDPWD. Si la valeur suivant le tilde est un nom de login valide, le tilde, ainsi que ce nom seront remplacés par le répertoire personnel associé à ce nom. Si le nom est invalide, ou si le développement du tilde échoue, le mot est inchangé.

Chaque affectation de variable est soumis au développement du tilde s'il suit le : ou le =. On peut donc utiliser des chemins d'accès avec un tilde pour remplir les variables PATH, MAILPATH, et CDPATH, et le shell fournira la valeur correcte.  

Remplacement des paramètres

Le caractère `$' permet d'introduire le remplacement des paramètres, la substitution de commandes, ou l'expansion arithmétique. Le nom du paramètre ou du symbole à développer peut être encadré par des accolades, afin d'éviter que les caractères suivants ne soient considérés comme appartenant au nom de la variable.

${paramètre}
est remplacé par la valeur du paramètre. Les accolades sont nécessaire quand le paramètre est un paramètre positionnel ayant plusieurs chifres, ou si le paramètre est suivi de caractères n'appartenant pas à son nom.

Dans chacun des exemples suivants, le mot est soumis au développement du tilde, au remplacement des paramètres, à la substitution de commandes, et à l'évaluation arithmétique. Bash vérifie si un paramètre existe, et s'il n'est pas nul. L'omission du double point ne fournit qu'un test d'existence.

${paramètre:-mot}
Utilisation d'une valeur par défaut. Si le paramètre est inexistant ou nul, on substitue le développement du mot. Sinon, c'est la valeur du paramètre qui est fournie.
${paramètre:=mot}
Attribution d'une valeur par défaut. Si le paramètre est inexistant ou nul, le développement du mot lui est affecté. La valeur du paramètre est alors renvoyée. Les paramètres positionnels, et spéciaux ne peuvent pas être affectés de cette façon.
${paramètre:?mot}
Affichage d'une erreur si inexistant ou nul. Si le paramètre est inexistant, ou nul, le développement du mot (ou un message approprié si aucun mot n'est fourni) est affiché sur la sortie d'erreur standard, et l'interpréteur se termine, s'il n'est pas interactif. Autrement, la valeur du paramètre est utilisée.
${paramètre:+mot}
Utilisation d'une valeur différente. Si le paramètre est nul, ou inexistant, rien n'est substitué. Sinon le développement du mot est renvoyé.
${#paramètre}
Est remplacé par la longueur, en caractères, de la valeur du paramètre. Si le paramètre est * ou @, la longueur fournie est celle du paramètre * développé entre guillemets.
${paramètre#mot}
${paramètre##mot}
Le mot est développé pour fournir un motif, comme dans l'expansion des noms de fichiers. Si le motif correspond au debut de la valeur du paramètre, alors le développement prend la valeur du paramètre après suppression du plus petit motif commun (cas ``#''), ou du plus long motif (cas ``##'').
${paramètre%mot}
${paramètre%%mot}
est développé pour fournir un motif, comme dans l'expansion des noms de fichiers. Si le motif correspond à une portion finale de la valeur du paramètre, alors le développement prend la valeur du paramètre après suppression du plus petit motif commun (cas ``%''), ou du plus long motif (cas ``%%'').
 

Substitution de commandes

La substitution de commandes permet de remplacer le nom d'une commande par son résultat. Il en existe deux formes :

$(commande)

ou
`commande`

Bash effectue la substitution en exécutant la commande et en la remplaçant par sa sortie standard, dont les derniers sauts de lignes sont supprimés.

Quand l'ancienne forme de substitution -avec les backquotes `- est utilisée, le caractère backslash garde sa signification littérale, sauf s'il est suivi de $, `, ou \. Quand on utilise la forme $(commande), tous les caractères entre parenthèses gardent leurs valeurs littérales. Aucun n'est traité spécifiquement.

Les substitutions de commandes peuvent être imbriquées. Avec l'ancienne forme, il faut protéger les backquotes internes avec un backslash.

Si la substitution apparaît entre guillemets, le découpage des mots, et l'expansion des noms de fichiers ne sont pas effectués.  

Évaluation Arithmétique

L'évaluation arithmétique permet de remplacer une expression par le résultat de son évaluation. Il existe deux formats d'évaluation arithmétique :

$[expression]

$((expression))

L'expression est manipulée de la même manière que si elle se trouvait entre guillemets, mais un guillemet se trouvant entre les crochets ou les parenthèses n'est pas traité spécifiquement. Tous les mots de l'expression subissent le développement des paramètres, la substitution des commandes et la suppression des apostrophes et guillemets. Les évaluations arithmétiques peuvent être imbriquées.

L'évaluation est effectuée en suivant les règles mentionnées dans le paragraphe CALCUL ARITHMÉTIQUE (plus bas). Si l'expression est invalide, bash affiche un message indiquant l'erreur, et aucune substitution n'a lieu.  

Substitution de Processus

La substitution de processus n'est disponible que sur les systèmes acceptant le mécanisme des tubes nommés (FIFOs) ou la méthode /dev/fd de noms de fichiers ouverts. Elle prend la forme <(liste) ou >(liste). La liste de processus est exécutée avec ses entrées et sorties connectées à une FIFO ou à un fichier dans /dev/fd. Le nom de ce fichier est passé en argument à la commande qui sera exécutée comme résultat de cette substitution. Si l'on utilise la forme >(liste), l'écriture dans le fichier fournira des entrées pour la liste. Si la forme <(liste) est utilisée, le fichier passe en argument devra être lu pour obtenir la sortie de la liste.

Sur les systèmes qui le permettent, la substitution de processus est effectuée simultanément au remplacement des paramètres et variables, a la substitution de commande, et à l'évaluation arithmétique.  

Séparation des mots

Les résultats du remplacement des paramètres, de la substitution de commandes, et de l'évaluation arithmétique, qui ne se trouvent pas entre guillemets sont analysés par le shell afin d'appliquer le découpage des mots.

L'interpréteur considère chaque caractère du paramètre IFS comme un délimiteur, et redécoupe le résultat des transformations précédentes en fonction de ceux-ci. Si la valeur du paramètre IFS est exactement <espace><tabulation><retour-chariot>, (la valeur par défaut), alors toute séquence de caractères IFS sert à délimiter les mots. Si IFS a une valeur autre que celle par défaut, alors les séquences de caractères blancs espace et tabulation sont ignorées en début et fin de mot, à condition que ces caractères blancs se trouvent dans la valeur de IFS. Tout autre caractère de IFS se trouvant à côté d'un caractère blanc de IFS, sert à délimiter un champ. Une séquence de caractères blancs de IFS est également traitée comme un séparateur. Si la valeur de IFS est nulle, aucun découpage de mot n'a lieu. IFS ne peut pas être détruit.

Les arguments nuls explicites ("" ou '') sont conservés. Les arguments nuls implicites, résultant du développement des paramètres n'ayant pas de valeurs, sont éliminés.

Notez que si aucun développement n'a lieu, le découpage des mots n'est pas effectué.  

Développement des noms de fichiers

Apres le découpage des mots, et si l'option -f n'est pas indiquée, bash recherche dans chaque mot les caractères *, ?, et [. Si l'un d'eux apparaît, le mot est considéré comme un motif, et remplacé par une liste, classée par ordre alphabétique, des noms de fichiers correspondant à ce motif. Si aucun nom de fichiers ne correspond, et si la variable allow_null_glob_expansion n'existe pas, le mot reste inchangé. Si la variable existe, et si aucune correspondance n'est trouvée, le mot est éliminé. Quand un motif est utilisé pour créer des chemins d'accès, le caractère ``.'' au début d'un nom, ou immédiatement à la suite d'un slash doit être explicitement mis en correspondance, à moins que la variable shell glob_dot_filenames n'existe. Dans tous les autres cas, le caractère ``.'' n'est pas traité spécifiquement. Le caractère slash doit toujours être mis en correspondance explicitement.

Les caractères spéciaux ont les significations suivantes :

*
Correspond à n'importe quelle chaîne, y compris la chaîne vide.
?
Correspond à n'importe quel caractère.
[...]
Correspond à l'un des caractères entre crochets. Une paire de caractères séparés par un signe "moins" indique un intervalle; qui correspond à n'importe quel caractère situé entre les deux bornes incluses. Si le premier caractère suivant le [ est un ! ou un ^ alors la correspondance se fait sur les caractères non-inclus. Un - ou un ] peuvent être mis en correspondance en les incluant en premier ou dernier caractère de l'ensemble.
 

Suppression des protections

Après les développements précédents, toutes les occurences non-protégées des caractères \, `, et " sont supprimées.  

REDIRECTION

Avant qu'une commande ne soit exécutée, il est possible de rediriger son entrée et sa sortie en utilisant une notation spéciale qui sera interprétée par le shell. Les redirections peuvent également servir à ouvrir ou fermer des fichiers dans l'environnement actuel du shell. Les opérateurs de redirection décrits ci-dessous peuvent apparaitre avant, ou au sein d'une commande simple ou suivre une commande. Les redirections sont traitées dans l'ordre d'apparition de gauche à droite.

Dans les descriptions suivantes, si le numéro de descripteur de fichier est omis, et si le premier caractère de l'opérateur de redirection est <, celui-ci correspondra à l'entrée standard (descripteur de fichier 0). Si le premier caractère de l'opérateur est >, la redirection s'appliquera à la sortie standard (descripteur de fichier 1).

Le mot qui suit l'operateur de redirection dans les descriptions suivantes est soumis à l'expansion des accolades, du tilde, des paramètres, à la substitution de commandes, à l'évaluation arithmétique, à la suppression des protections, et au développement des noms de fichiers. S'il se modifie pour donner plusieurs mots, bash détectera une erreur.

Remarquez que l'ordre des redirections est important. Par exemple, la commande

ls > liste_répertoires 2>&1

redirige a la fois la sortie standard et la sortie d'erreur vers le fichier liste_répertoires, alors que la commande

ls 2>&1 > liste_répertoires

ne redirige que la sortie standard vers le fichier liste_répertoires, car la sortie d'erreur a été renvoyée vers la sortie standard avant que celle-ci ne soit redirigée vers liste_répertoires.  

Redirection d'entrée

Le format général des redirections d'entrée est le suivant :

[n]<mot

Lorsque l'on applique une redirection d'entrée, le fichier dont le nom résulte du développement du mot sera ouvert en lecture avec le descripteur de fichier numéro n, ou en tant qu'entrée standard (descripteur de fichier 0) si n n'est pas mentionné.  

Redirection de sortie

Le format général des redirections de sortie est le suivant :

[n]>mot

Lors d'une redirection de sortie, le fichier dont le nom résulte du développement du mot est ouvert en écriture, avec le descripteur de fichier n, ou en tant que sortie standard (descripteur de fichier 1) si n n'est pas mentionné. Si le fichier n'existe pas, il est créé. S'il existait déjà, sa taille est ramenée à 0.

Si l'opérateur de redirection est >|, alors la valeur de l'option -C de la commande interne set est ignorée, et une tentative de création de fichier a lieu. (Voir la description de noclobber dans le paragraphe Variables du Shell plus haut).  

Redirection pour Ajout en Sortie

Le format général pour la redirection de sortie avec ajout est :

[n]>>mot

Lorsqu'on redirige ainsi la sortie, le fichier dont le nom résulte du développement du mot est ouvert pour ajout en fin de fichier, avec le descripteur n, ou en tant que sortie standard (descripteur 1) si n n'est pas mentionné. Si le fichier n'existe pas, il est créé.

 

Redirection de la sortie standard et de la sortie d'erreur.

Bash permet la redirection simultanée de la sortie standard (descripteur 1) et de la sortie d'erreur (descripteur 2), dans un fichier dont le nom est le résultat du développement du mot.

Il y a deux formes pour effectuer cette double redirection :

&>mot

et
>&mot

On préfère généralement la première. Elle est sémantiquement équivalente à

>mot 2>&1

 

Document en ligne

Avec ce type de redirection, le shell va lire son entrée standard jusqu'à ce qu'il atteigne une ligne contenant uniquement le mot prévu (sans espaces à la suite), nommée étiquette. Une fois cette étiquette atteinte, il exécutera la commande demandée en lui fournissant en entrée le texte lu avant l'étiquette, que l'on appelle document en ligne.

Le format des documents en ligne est le suivant :

<<[-]mot
        document en ligne
étiquette

Il n'y a ni remplacement de paramètre, ni substitution de commande, ni développement de chemin d'acces, ni évaluation arithmétique sur le mot. Si l'un des caractères du mot est protégé, l'étiquette est obtenue après suppression des protections dans le mot, et les lignes du document ne sont pas développées. Sinon, toutes les lignes du document sont soumises au remplacement des paramètres, à la substitution de commandes, et à l'évaluation arithmétique. Dans ce dernier cas, les couples \<retour-chariot> sont ignorés, et \ doit être utilisé pour protéger les caractères \, $, et `.

Si l'opérateur de redirection est <<-, alors les tabulations en tête de chaque ligne sont supprimées, y compris dans la ligne contenant l'étiquette. Ceci permet d'indenter de manière naturelle les documents en ligne au sein des scripts.  

Dédoublement de descripteur de fichier

L'opérateur de redirection

[n]<&mot

permet de dupliquer les descripteurs de fichiers en entrée. Si le mot se transforme en un ou plusieurs chiffres, le descripteur de fichier n devient une copie de ce descripteur. Si le mot prend la forme -, le descripteur n est fermé. Si n n'est pas mentionné, on utilise l'entrée standard (descripteur 0).

L'opérateur

[n]>&mot

est utilisé de manière similaire pour dupliquer les descripteurs de sortie. Si n n'est pas précisé, on considère la sortie standard (descripteur 1). Un cas particulier se produit si n est omis, et si mot ne se développe pas sous forme de chiffres. Alors, les sorties standard et d'erreurs sont toutes deux redirigées comme précédement.  

Ouverture en Lecture/Écriture d'un descripteur de fichier

L'opérateur de redirection

[n]<>mot

ouvre à la fois en lecture et en écriture le fichier dont le nom résulte du développement du mot, et lui affecte le descripteur de fichier n, ou bien les entrée et sortie standard si n n'est pas mentionné. Si le fichier n'existe pas, il est créé.  

FONCTIONS

Une fonction du shell mémorise une série de commandes pour permettre une exécution ulterieure. La definition d'une fonction est décrite plus haut, dans le paragraphe GRAMMAIREDUSHELL. Les fonctions sont exécutées dans le contexte de l'interpréteur en cours. On ne crée pas de nouveau processus pour interpréter une fonction, contrairement à l'exécution d'un script. Les arguments d'une fonction sont placés dans les paramètres positionnels durant son exécution. Le paramètre spécial # est mis a jour. Le paramètre positionnel 0 n'est pas modifié.

La variables locales d'une fonction peuvent être déclarées en utilisant la commande interne local. Autrement, les variables et leurs valeurs sont partagées entre la fonction et son appelant.

Si la commande interne return est exécutée dans une fonction, celle-ci se termine et l'exécution reprend avec la commande suivant l'appel de fonction. Quand une fonction se termine, les paramètres positionnels et le paramètre spécial # reprennent les valeurs qu'ils avaient avant l'appel de fonction.

Les noms des fonctions et leurs définitions peuvent être affichés en utilisant l'option -f des commandes internes declare ou typeset. Les fonctions peuvent être exportées avec l'option -f de la commande interne export, afin de rester définies dans les sous-shells.

Les fonctions peuvent être récursives. Aucune limite n'est imposée quant au nombre d'appels récursifs.  

ALIAS

L'interpréteur gère une liste d'alias qui peuvent être créés et détruits avec les commandes internes alias et unalias (voir le paragraphe COMMANDES INTERNES DU SHELL plus bas). Le shell vérifie si le premier mot de chaque commande (à condition qu'il ne soit pas protégé) est un alias. Si tel est le cas, ce mot est remplacé par le texte de l'alias. Le nom de l'alias, ainsi que le texte de remplacement, peuvent contenir n'importe quels caractères valides pour le shell, y compris les méta-caractères présentés plus haut. Une exception toutefois, le nom de l'alias ne peut pas contenir de caractère =. Le shell vérifie si le premier mot du texte de remplacement est à son tour le nom d'un alias, mais s'il est identique au nom de l'alias il ne sera pas remplacé à nouveau. Ceci permet par exemple de créér un alias pour ls valant ls -F, que bash n'essaiera pas de développer récursivement. Si le dernier caractère du texte de remplacement est un blanc, alors on vérifiera également si le mot suivant l'alias est lui aussi un alias.

Les alias sont créés et affichés avec la commande alias, et supprimés avec la commande unalias.

Il n'existe pas de mécanisme permettant d'utiliser des arguments dans le texte de remplacement, contrairement à l'interpreteur csh. Si l'on a besoin de traiter des arguments, il faut utiliser une fonction du shell.

Les alias ne sont développés qu'avec les shells interactifs.

Les règles concernant la définition et l'utilisation des alias sont un peu confuses. Bash lit toujours au moins une ligne d'entrée complètement avant d'exécuter une commande de cette ligne. Les alias sont traités lorsque la commande est lue, et non pas lorsqu'elle est exécutée. Ainsi, une définition d'alias apparaissant sur la même ligne qu'une autre commande ne prend pas effet avant la lecture de la prochaine ligne d'entrée. Autrement dit, une commande placée à la suite d'une définition d'alias, sur la même ligne ne sera pas affectée par cet alias. Ce comportement est également important lors de l'exécution des fonctions. Les alias sont traités lorsque la définition de la fonction est lue, et non pas lors de l'exécution de cette fonction. Ainsi des alias définis dans une fonction ne sont pas actifs avant la fin de l'exécution de la fonction. Pour plus de tranquilité, placez toujours les définitions d'alias sur des lignes isolées, et n'utilisez jamais la commande alias dans les commandes composées.

Notez enfin que la plupart du temps les alias sont avantageusement remplacés par des fonctions du shell.  

CONTRÔLE DES JOBS

Le contrôle des jobs permet d'arrêter (suspend) sélectivement l'exécution d'un processus, et de la reprendre (resume) ultérieurement. L'utilisateur bénéficie généralement de cette possibilité grâce à l'action conjointe du pilote de terminal et de bash.

L'interpréteur associe un job à chaque tube. Il maintient une table des jobs en cours d'exécution, cette table pouvant être affichée avec la commande jobs. Quand bash lance un job de manière asynchrone (en arrière-plan), il affiche une ligne du genre :

[1] 25647

Cette ligne indique que le job est associé au numéro 1, et que le PID du dernier processus dans le tube est 25647. Tous les processus dans un tube simple font partie du même job. Bash utilise la notion de job comme une abstraction pour aider à les contrôler.

Pour faciliter l'implémentation d'une interface utilisateur pour le contrôle de job, le système introduit la notion d'ID de groupe de processus associés à un terminal. Les membre de ce groupe de processus (ceux dont le GID est égal au Process Group ID du terminal) recoivent les signaux déclenchés par le clavier, comme SIGINT. Ces processus sont dits en avant-plan. Les processus en arrière-plan sont ceux dont le Process-GID differe de celui du terminal, ceux qui ne reçoivent pas les signaux déclenchés par le clavier. Seuls les processus en avant-plan peuvent lire depuis le terminal ou écrire dessus. Les processus en arrière-plan qui tentent une lecture sur le terminal (ou une écriture dessus), reçoivent les signaux SIGTTIN (SIGTTOU) émis par le pilote de péripherique du terminal, lesquels signaux suspendent l'exécution du processus (sauf interception du signal).

Si le système d'exploitation sur lequel bash fonctionne permet le contrôle des jobs, bash vous y donne accès. La frappe d'un caractère suspension (généralement ^Z, Contrôle-Z) pendant l'exécution d'un processus arrête celui-ci, et redonne la main à bash. La frappe d'un caractère suspension différée (généralement ^Y, Contrôle-Y) arrêtera le processus au moment où il tentera de lire depuis le terminal, et la main reviendra à bash. Il est possible de manipuler ces jobs en utilisant la commande bg (background = arrière-plan) pour continuer l'exécution en arrière-plan, fg (foreground) pour la reprendre en avant-plan, ou encore la commande kill pour tuer le processus. Un ^Z prend effet immédiatement, et élimine les sorties en attente.

Il y a plusieurs manières de faire référence à un job. Le caractère % introduit un nom de job. Le job numéro n peut être noté %n. On peut également faire référence à un job en utilisant un préfixe du nom utilise pour le lancer, ou une partie de la ligne de commande. Par exemple, %ce se réfère à un job arrêté nomme ce. Si ce préfixe correspond à plusieurs jobs, bash renverra une erreur. D'autre part, %?ce, fait référence à n'importe quel job contenant la chaîne ce dans sa ligne de commande. Si la sous-chaîne correspond à plusieurs jobs, bash renverra une erreur. Les symboles %% et %+ référencent le job courant du shell, c'est à dire le dernier job arrêté alors qu'il se trouvait en avant-plan. Le job précédent peut être mentionné en utilisant %-. Dans les affichages se rapportant aux jobs (par exemple ceux de la commande jobs le job courant est toujours indiqué par un +, et le job précédent avec un -.

Il suffit de nommer un job pour le ramener en avant-plan : %1 est synonyme de ``fg %1'', et ramène le job 1 depuis l'arrière-plan vers l'avant-plan. De même, ``%1 &'' relance le job 1, mais en arrière-plan cette fois, de manière équivalente à ``bg %1''.

Le shell est immédiatement prévenu lorsqu'un job change d'état. Normalement bash attend d'être prêt à afficher son symbole d'accueil avant de fournir un rapport sur les changements dans les statut des jobs, afin de ne pas perturber les autres affichages. Avec l'option -b de la commande interne set, bash affichera les modifications immédiatement (Voir aussi la description de la variable notify dans le paragraphe Variables du Shell plus haut.)

Si vous essayez de quitter bash alors que des jobs sont suspendus, le shell affichera un message d'avertissement. Vous pouvez alors utiliser la commande jobs pour vérifier leurs états. Une fois cette commande invoquée, ou si vous essayez à nouveau de quitter le shell immédiatement, il n'y aura plus d'avertissement, et les jobs suspendus seront définitivement terminés.  

SIGNAUX

Quand bash fonctionne de manière interactive, il ignore le signal SIGTERM (c'est pourquoi kill 0 ne tue pas un shell interactif), et le signal SIGINT est intercepté et géré (c'est pourquoi la commande interne wait n'est pas interruptible). Dans tous les cas, bash ignore le signal SIGQUIT. Si le contrôle de jobs est disponible, bash ignore les signaux SIGTTIN, SIGTTOU, et SIGTSTP.

Les jobs synchrones lancés par bash reçoivent les valeurs des signaux héritées par le shell de leur parent. Quand le contrôle de job n'est pas actif, les jobs en arrière-plan (démarrés avec &) ignorent les signaux SIGINT et SIGQUIT. Les commandes exécutées en tant que résultat de la substitution de commandes ignorent les signaux de contrôle de jobs émis par le clavier SIGTTIN, SIGTTOU, et SIGTSTP.  

ÉXÉCUTION DES COMMANDES

Apres le découpage de la ligne de commande en mots, si le résultat est une commande simple suivie d'une éventuelle liste d'arguments, les actions suivantes sont effectuées.

Si le nom de la commande ne contient pas de slash, le shell tente de la trouver. S'il existe une fonction shell de ce nom, elle est appelée comme nous l'avons vu dans le paragraphe FONCTIONS plus-haut. Si le nom n'est pas celui d'une fonction, l'interpréteur le recherche dans la liste des fonctions internes. Si une équivalence est trouvée, la fonction interne est invoquée.

Si le nom n'est ni celui d'une fonction shell, ni celui d'une commande interne, et s'il ne contient pas de slash, bash va chercher dans chacun des membres de PATH un répertoire contenant un fichier exécutable du nom désiré. Si la recherche est infructueuse, l'interpréteur affiche un message d'erreur et renvoie un code de retour non nul.

Si la recherche réussit, ou si le nom de la commande contient au moins un slash, le shell exécute le programme voulu. L'argument 0 est rempli avec le nom fourni, et les autres arguments seront éventuellement remplis avec le reste de la ligne de commande.

Si l'exécution échoue parce que le programme n'est pas un exécutable, et si le fichier n'est pas un répertoire, on le considère alors comme un script shell, un fichier contenant une série de commandes. Un sous-shell est alors créé pour exécuter ce script. Ce sous-shell se réinitialisera lui-même, comme si un nouveau shell avait été invoqué pour exécuter le script, à la difference qu'il continuera à mémoriser l'emplacement des commandes connues de son parent (voir hash dans le paragraphe COMMANDES INTERNES DU SHELL plus bas).

Si le programme est un fichier commençant par #!, le reste de la première ligne indique un interpréteur pour ce programme. Le shell se chargera d'exécuter cet interpréteur, si le système d'exploitation ne gère pas lui-même ce format d'exécutable. Les arguments de l'interpréteur consistent en un premier argument éventuel fourni sur la première ligne du fichier à la suite du nom de l'interpréteur, suivi du nom du programme, suivi des arguments de la commande s'il y en a.  

ENVIRONNEMENT

Quand un programme est invoqué, il reçoit un tableau de chaînes que l'on appelle environnement. Il s'agit d'une liste de paires nom-valeur, de la forme nom=valeur.

Le shell permet de manipuler l'environnement de plusieurs façons. Au démarrage, le shell analyse son propre environnement, et crée un paramètre pour chaque nom trouvé, en le marquant comme exportable vers les processus fils. Les commandes exécutées héritent de cet environnement. Les commandes export et declare -x permettent d'ajouter ou de supprimer des paramètres ou des fonctions de l'environnement. Si la valeur d'un paramètre de l'environnement est modifiée, la nouvelle valeur devient une partie de l'environnement, et elle remplace l'ancienne. L'environnement hérité par les commandes exécutées est l'environnement initial du shell (dont les valeurs peuvent être modifiées), moins les éléments supprimés par la commande unset, plus les éléments ajoutés par les commandes export et declare -x.

L'environnement d'une commande simple ou d'une fonction peut être augmenté temporairement en la faisant précéder d'une affectation de paramètre, comme nous l'avons vu plus haut dans le paragraphe PARAMÈTRES. Ces affectations ne concernent que l'environnement vu par cette commande ou fonction.

Si l'option -k est utilisée (voir la commande interne set plus bas), alors toutes les affectations de paramètres sont placées dans l'environnement d'une commande exécutée, pas seulement celles qui précèdent son nom.

Quand bash invoque une commande externe, la variable _ contient le chemin d'accès complet à cette commande, et elle est transmise dans l'environnement.  

CODE DE RETOUR

Au niveau du shell, une commande qui se termine avec un code de retour nul est considérée comme réussie. Le zéro indique le succès. Un code de retour non-nul indique un echec. Quand une commande se termine à cause d'un signal fatal, bash utilise la valeur 128+signal comme code de retour.

Si une commande n'est pas trouvée, le processus fils créé pour l'exécuter renvoie la valeur 127. Si la commande est trouvée mais pas exécutable, la valeur renvoyée est 126.

Bash lui-même renvoie le code de retour de la dernière commande exécutée, à moins qu'une erreur de syntaxe ne se produise, auquel cas il renvoie une valeur non-nulle. Voir également la commande interne exit plus bas.  

SYMBOLE D'ACCUEIL (PROMPT)

Quand il est exécuté de manière interactive, bash affiche le symbole d'accueil principal PS1 dès qu'il est prêt à lire une commande, et le symbole d'accueil secondaire PS2 quand il a besoin de plus de données pour exécuter une commande. Bash permet de personnaliser ces chaînes d'accueil, en insérant des séquences d'échappement spéciales (préfixées par un backslash) ayant les significations suivantes :
\t
l'heure actuelle au format HH:MM:SS
\d
la date au format "Jour_de_la_semaine Mois Quantième" (ex : "Tue May 26")

retour-chariot
\s
le nom du shell, c'est à dire le nom de base de $0 (la portion suivant le dernier slash)
\w
le répertoire de travail en cours
\W
le nom de base du répertoire de travail en cours
\u
le nom de l'utilisateur
\h
le nom d'hôte de la machine
\#
le numéro de la commande
\!
le numéro d'historique de la commande
\$
# si l'UID effectif est 0, $ sinon

nn
le caractère de code octal nnn
\\
un backslash
\[
débute une série de caractères non-imprimables, qui permettent d'inclure des séquences de contrôle de terminal dans une chaîne d'accueil
\]
fin d'une série de caractères non-imprimables

Le numéro de commande, et le numéro d'historique sont généralement différents : le numéro d'historique d'une commande correspond à sa position dans la liste d'historique qui peut contenir des commandes relues depuis cette liste (voir le paragraphe HISTORIQUE plus bas), alors que le numéro de commande est simplement une position dans la séquence de commandes exécutées depuis le début de la session shell actuelle. Apres que la chaîne d'invite ait été décodée, elle est soumise à l'expansion des paramètres, substitution de commandes, évaluation arithmétique et découpage des mots.  

BIBLIOTHÈQUE READLINE

Il s'agit de la bibliothèque qui gère la saisie lors des sessions interactives du shell, à moins que l'option -nolineediting n'ait été choisie. Par défaut les commandes d'édition de ligne sont similaires à celles d'emacs. Il est également possible de disposer d'une interface d'édition du style vi.

Dans ce paragraphe on utilisera la notation "à la emacs" pour indiquer les séquences de touches. Les touches Contrôle sont notées C-touche, par exemple C-n signifie Contrôle-N. De même, les touches Méta sont notées par M-touche, ainsi M-x signifie Méta-X. (Sur les claviers sans touches Méta, M-x signifie ESC x (sur les claviers français ESC est noté Échappement), autrement dit presser la touche Échappement puis la touche x. On dit alors qu'ESC est le préfixe méta. La séquence M-C-x signifie ESC-Contrôle-x, ou encore Presser la touche Échappement puis maintenez la touche Contrôle enfoncée tout en pressant la touche x.

L'affectation par défaut des touches peut être modifiée dans le fichier ~/.inputrc. La valeur de la variable shell INPUTRC, si elle existe, est utilisée à la place du fichier ~/.inputrc. D'autres programmes qui utilisent cette bibliothèque peuvent ajouter leurs propres affectations de touches.

Par exemple, en plaçant

M-Control-u: universal-argument

ou
C-Meta-u: universal-argument
dans le fichier ~/.inputrc, on affectera à la séquence de touche M-C-u la commande readline universal-argument.

Les caractères symboliques suivants sont acceptés : RUBOUT, DEL, ESC, LFD, NEWLINE, RET, RETURN, SPC, SPACE, et TAB. En plus des noms de commandes, readline permet d'affecter aux touches des chaînes de caractères qui seront insérées lorsque la touche sera pressée (une macro).

Readline peut être personnalisé en ajoutant des commandes dans le fichier d'initialisation dont le nom est contenu dans la variable INPUTRC, ou, s'il elle n'existe pas, dans le fichier ~/.inputrc. Quand un programme qui utilise la bibliothèque readline démarre, le fichier d'initialisation est lu, et les affectations de touches et de variables sont effectuées. Il n'y a que peu de constructions autorisées dans le fichier d'initialisation. Les lignes blanches sont ignorées. Les lignes commençant par # sont considérées comme des commentaires, les lignes commençant par un $ indique une construction conditionnelle. Les autres lignes contiennent les affectations de touches et les assignations de variables.

La syntaxe des affectations de touches dans le fichier ~/.inputrc est simple. Les seules choses nécessaires sont le nom d'une commande, ou le texte d'une macro, et la séquence de touches à laquelle il faut l'affecter. Les touches peuvent être indiquées de deux manières : sous forme de nom symbolique, éventuellement précédé de Meta- ou Control-, ou sous forme de séquence de touches. Lorsque l'on utilise la forme touche:nom_de_fonction ou macro, touche est le nom de la séquence de touches épelée en Anglais. Par exemple :

Control-u: universal-argument
Meta-Rubout: backward-kill-word
Control-o: ">&sortie"

Dans ces exemples, C-u est assigné à la fonction universal-argument, M-DEL à la fonction backward-kill-word, et C-o est affecté à la macro exprimée dans la partie gauche (c'est à dire insèrera >&sortie sur la ligne).

Avec la seconde forme, "touches":nom_de_fonction ou macro, touches n'est plus un nom symbolique, mais décrit une séquence complète de touches entre guillemets. Certaines séquences d'échappement dans le style GNU Emacs peuvent être utilisée, comme dans l'exemple suivant :

"\C-u": universal-argument
"\C-x\C-r": re-read-init-file
"\e[11~": "Touche Fonction 1"

Dans cet exemple, C-u est à nouveau assigné à la fonction universal-argument, C-x C-r à la fonction re-read-init-file, et ESC [ 1 1 ~ insèrera le texte Touche Fonction 1. L'ensemble complet des séquences d'échappement est le suivant :

\C-
préfixe Contrôle
\M-
préfixe Méta
\e
caractère d'échappement
\\
backslash
\
un guillemet littéral
\'
un apostrophe littéral

Lorsque l'on saisit le texte d'une macro, il faut utiliser des apostrophes ou des guillemets pour indiquer la définition de la macro. Les textes non protégés sont considérés comme des noms de fonctions. Le backslash protègera n'importe quel caractère dans la définition d'une macro, y compris " et '.

Bash permet d'afficher ou de modifier les affectations des touches avec la commande interne bind. On peut changer de mode d'édition durant une session interactive en utilisant l'option -o de la commande interne set (voir le paragraphe COMMANDES INTERNES DU SHELL plus bas).

Readline dispose de variables permettant de personnaliser encore plus son comportement. Une variable peut être configurée dans le fichier inputrc avec une déclaration de la forme

set nom_de_variable valeur

Sauf contre-indication, les variables de readline prennent les valeurs On ou Off. Les variables, et leurs valeurs par défaut, sont :

horizontal-scroll-mode (Off)
Si cette variable contient la valeur On, readline utilisera une seule ligne d'affichage, et la fera défiler horizontalement si elle devient plus longue que la largeur de l'écran, plutôt que de basculer sur une nouvelle ligne.
editing-mode (emacs)
Cette variable indique si readline doit démarrer avec des affectations de touches similaires à emacs ou à vi. editing-mode peut prendre les valeurs emacs ou vi.
mark-modified-lines (Off)
Si cette variable est configurée sur On, les lignes d'historique qui ont été modifiées seront précédées à l'affichage d'un astérisque (*).
bell-style (audible)
Cette variable permet de contrôler le comportement de readline lorsqu'il faut déclencher le signal sonore du terminal. Si cette variable contient la valeur none, readline n'utilise pas le signal sonore ; si elle contient visible, readline utilise un avertisseur visuel si c'est possible ; si elle contient audible, readline essaie d'utiliser le signal sonore du terminal.
comment-begin (``#'')
Cette chaîne est insérée dans le mode vi quand la commande vi-comment est exécutée.
meta-flag (Off)
Si cette variable contient la valeur On, readline acceptera des saisies sur huit bits (autrement dit il ne supprimera pas le huitième bit), quelque soit le terminal utilisé.
convert-meta (On)
Si cette variable contient la valeur On, readline transformera en séquences ASCII les caractères ayant leur huitième bit à 1. Il suprimera ce huitième bit, et insèrera comme préfixe le caractère d'échappement (en utilisant ce caractère d'échappement comme préfixe méta).
output-meta (Off)
Si cette variable contient la valeur On, readline affichera directement les caractères ayant leur huitième bit à 1, plutôt que d'utiliser une séquence d'échappement avec le préfixe méta.
completion-query-items (100)
Lors de la complétion de commandes, si le nombre de possibilités est supérieur à cette valeur, on demandera confirmation à l'utilisateur avant d'afficher la liste des possibilités. Le nombre de complétions possibles est déterminé par la commande possible-completions.
keymap (emacs)
Configure l'affectation des touches. Les jeux d'affectations disponibles sont emacs, emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move, vi-command, et vi-insert. vi est équivalent à vi-command; emacs est équivalent à emacs-standard. La valeur par defaut est emacs; notez que la configuration de la variable editing-mode modifie aussi l'affectation par défaut.
show-all-if-ambiguous (Off)
Cette variable agit sur la complétion des commandes. Lorsqu'elle contient la valeur on, toutes les complétions possibles sont affichées immédiatement plutôt que de déclencher l'avertisseur sonore.
expand-tilde (Off)
Si cette variable contient la valeur on, le développement du tilde est effectué lorsque readline tente une complétion de commandes.

Readline propose un mécanisme inspiré des possibilités de compilation conditionnelle en C, qui permet d'effectuer certaines assignations de variables, ou affectations de touches en fonction du résultat d'un test. Il y a trois directives utilisables.

$if
La structure $if permet d'affecter les touches en fonction du mode d'édition, du terminal de saisie, ou de l'application qui utilise la bibliothèque readline. Le texte du test se trouve à la suite du $if, jusqu'à la fin de la ligne.
mode
La forme mode= de la structure $if permet de vérifier si readline est en mode emacs ou en mode vi. Ceci peut être utilisé conjointement à la commande set keymap, par exemple pour ne configurer les jeux de touches emacs-standard et emacs-ctlx que si readline démarre en mode emacs.
term
La forme term= peut être utilisée pour ajouter des affectations de touches spécifiques au terminal, par exemple sur des touches de fonction. Le mot à droite du signe = est comparé au nom complet du terminal, et à la portion de ce nom qui précède un éventuel signe -. Ceci permet, par exemple, de faire correspondre le mot sun aussi bien au terminal sun qu'au terminal sun-cmd.
application
La forme application permet d'inclure des configurations spécifiques à l'application. Chaque programme utilisant la bibliothèque readline configure un nom d'application, et un fichier d'initialisation peut dépendre de ce nom. Ceci est utile pour des affectations de touches intéressantes pour un programme spécifique. Par exemple, les commandes suivantes ajoutent une séquence de touches capable de protèger par des guillemets le mot courant ou le mot précédent, sous Bash :
$if Bash
# Protéger le mot actuel ou le précédent
"\C-xq": "\eb\"\ef\""
$endif
$endif
Cette commande, comme vous l'avez deviné dans l'exemple ci-dessus, termine une commande $if.
$else
Permet d'ajouter des commandes qui seront exécutées si un $if échoue.

Les commandes de readline peuvent recevoir un argument numérique, généralement un nombre de répétitions. Parfois il arrive que le signe de cet argument soit significatif. En passant un argument négatif à une commande qui agit vers l'avant (par exemple kill-line), on inversera le sens d'action de cette commande. On détaillera les commandes dont les arguments ont un comportement particulier.

Quand une commande est décrite comme destructive (killing), le texte effacé est sauvegardé pour une éventuelle récupération ulterieure (yanking). Le texte est sauvegardé dans des tampons circulaires(kill-ring). Les destructions successives accumulent les textes dans le même tampon qui peut être récupéré en une seule fois. Les commandes qui ne détruisent pas de texte permettent de séparer les différents tampons.

Voici une liste des noms de commandes, ainsi que les séquences de touches auxquelles elles sont attribuées par défaut.  

Commandes de déplacement

beginning-of-line (C-a)
Saut au début de la ligne en cours.
end-of-line (C-e)
Saut à la fin de la ligne.
forward-char (C-f)
Avancer d'un caractère.
backward-char (C-b)
Reculer d'un caractère.
forward-word (M-f)
Avancer jusqu'à la fin du mot suivant. Les mots sont composés de caractères alphanumééiques (lettres et chiffres).
backward-word (M-b)
Reculer jusqu'au début du mot courant, ou du précédent. Les mots sont composés de caractères alphanumériques (lettres et chiffres).
clear-screen (C-l)
Effacer l'écran, en laissant la ligne courante en haut de l'ecran. S'il y a un argument, rafraîchir la ligne en cours sans effacer l'écran.
redraw-current-line
Rafraîchir la ligne en cours. Par défaut pas d'affectation de touche.
 

Commandes de manipulation de l'historique

accept-line (Retour-Chariot)
Valider la ligne, sans se soucier de l'emplacement du curseur. Si cette ligne est non vide, l'ajouter à la liste d'historique, en fonction de l'état de la variable HISTCONTROL. Si cette ligne est une modification d'une ligne de l'historique, restaurer cette dernière.
previous-history (C-p)
Récupérer la commande précédente de la liste d'historique.
next-history (C-n)
Récupérer la commande suivante dans la liste d'historique.
beginning-of-history (M-<)
Récupérer la première ligne de l'historique.
end-of-history (M->)
Retourner à la fin de l'historique, c'est à dire à la ligne en cours d'édition.
reverse-search-history (C-r)
Rechercher en arrière dans l'historique, en remontant. C'est une recherche incrémentale.
forward-search-history (C-s)
Rechercher en avant dans l'historique, en descendant. C'est une recherche incrémentale.
non-incremental-reverse-search-history (M-p)
Rechercher une chaîne en arrière dans l'historique, en remontant depuis la ligne actuelle, utiliser une recherche non-incrémentale.
non-incremental-forward-search-history (M-n)
Rechercher une chaîne en avant dans l'historique, utiliser une recherche non-incrémentale.
history-search-forward
Rechercher en avant dans l'historique la chaîne comprise entre le début de la ligne actuelle, et la position du curseur. Par défaut cette commande n'est affectée à aucune touche.
history-search-backward
Rechercher en arrière dans l'historique la chaîne comprise entre le début de la ligne actuelle, et la position du curseur. Par défaut cette commande n'est affectée à aucune touche.
yank-nth-arg (M-C-y)
Insérer, à l'emplacement du curseur, le premier argument de la commande précédente. Généralement il s'agit du second mot de la ligne précédente. Avec un argument n, insérer le nième mot de la commande précédente (les mots sont numérotés à partir de 0). Un argument négatif insère le nième mot en partant de la fin de la commande précédente.
yank-last-arg (M-., M-_)
Insérer à la position du curseur le dernier argument de la commande précédente (le dernier mot de la ligne précédente). Avec un argument, se comporte exactement comme yank-nth-arg.
shell-expand-line (M-C-e)
Développer, comme le fait le shell, la ligne en cours. Ceci inclut le remplacement des alias et des directives d'historique, aussi bien que l'ensemble des expansions effectuées par le shell. Voir le paragraphe EXPANSION DE L'HISTORIQUE plus bas, pour une description détaillée.
history-expand-line (M-^)
Effectuer l'expansion d'historique sur la ligne en cours. Voir le paragraphe EXPANSION DE L'HISTORIQUE plus bas, pour une description détaillée.
insert-last-argument (M-., M-_)
un synonyme de yank-last-arg.
operate-and-get-next (C-o)
Valider la ligne en cours, et recupérer la ligne suivante de l'historique pour l'édition. Tout argument est ignoré.
 

Commande d'édition de texte

delete-char (C-d)
Effacer le caractère sous le curseur. Si le curseur est au début de la ligne, si celle-ci est vide, et si le dernier caractère frappé n'était pas C-d, alors la valeur renvoyée est EOF.
backward-delete-char (Rubout)
Effacer le caractère derrière le curseur. Lorsque un argument est fourni, le texte effacé est sauvegardé dans un buffer.
quoted-insert (C-q, C-v)
Ajouter littéralement sur la ligne le caractère frappé suivant. Ceci permet d'insérer des caractères comme C-q, par exemple.
tab-insert (C-v TAB)
Insérer un caractère de tabulation.
self-insert (a, b, A, 1, !, ...)
Insérer le caractère mentionné.
transpose-chars (C-t)
Echanger les caractères se trouvant devant et sous le curseur. Le curseur est alors avancé d'un caractère. S'il se trouve à la fin d'une ligne, les caractères échangés sont les deux précédents. Les arguments négatifs ne sont pas acceptés.
transpose-words (M-t)
Echanger le mot où se trouve le curseur et le mot précédent, puis avancer le curseur après ce mot.
upcase-word (M-u)
Transformer le mot en cours (ou le suivant) en majuscules. Avec un argument négatif, agir sur le mot précédent mais ne pas déplacer le curseur.
downcase-word (M-l)
Transformer le mot en cours (ou le suivant) en minuscules. Avec un argument négatif, agir sur le mot précédent mais ne pas déplacer le curseur.
capitalize-word (M-c)
Passer en majuscule l'initiale du mot en cours (ou du suivant). Avec un argument négatif, agir sur le mot précédent mais ne pas déplacer le curseur.
 

Effacement et récuperation

kill-line (C-k)
Effacer le texte depuis l'emplacement du curseur jusqu'à la fin de la ligne.
backward-kill-line (C-x C-Rubout)
Effacer en arrière jusqu'au début de ligne.
unix-line-discard (C-u)
Effacer le texte entre le début de la ligne et l'emplacement du curseur.
kill-whole-line
Effacer toute la ligne sans tenir compte de la position du curseur. Par défaut cette fonction n'est affectée à aucune touche.
kill-word (M-d)
Effacer le texte entre l'emplacement du curseur et la fin du mot en cours, ou jusqu'à la fin du mot suivant si le curseur est entre deux mots. Les séparations de mots sont les mêmes que celles de forward-word.
backward-kill-word (M-Rubout)
Effacer le mot sous le curseur Les séparations de mots sont les mêmes que celles de backward-word.
unix-word-rubout (C-w)
Effacer le mot derrière le curseur, en utilisant l'espace blanc comme limite de mot. Cette limite est différente de celle de backward-kill-word.
delete-horizontal-space
Effacer tous les espaces blancs et les tabulations autour du curseur. Par défaut cette commande n'est affectée à aucune touche.
yank (C-y)
Récupérer le texte au sommet du tampon circulaire.
yank-pop (M-y)
Exécuter une rotation du tampon circulaire, et récupérer le nouveau texte situé à son sommet. Ceci ne fonctionne qu'après yank ou yank-pop.
 

Arguments numériques

digit-argument (M-0, M-1, ..., M--)
Ajouter le chiffre aux arguments déjà présents, ou créer un nouvel argument. M-- crée un argument négatif.
universal-argument
Chaque fois que cette commande est exécutée, le compteur d'arguments est multiplié par 4. Ce compteur est initialement à 1, aussi en exécutant la fonction une fois il passera à 4. Par défaut cette commande n'est affectée à aucune touche.
 

Complétion

complete (TAB)
Essayer d'effectuer une complétion du texte situé avant le curseur. Bash effectue la complétion en considèrant successivement le texte comme une variable (s'il commence par $), un nom d'utilisateur (s'il commence par ~), un nom d'hôte (s'il commence par @), ou une commande (y compris les alias et les fonctions). Si rien ne fonctionne, il essaye la complétion en nom de fichier.
possible-completions (M-?)
Affiche la liste des complétions possibles pour le texte situé avant le curseur.
insert-completions
Insérer l'ensemble des complétions du texte situé avant le curseur. Par défaut cette commande n'est affectée à aucune touche.
complete-filename (M-/)
Essayer la complétion des noms de fichiers sur le texte situé avant le curseur.
possible-filename-completions (C-x /)
Affiche la liste des complétions possibles en noms de fichiers pour le texte situé avant le curseur.
complete-username (M-~)
Essayer la complétion des noms d'utilisateurs sur le texte situé avant le curseur.
possible-username-completions (C-x ~)
Affiche la liste des complétions possibles en noms d'utilisateurs pour le texte situé avant le curseur.
complete-variable (M-$)
Essayer la complétion des noms de variables shell sur le texte situé avant le curseur.
possible-variable-completions (C-x $)
Affiche la liste des complétions possibles en noms de variables shell pour le texte situé avant le curseur.
complete-hostname (M-@)
Essayer la complétion des noms d'hôtes sur le texte situé avant le curseur.
possible-hostname-completions (C-x @)
Affiche la liste des complétions possibles en noms d'hôtes pour le texte situé avant le curseur.
complete-command (M-!)
Essayer la complétion des commandes sur le texte situé avant le curseur. La complétion des commandes inclut les alias, les mots réservés, les fonctions shell, les fonctions internes, et finalement les exécutables, dans cet ordre.
possible-command-completions (C-x !)
Affiche la liste des complétions possibles en noms de commandes pour le texte situé avant le curseur.
dynamic-complete-history (M-TAB)
Essayer la complétion du texte situé avant le curseur, en recherchant dans la liste d'historique.
complete-into-braces (M-{)
Affiche la liste des complétions possibles en noms de fichiers pour le texte situé avant le curseur, en renvoyant la liste entre accolades, afin qu'elle soit utilisable par le shell (voir le paragraphe Expansion des Accolades plus haut).
 

Macros Claviers

start-kbd-macro (C-x ()
Démarre la mémorisation dans la macro en cours des caractères tapés.
end-kbd-macro (C-x ))
Arrête la mémorisation dans la macro en cours des caractères tapés, et sauvegarde la définition.
call-last-kbd-macro (C-x e)
Ré-exécute la derniere macro définie, en agissant comme si les caractères contenus dans cette macro étaient tapés au clavier.
 

Divers

re-read-init-file (C-x C-r)
Lire le contenu du fichier d'initialisation personnalisée, en incorporant les assignations de variables, ou les affectations de touches qui s'y trouvent.
abort (C-g)
Abandonner l'édition en cours et déclencher l'avertisseur sonore (soumis à la configuration de la variable bell-style).
do-uppercase-version (M-a, M-b, ...)
Exécuter la commande correspondant aux caractères majuscules indiqués.
prefix-meta (ESC)
Considérer le prochain caractère tapé comme une séquence Meta. ESC f est équivalent à Meta-f.
undo (C-_, C-x C-u)
Fonction d'annulation incrémentale, chaque ligne étant mémorisée séparement.
revert-line (M-r)
Annuler toutes les modifications sur cette ligne. Ceci est équivalent à répéter commande undo en nombre suffisant pour ramener la ligne à son état initial.
tilde-expand (M-~)
Effectuer le développement du tilde sur le mot en cours.
dump-functions
Afficher toutes les fonctions et leurs assignations de touches sur le flux de sortie de readline. Si un argument numérique est présent, la sortie est mise en forme pour être compatible avec le format d'un fichier inputrc.
display-shell-version (C-x C-v)
Afficher des informations sur la version de bash en cours d'exécution.
 

HISTORIQUE

En mode interactif, l'interpréteur donne accès à un historique des commandes, c'est à dire la liste des commandes précédemment utilisées. Le texte des HISTSIZE dernières commandes (par défaut 500) est mémorisé dans l'historique. Le shell les enregistre avant expansion des paramètres et variables (voir le paragraphe EXPANSION plus haut) mais après avoir effectué l'expansion historique, sous contrôle des variables command_oriented_history et HISTCONTROL. Au démarrage, l'historique est initialisé avec le fichier dont le nom est contenu dans la variable HISTFILE (par défaut ~/.bash_history). HISTFILE est tronqué si nécessaire, pour ne pas dépasser HISTFILESIZE lignes. La commande interne fc (voir le paragraphe COMMANDES INTERNES DU SHELL plus bas) permet d'afficher, d'éditer, ou de ré-exécuter une partie de l'historique. La commande interne history permet d'afficher l'historique et de manipuler le fichier d'historique. Quelque soit le mode d'édition en ligne de commande, des commandes de recherche sont disponibles pour accéder à l'historique. Lorsqu'un shell interactif se termine, les HISTSIZE dernières lignes de l'historique sont copiées dans le fichier HISTFILE. Si la variable HISTFILE n'existe pas, ou si le fichier n'est pas accessible en écriture, l'historique n'est pas enregistré.  

EXPANSION DE L'HISTORIQUE

Le shell propose des possibilités d'expansion de l'historique qui sont semblables à celles de csh. Ce paragraphe décrit la syntaxe de ces commandes. Elles sont utilisables par défaut dans les shells interactifs, il est toutefois possible de les désactiver en utilisant l'option +H de la commande interne set (voir le paragraphe COMMANDES INTERNES DU SHELL plus bas). Les shells non-interactifs n'effectuent pas d'expansion d'historique.

Le développement de l'historique est fait immédiatement après la lecture d'une ligne complète, avant que le shell ne fasse la séparation des mots. Il se déroule en deux parties. La première consiste à déterminer la ligne de l'historique à utiliser pour les substitutions, la seconde permet de sélectionner les parties de la lignes à inclure dans la nouvelle ligne. La ligne sélectionnée dans l'historique est l'évènement, et les parties de cette ligne à réutiliser sont des mots. La ligne est découpée en mots de la même manière que lors d'une saisie, ainsi plusieurs mots séparés par des méta-caractères, et protégés par des guillemets sont considérés comme un unique mot. Seul le backslash (\) et les apostrophes permettent de protéger le caractère d'échappement de l'historique, par défaut !.

Le shell offre le contrôle des divers caractères utilisés par le mécanisme d'expansion de l'historique (voir la description de histchars plus haut dans le paragraphe Variables du Shell).  

Indicateur d'évènement

Un indicateur d'évènement est une référence à une ligne de commande dans la liste d'historique.

!
Débute une substitution de l'historique, sauf s'il est suivi par un blanc, retour-chariot, = ou (.
!!
Est une référence à la commande précédente. C'est un synonyme de `!-1'.
!n
Se réfère à la ligne de commande n.
!-n
Se réfère à la ligne de commande actuelle moins n.
!chaîne
Référence la plus récente commande commençant par la chaîne.
!?chaîne[?]
Se réfère à la plus récente commande contenant la chaîne.
^chaîne_1^chaîne_2^
Substitution rapide. Répéter la dernière commande en remplaçant la chaîne_1 par la chaîne_2. Equivalent à ``!!:s/chaîne_1/chaîne_2/'' (voir Modificateurs plus bas).
!#
La ligne entière tapée jusqu'à présent.
 

Indicateurs de mots

Un : sépare l'indicateur d'évènements de l'indicateur de mot. On peut l'omettre si l'indicateur de mot commence par ^, $, *, ou %. Les mots sont numérotés depuis le début de la ligne, le premier étant note 0 (zéro).

0 (zéro)
Le zéro-ième mot. Pour le shell, c'est le nom de la commande.
n
Le n-ième mot.
^
Le premier argument, c'est à dire le mot 1.
$
Le dernier argument.
%
Le mot ayant été mis en correspondance lors de la dernière recherche `?chaîne?'.
x-y
Un intervalle de mots, `-y' permet d'abréger `0-y'.
*
Tous les mots sauf le zéro-ième. C'est un synonyme pour `1-$'. Même s'il n'y a qu'un mot, * ne déclenche pas d'erreur, simplement la chaîne vide est renvoyée.
x*
Abréviation de x-$.
x-
Abréviation de x-$ comme x*, mais sans le dernier mot.
 

Modificateurs

Après l'éventuel indicateur de mot, vous pouvez ajouter une séquence de modificateurs, chacun précédé par un `:'.

h
Elimine la fin du chemin d'accès, ne laissant que son début.
r
Supprime un suffixe final de la forme .xxx, en ne laissant que le nom de base.
e
Tout supprimer sauf le suffixe final.
t
Supprimer tout les composants initiaux d'un chemin d'accès, en ne laissant que la fin.
p
Afficher la nouvelle commande sans l'exécuter.
q
Protéger les mots substitués, pour éviter les substitutions futures.
x
Protéger les mots substitués, comme avec q, mais en faisant la séparation des mots sur les blancs et les retour-chariots.
s/ancien/nouveau/
Remplacer par nouveau la première occurence de ancien sur la ligne d'évènement. N'importe quel délimiteur peut être utilisé à la place de /. Le dernier délimiteur est facultatif si c'est le dernier caractère de la ligne d'évènement. Le délimiteur peut être protégé dans ancien et nouveau par un simple backslash. Si & apparaît dans nouveau, il est remplacé par ancien. Un simple backslash protégera le &.
&
Répéter la substitution précédente.
g
Appliquer les changements sur la ligne d'évènement entière. On utilise ceci conjointement à `:s' (par exemple `:gs/ancien/nouveau/') ou `:&'. S'il est utilisé avec `:s', n'importe quel délimiteur peut être utilisé à la place de /, et le dernier délimiteur est facultatif si c'est le dernier caractère de la ligne d'évènement.
 

CALCUL ARITHMÉTIQUE

Le shell permet, dans certaines circonstances, l'évaluation d'expression arithmétique (voir la commande interne let ainsi que le paragraphe Évaluation Arithmétique). L'évaluation est effectuée en utilisant des entiers longs, sans vérification du débordement. Néanmoins la division par 0 est détectée et renvoie une erreur. La liste des opérateurs ci-dessous est constituée par des groupes de précédence identique. Les niveaux sont classés en ordre de précédence décroissante.

- +
plus et moins unaire
! ~
négations logique et binaire
* / %
multiplication, division, reste
+ -
addition, soustraction
<< >>
décalage arithmétique à gauche et à droite
<= >= < >
comparaisons
== !=
égalite et différence
&
ET binaire
^
OU exclusif binaire
|
OU binaire
&&
ET logique
||
OU logique
= *= /= %= += -= <<= >>= &= ^= |=
assignations

On peut utiliser les variables du shell comme opérandes, le développement des paramètres étant effectué avant l'évaluation arithmétique. Les valeurs des paramètres sont converties en entiers longs dans les expressions. Une variable shell n'a donc pas besoin d'avoir l'attribut "entier" pour être utilisable dans un calcul.

Les constantes commençant par un 0 sont interprétées comme des nombres octaux. Un entête 0x ou 0X indique une valeur héxadécimale. Sinon, les nombres ont la forme [base#]n, ou la base arithmétique est un nombre décimal entre 2 et 36, et n le nombre lui-même exprimé dans cette base. Si la base n'est pas mentionnée, le nombre est considéré comme décimal.

Les opérateurs sont évalués dans l'ordre de précédence. Les sous-expressions entre parenthèses sont évaluées en premier, ce qui permet de surpasser les règles de précédence.  

COMMANDES INTERNES DU SHELL

: [arguments]
Pas d'effet. Cette commande ne fait rien d'autre que l'expansion des arguments et la mise en place des redirections. Le code de retour est nul.
. fichier [arguments]
source fichier [arguments]
Lire et exécuter les commandes contenues dans le fichier avec l'environnement du shell en cours, puis renvoyer le code de retour de la dernière commande exécutée dans le fichier. Si le nom du fichier ne contient pas de slash, on utilise les chemins d'accès contenus dans la variable PATH pour rechercher le répertoire contenant le fichier. Lorsqu'il est recherché dans le PATH le fichier n'a pas besoin d'être exécutable. Le répertoire de travail en cours est finalement examiné si aucun fichier n'est trouvé dans le PATH. Si des arguments sont fournis, ils sont transmis dans les paramètres positionnels lorsque le fichier est exécuté. Sinon les paramètres positionnel ne sont pas modifiés. Le code de retour est celui de la dernière commande exécutée au sein du script (0 si aucune commande n'est exécutée), et faux si le fichier n'est pas trouvé.
alias [nom[=valeur] ...]
La commande alias, sans argument, affiche sur la sortie standard la liste des alias actuellement définis, sous la forme nom=valeur. Lorsque l'on fournit des arguments, un alias est créé pour chaque nom auquel on a donné une valeur. Un espace final dans une valeur forcera la recherche d'alias dans le mot suivant lors de l'expansion de l'alias. Pour chacun des noms pour lesquels aucune valeur n'est fournie dans la liste d'arguments, le nom et la valeur de l'alias sont affichés. La commande Alias renvoie vrai, sauf si l'on indique un nom pour lequel aucun alias n'a été défini.
bg [job]
Bascule le job en arrière-plan, comme s'il avait été lancé avec &. Si aucun job n'est précisé, le job en cours est basculé en arrière-plan. bg job renvoie 0 si le contrôle des jobs est désactivé, ou si le job n'existe pas, ou encore s'il a été lancé sans contrôle de jobs.
bind [-m jeu_de_touches] [-lvd] [-q nom]
bind [-m jeu_de_touches] -f fichier
bind [-m jeu_de_touches] sequence:fonction
Affiche les affectations de touches readline pour une fonction, ou affecte une séquence de touches à une fonction ou une macro readline. La syntaxe d'affectation est identique à celle des fichiers .inputrc, mais chaque affectation doit être fournie sous forme d'argument indépendant, par exemple '"\C-x\C-r": re-read-init-file'. Les éventuelles options ont les significations suivantes :
-m jeu_de_touches
Modifier la configuration du jeu_de_touches indiqué. Les noms des jeux_de_touches acceptés sont emacs, emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move, vi-command, et vi-insert. vi est équivalent à vi-command; emacs est équivalent à emacs-standard.
-l
Afficher la liste des noms de toutes les fonctions readline
-v
Afficher les affectations actuelles
-d
Afficher les fonctions et les affectations de manière à pouvoir les réutiliser
-f fichier
Lire les affectations dans le fichier
-q fonction
Rechercher la touche permettant d'invoquer la fonction indiquée

La valeur de retour est nulle, sauf si une option invalide est fournie, ou si une erreur se produit.

break [n]
Sortir d'une boucle for, while, ou until. Si n est fourni, sortir de n niveaux de boucles. n doit être > 1. Si n est supérieur au nombre de boucles imbriquées, on sort de l'ensemble d'entre elles. La valeur de retour est nulle, sauf si le shell n'exécute pas de boucle lorsque le break est atteint.
builtin commande_interne [arguments]
Exécuter la commande interne du shell indiquée, en lui passant les arguments, puis renvoyer son code de retour. Ceci est utile lorsque l'on veut définir une fonction ayant le même nom qu'une commande interne, mais que l'on a besoin d'invoquer cette commande depuis l'intérieur de la fonction. On redéfinit souvent la commande interne cd ainsi. Le code de retour est faux si la commande_interne n'existe pas.
cd [rep]
Remplacer le répertoire de travail en cours par rep. La variable HOME est la valeur par défaut de rep. La variable CDPATH définit des chemins de recherche pour trouver le répertoire contenant rep. Les répertoires possibles y sont fournis dans une liste séparées par des doubles-points (:). Un nom de répertoire nul dans CDPATH est équivalent au répertoire en cours, c'est à dire ``.''. Si rep coommence par un slash (/), alors CDPATH n'est pas utilisé. Un argument - est équivalent à $OLDPWD. La valeur de retour est vraie si l'on a pu changer le répertoire de travail, et fausse sinon.
command [-pVv] commande [arguments ...]
Lancer la commande avec les arguments indiqués, mais en simplifiant le processus habituel de recherche des commandes. Seules les commandes internes, et les commandes disque trouvées dans le PATH seront exécutées. Si l'option -p est fournie, la recherche utilisera une valeur par défaut du PATH garantissant de trouver tous les utilitaires standards. Si l'option -V ou l'option -v sont fournies, une description de la commande est affichée. L'option -v n'affiche qu'un simple mot indiquant la commande interne, ou le chemin d'accès utilisé pour invoquer la commande. L'option -V fournit une description plus volubile. Un argument -- arrête la recherche d'options dans la suite des arguments. Si les options -V ou -v sont fournies, le code de retour est 0 si la commande est trouvée, et 1 sinon. Si aucune option n'est fournie, et si une erreur se produit, ou si la commande est introuvable, le code de retour est 127. Sinon, le code de retour de cette commande interne est celui de la commande invoquée.
continue [n]
Reprendre l'exécution à l'itération suivante d'une boucle for, while, ou until. Si n est indiqué, reprendre l'exécution à la n-ième boucle imbriquée. n doit être > 1. Si n est supérieur au nombre de boucles imbriquées, l'exécution reprend à la boucle la plus externe (`top-level'). La valeur de retour est 0 sauf si le shell n'exécutait pas de boucle quand il a rencontré l'instruction continue.
declare [-frxi] [nom[=valeur]]
typeset [-frxi] [nom[=valeur]]
Déclarer des variables et/ou leur fournir des attributs. Si aucun nom n'est mentionné, les valeurs des variables sont affichées. Les options permettent de restreindre l'affichage aux variables dotées de certains attributs.
-f
Seulement les noms de fonctions
-r
Rend les noms accessibles en lecture seulement. On ne pourra plus modifier les valeurs de ces noms lors d'assignations ultérieures.
-x
Marquer le nom pour qu'il soit exporté dans l'environnement des commandes suivantes.
-i
La variable est traitée comme un entier. L'évaluation arithmétique (voir plus haut le paragraphe EVALUATION ARITHMÉTIQUE ) est effectuée lorsque la variable reçoit une valeur.

En utilisant `+' a la place de `-', l'attribut correspondant est désactivé. Dans une fonction, le nom devient local, comme avec la commande local. La valeur de retour est 0 sauf si une option illégale est rencontrée, si on essaye de définir une fonction en utilisant "-f foo=bar", si l'un des noms n'est pas un nom légal pour le shell, si on essaye de supprimer l'attribut lecture-seule d'une variable, ou si on essaye d'afficher avec -f une fonction inexistante.

dirs [-l] [+/-n]
Affiche la liste des répertoires actuellement mémorisés. On ajoute des répertoires dans cette liste avec la commande pushd, on revient en arrière avec la commande popd.
+n
affiche le n-ième élément de la liste fournie par dirs sans options, en comptant à partir de la gauche en commençant à zéro.
-n
affiche le n-ième élément de la liste fournie par dirs sans options, en comptant à partir de la droite en commençant à zéro.
-l
affiche une liste longue, le format par défaut utilisant le tilde pour représenter le répertoire personnel.

La valeur de retour est 0 sauf si une option illégale a été trouvée, ou si l'index n dépasse la longueur de la pile des répertoires.

echo [-neE] [arguments ...]
Affiche ses argumentss, séparés par des espaces. La valeur de retour est toujours nulle. Avec l'option -n, le retour-chariot final est supprimé. Avec l'option -e l'interprétation des séquences d'échappement est activée. L'option -E désactive l'interprétation des séquences d'échappement, même sur les systèmes où elles sont interprétées par défaut.
\a
alerte (avertisseur sonore)
\b
backspace
\c
suppression du retour-chariot final
\f
saut de page

nouvelle ligne
\r
retour-chariot
\t
tabulation horizontale
\v
tabulation verticale
\\
backslash

nn
le caractère dont le code ASCII vaut nnn (en octal)
enable [-n] [-all] [nom ...]
Active ou inhibe les commandes internes du shell. Ceci permet d'exécuter une commande disque ayant le même nom qu'une commande interne du shell, sans avoir besoin d'indiquer le chemin d'accès complet. Avec l'option -n, chaque nom indiqué est inhibé, sinon ils sont activés. Par exemple, pour utiliser le programme binaire test qui se trouve dans le PATH plutôt que la commande interne, utilisez ``enable -n test''. Si aucun argument n'est fourni, la liste des commandes internes actives est affichée. Si seule l'option -n est fournie, la liste des commandes internes inhibées est affichée. Si seule l'option -all est fournie, la liste de toutes les commandes internes est affichée, avec pour chacune l'indication de l'activation ou inhibition. enable accepte -a comme synonyme de -all. La valeur de retour est 0, sauf si nom n'est pas une commande interne.
eval [arguments ...]
Les arguments sont lus et regroupés en une seule commande simple. Cette commande est alors lue et exécutée par le shell, et son code de retour est renvoyée comme valeur de la commande eval. S'il n'y a pas d'arguments, ou uniquement des arguments nuls, eval renvoie vrai.
exec [[-] commande [arguments]]
Si une commande est indiquée, elle remplace le shell. Aucun nouveau processus n'est créé. Les arguments deviennent ceux de la commande. Si le premier argument est -, l'interpréteur place un tiret en guise de zéro-ième argument fourni a la commande. C'est ce que fait login. Si le fichier ne peut pas être exécuté, quelque soit la raison, un shell non-interactif se termine, sauf si la variable no_exit_on_failed_exec existe, auquel cas une erreur est renvoyée. Un shell interactif rapporte l'erreur si le fichier ne peut pas être exécuté. Si aucune commande n'est indiquée, les éventuelles redirections sont mises en place dans le shell en cours, et le code de retour est 0.
exit [n]
Termine le shell avec le code de retour n. Si n est omis, le code de retour sera celui de la dernière commande exécutée. Un éventuel gestionnaire installé sur EXIT (voir la commande interne trap plus bas) sera exécuté avant la fin du shell.
export [-nf] [nom[=mot]] ...
export -p
Les noms indiqués sont marqués pour être exportés automatiquement dans l'environnement des commandes exécutées par la suite. Si l'option -f est fournie, les noms sont ceux de fonctions. Si aucun nom n'est mentionné, ou si l'option -p est fournie, une liste est affichée indiquant l'ensemble des noms exportables par ce shell. L'option -n supprime l'attribut d'exportation des variables mentionnées. Un argument -- arrête la recherche d'options dans la suite des arguments. export renvoie un code de retour nul, sauf si une option illégale est rencontrée, ou si l'un des noms n'est pas un nom de variable légal, ou si l'option -f est fournie avec un nom qui ne soit pas une fonction.
fc [-e éditeur] [-nlr] [première] [dernière]
fc -s [motif=nouveau] [commande]
(Fix Command). Avec la première forme indiquée ci-dessus, un intervalle de commandes, entre la première et la dernière, est sélectionné dans la liste d'historique. La première et la dernière peuvent être indiquées sous forme de chaînes (la dernière commande commençant par la chaîne indiquée), ou sous forme numérique (un index dans la liste d'historique, ou un nombre négatif indiquant un décalage par rapport à la position actuelle dans cette liste). Si la dernière n'est pas indiquée, on considère qu'il s'agit de la commande en cours si l'on veut afficher la liste (ainsi fc -l -10 affiche les 10 derniere commandes), et qu'il s'agit de la même que la première sinon. Si la première n'est pas indiquée, on considere qu'il s'agit de la commande précédente pour une édition, et de la commande -16 pour l'affichage de liste.

L'option -n supprime l'affichage des numéros dans la liste. L'option -r inverse l'ordre des commandes Avec l'option -l les commandes sont affichées sur la sortie standard. Sinon, l'éditeur est invoqué avec un fichier contenant les commandes sélectionnées. Si aucun éditeur n'est précisé, on utilise la valeur de la variable FCEDIT, ou la valeur de EDITOR si FCEDIT n'existe pas. Si aucune variable n'existe, vi est invoqué. Lorsque l'édition se termine, les commandes sont affichées puis exécutées.

Dans la seconde forme, la commande est ré-exécutée après avoir remplacé chaque instance du motif par nouveau. Un alias utile pour ceci est ``r=fc -s'', ainsi en tapant ``r cc'' on relance la dernière commande commençant par ``cc'', et en tapant ``r'' on ré-exécute la commande précédente.

Lorsque la première forme est utilisée, la valeur renvoyée est 0, sauf si une option illégale est trouvée, ou si première ou dernière indiquent des lignes d'historique inexistantes. Avec l'option -e, la valeur de retour est celle de la dernière commande exécutée, ou un échec si une erreur s'est produite avec le fichier temporaire des commandes. Avec la seconde forme, le code de retour est celui de la commande ré-exécutée, à moins que commande ne soit pas une ligne valide de l'historique, auquel cas fc renvoie un échec.

fg [job]
Placer le job en avant-plan, et en faire le job en cours. Si aucun job n'est mentionné, le shell considèrera qu'il faut ramener le job en cours en avant-plan. La valeur de retour est celle de la commande placée en avant-plan, ou un échec si le contrôle des jobs n'est pas actif, ou encore si le job n'existe pas ou a été lancé sans contrôle des jobs.
getopts chaîne_d_options nom [arguments]
getopts est utilise par les procédures shell pour analyser les paramètres positionnels. La chaîne_d_options contient l'ensemble des lettres d'options à reconnaître. Si une lettre est suivie par un double-point (:), l'option est censée comprendre un argument, qui peut en être séparé par un espace. A chaque invocation, getopts place l'option suivante dans la variable shell dont le nom est fourni, en la créant si elle n'existe pas. Il place également l'index de l'argument suivant à analyser dans la variable OPTIND. OPTIND est initialisé à 1 à chaque lancement d'un shell ou d'un script. Quand une option nécessite un argument, getopts place celui-ci dans la variable OPTARG. Le shell ne réinitialise pas OPTIND automatiquement, il faut le faire manuellement si des appels multiples à getopts au sein du même shell utilisent des ensembles différents de paramètres.

getopts peut renvoyer des erreurs de deux manières. Si le premier caractère de la chaîne_d_options est un double point, les erreurs sont renvoyées de manière silencieuse. Lors d'un fonctionnement normal, des messages de diagnostique sont affichés si une option est illégale, ou s'il manque un argument d'option. Si la variable OPTERR vaut 0, aucun message d'erreur ne sera affiché, même si le premier caractère de la chaîne_d_options n'est pas un double-point.

Si une option illégale est rencontrée, getopts met un point d'interrogation ? dans la variable nom, affiche un message d'erreur (s'il n'est pas en mode silencieux), et détruit la variable OPTARG. En mode silencieux, getopts le caractère d'option est placé dans OPTARG et aucun message de diagnostique n'est affiché.

Lorsqu'un argument d'option est manquant, et si getopts n'est pas silencieux, un point d'interrogation (?) est placé dans la variable nom, OPTARG est détruit, et un message de diagnostique est affiché. Si getopts est silencieux, un double-point (:) est placé dans la variable nom et OPTARG est rempli avec le caractère d'option trouvé.

getopts est normalement utilisé pour analyser les paramètres positionnels, mais il analysera d'éventuels arguments supplémentaires. getopts renvoie la valeur Vrai si une option, prévue ou imprévue, est trouvée. Il renvoie Faux si la fin des options est atteinte, ou si une erreur se produit.

hash [-r] [nom]
Pour chaque nom fourni, le chemin d'accès complet de la commande est déterminé, et mémorisé. L'option -r force le shell à oublier tous les emplacements mémorisés. Sans arguments, hash affiche des informations sur les commandes mémorisées. Un argument -- arrête la recherche d'options dans la suite des arguments. La valeur de retour est Vrai, sauf si nom n'est pas trouvé, ou si une option est illégale.
help [motif]
Affiche des informations d'aide au sujet des commandes internes. Si un motif est indiqué, help fournit de l'aide sur toutes les commandes correspondant à ce motif, sinon, une liste des commandes internes est affichée. Le code de retour est 0, sauf si aucune commande ne peut correspondre au motif.
history [n]
history -rwan [fichier]
Sans options, affiche la liste des commandes de l'historique, avec des numéros de ligne. Les lignes marquées avec un astérisque * ont été modifiées. Un argument n permet de ne lister que les n dernières lignes. Si un argument est fourni, il est utilisé comme nom de fichier historique, sinon on utilise la valeur de la variable HISTFILE. Les options ont les significations suivantes :
-a
Ajouter les ``nouvelles'' lignes d'historiques (celles créées depuis le début de la session actuelle de bash) dans le fichier.
-n
Lire dans le fichier, et ajouter à la liste d'historique, les lignes non encore lues. Il s'agit des lignes qui ont été ajoutées dans le fichier depuis le début de la session actuelle de bash.
-r
Lire le contenu du fichier, et l'utiliser comme historique courant.
-w
Ecrire dans le fichier l'historique actuel, en écrasant le contenu precedent.

La valeur de retour est 0, sauf si une option illégale est fournie, ou si une erreur se produit durant la lecture ou l'écriture du fichier.

jobs [-lnp] [ job ... ]
jobs -x commande [ arguments ... ]
La première forme affiche la liste de jobs actifs. L'option -l affiche les PIDs, en plus des informations normales. L'option -p n'affiche que le PID du leader du groupe de processus du job. L'option -n n'affiche que les jobs dont le statut a varié depuis le dernier affichage. Si une spécification de job est fournie, l'affichage ne comporte que les informations à propos de ce job. Le code de retour est 0, à moins qu'une option illégale soit transmise, ou que le job n'existe pas.

Avec l'option -x, jobs va remplacer toutes les spécifications de jobs rencontrées dans la commande ou dans ses arguments avec les Process Group ID correspondant, puis il exécutera la commande en lui transmettant les arguments, et en renvoyant son code de retour.

kill [-s sigspec | -sigspec] [pid | job] ...
kill -l [signum]
Envoyer le signal indiqué par sigspec aux processus spécifiés par pid ou par jobspec. On peut fournir sigspec sous forme numérique, ou sous forme de nom de signal, comme SIGKILL. Si sigspec est un nom de signal, il n'y a pas de différenciation majuscules/minuscules, et le préfixe SIG est facultatif. S'il n'y a pas d'indication de sigspec, le signal envoyé est SIGTERM. Un argument -l fournit la liste des noms de signaux. S'il y a des arguments avec l'option -l, les noms des signaux indiqués sont affichés, et le code de retour est nul. Un argument -- arrête la recherche d'options dans la suite des arguments. kill renvoie Vrai si au moins un signal a été envoyé, ou Faux si une erreur s'est produite, ou si une option illégale a été trouvée.
let argument [argument ...]
Chaque argument est une expression arithmétique à evaluer (voir plus haut le paragraphe EVALUATIONARITHMÉTIQUE). Si l'évaluation du dernier argument donne 0, let renvoie 1, sinon elle renvoie 0.
local [nom[=valeur] ...]
Pour chaque argument, on crée une variable locale ayant le nom indiqué, et à laquelle on affecte la valeur fournie. Quand local est utilisée dans une fonction, le nom de la variable n'est visible que dans la fonction, et ses descendantes. Sans opérandes, local affiche la liste des variables locales sur la sortie standard. Il ne faut pas utiliser local en dehors des fonctions. La valeur de retour est 0, sauf si local est invoqué en dehors d'une fonction, ou si un nom illégal est fourni.
logout
Quitter un shell de login.
popd [+/-n]
Enlève des éléments de la pile des répertoires. Sans arguments, seul le répertoire du sommet de la pile est éliminé, et un cd est effectué en direction du nouveau répertoire au sommet.
+n
supprime le n-ième élément de la liste affichée par dirs, en comptant depuis la gauche à partir de 0. Par exemple : ``popd +0'' enlève le premier répertoire, ``popd +1'' le second.
-n
supprime le n-ième élément de la liste affichée par dirs, en comptant depuis la droite à partir de 0. Par exemple: ``popd -0'' supprimer le dernier répertoire, et ``popd -1'' l'avant-dernier.

Si la commande popd réussit, un dirs est effectué, et le code de retour est nul. popd renvoie Faux si une option illégale est trouvée, si la pile de répertoires est vide, si on a indiqué un répertoire absent de la pile, ou si le changement de répertoire a échoué.

pushd [rep]
pushd +/-n
Ajoute un répertoire au sommet de la pile des répertoires, ou effectue une rotation dans la pile, en ramenant le répertoire en cours au sommet. Sans argument, cette commande échange les deux répertoires au sommet, et renvoie 0, sauf si la pile est vide.
+n
Effectue une rotation dans la pile, de manière à amener au sommet le n-ième répertoire de la liste affichée par dirs (en comptant à partir de la gauche).
-n
Effectue une rotation dans la pile, de manière à amener au sommet le n-ième répertoire de la liste affichée par dirs (en comptant à partir de la droite).
rep
Ajoute le répertoire rep au sommet de la pile, et en fait le nouveau répertoire de travail.

Si la commande pushd réussit, elle effectue un dirs. Si on utilise la première forme, pushd renvoie 0 sauf si le déplacement vers rep échoue. Avec la seconde forme, pushd renvoie 0 sauf si la pile est vide, si on a réclamé un élément inexistant de la pile, ou si le changement de répertoire a échoué.

pwd
Affiche le chemin d'accès complet au répertoire de travail actuel. Si l'option -P de la commande interne set est active, le chemin affiche ne contiendra pas de liens symboliques. (Voir également une description de nolinks dans le paragraphe Variables du Shell plus haut). Le code de retour est nul, sauf si une erreur s'est produite durant la lecture du chemin d'accès au répertoire courant.
read [-r] [nom ...]
Une ligne est lue depuis l'entrée standard, puis le premier mot de cette ligne est affecté au premier nom, le second mot au second nom, et ainsi de suite. Les mots restants sont affectés au dernier nom. Seul les caractères contenus dans la variables IFS sont utilisés comme délimiteurs de mots. Si aucun nom n'est fourni, la ligne lue est affectée entièrement à la variable REPLY. Le code de retour est nul, sauf si une fin-de-fichier est rencontrée. Avec l'option -r, une paire de caractères backslash/retour-chariot n'est pas ignorée, et le backslash est considéré comme faisant partie de la ligne.
readonly [-f] [nom ...]
readonly -p
Les noms indiqués reçoivent un attribut lecture-seule, et ces noms ne pourront pas être modifiés par des affectations ultérieures. Avec l'option -f, on considère les fonctions correspondant à ces noms. Si aucun argument n'est fourni, ou si l'option -p est utilisée, on affiche la liste des noms en lecture-seule. Un argument -- arrête la recherche d'options dans la suite des arguments. Le code de retour est nul, sauf si une option illégale a été trouvée, si l'un des noms n'est pas un nom légal de variables shell, ou si l'option -f est fournie avec un nom qui ne soit pas une fonction.
return [n]
La fonction shell en cours d'exécution se termine en renvoyant la valeur n. Si n est omis, la valeur renvoyée est celle de la dernière commande exécutée dans le corps de la fonction. Si cette commande est exécutée en dehors d'une fonction, mais durant l'exécution d'un script avec la commande . (source) ce script s'arrête, et la valeur renvoyée est n ou celle de la derniere commande exécutée. Si elle est utilisée en dehors d'une fonction ou d'un script exécuté par ., le code retour est Faux.
set [--abefhkmnptuvxldCHP] [-o option] [argument ...]
-a
Marquage automatique des variables modifiées ou créées pour qu'elles soient exportées dans l'environnement des commandes exécutées ultérieurement.
-b
Affichage immédiat des statuts des jobs en arrière-plan qui se terminent, plutot que d'attendre l'affichage du prochain symbole d'accueil principal (Voir également notify dans le paragraphe Variables du Shell plus haut).
-e
Sortie immédiate lorsqu'une commande simple (voir GRAMMAIRE DU SHELL plus haut) se termine avec un code non nul. Le shell ne se termine pas si la commande échoue dans une boucle until ou while, dans un test if, dans une liste && ou ||, ou si le code de retour est inversé par !.
-f
Désactivation du développement des noms de fichiers.
-h
Localisation et mémorisation des commandes dans les fonctions au moment de la définition des fonctions. Ces commandes sont normalement recherchées au moment de l'exécution de la fonction.
-k
Tous les arguments sont placés dans l'environnement des commandes, pas uniquement ceux saisis avant le nom de la commande.
-m
Mode supervision. Activation du contrôle des jobs. Ce mode est actif par defaut pour les shells interactifs qui le supportent (voir le paragraphe CONTRÔLE DES JOBS plus haut). Les processus en arrière-plan sont exécutés dans des groupes de processus séparés, et une ligne indiquant leur statuts est affichée lorsqu'ils se terminent.
-n
Lecture de commandes sans exécution. Ceci peut être utilisé pour rechercher les erreurs de syntaxe dans un script. Ce drapeau est ignoré par les shells interactifs.
-o nom__d_option
Le nom_d_option est l'un des suivants :
allexport
Identique à -a.
braceexpand
Le shell effectue le développement des accolades (voir le paragraphe Développement des Accolades plus haut). C'est le comportement par défaut.
emacs
Utiliser une interface "à la emacs" pour les lignes de commande. C'est le comportement par défaut pour un shell interactif, sauf s'il est lance avec l'option -nolineediting.
errexit
Identique à -e.
histexpand
Identique à -H.
ignoreeof
Identique à l'exécution d'une commande shell `IGNOREEOF=10'. (voir le paragraphe Variables du Shell plus haut)
interactive-comments
Autoriser les commentaires dans les shells interactifs, en ignorant tout ce qui se trouve à la suite d'un mot commençant par #. (voir le paragraphe COMMENTAIRES plus haut).
monitor
Identique à -m.
noclobber
Identique à -C.
noexec
Identique à -n.
noglob
Identique à -f.
nohash
Identique à -d.
notify
Identique à -b.
nounset
Identique à -u.
physical
Identique à -P.
posix
Modifier le comportement de bash, lorsque les opérations par défaut s'éloigne de Posix 1003.2 afin d'être conforme au standard.
privileged
Identique à -p.
verbose
Identique à -v.
vi
Utiliser une interface d'édition des lignes de commande "à la vi".
xtrace
Identique à -x.

Si aucun nom_d_option n'est fourni, les valeurs actuelles de l'ensemble des options sont affichées.

-p
Basculer en mode privilégié. Dans ce mode, le fichier $ENV n'est pas traité, et les fonctions shells ne sont pas héritées depuis l'environnement. Ce comportement est automatiquement déclenché quand l'UID (ou GID) effectif n'est pas égal à l'UID (respectivement GID) réel. En désactivant cette option, les UID et GID effectifs sont automatiquement replacés aux valeurs des UID et GID réels.
-t
Sortie automatique après lecture et exécution d'une commande.
-u
Considérer les variables inexistantes comme des erreurs durant l'expansion des paramètres. Si on tente de développer une variable inexistante, le shell affiche un message d'erreur, et, s'il n'est pas interactif, se termine avec un code de retour non-nul.
-v
Affichage des lignes de commandes au fur et à mesure de leur lecture.
-x
Après l'expansion de chaque commande simple, bash affiche la valeur de PS4, suivie par la commande et ses arguments développés.
-l
Sauver et restituer ensuite la valeur du nom lors d'une commande for nom [in mot] (voir le paragraphe GRAMMAIRE DU SHELL plus haut).
-d
Désactivation du stockage dans une table de hachage des commandes exécutées. Normalement, les commandes sont mémorisees dans cette table, et bash n'a ainsi plus besoin de les chercher à nouveau.
-C
Identique à l'exécution de la commande shell `noclobber='. (voir le paragraphe Variables du Shell plus haut).
-H
Autoriser le style ! de substitution historique. C'est le comportement par défaut lorsque le shell est interactif.
-P
Ne pas suivre les liens symboliques lors d'une commande comme cd qui modifie le répertoire de travail. Utiliser à la place le répertoire physique.
--
Si aucun argument ne suit ce drapeau, alors les paramètres positionnels sont détruits. Sinon, les paramètres positionnels sont remplis avec les arguments, même si certains d'entre eux commencent par un -.
-
Fin des options. Tous les arguments restants sont affectés aux paramètres positionnels. Les attributs -x et -v sont désactivés. S'il n'y a pas d'arguments, les paramètres positionnels ne sont pas modifiés.

Par défaut les attributs sont désactivés, sauf indication contraire. En utilisant + à la place de - on désactive explicitement un drapeau. Les attributs peuvent également être fournis en argument lors de l'invocation du shell. Le jeu de drapeaux actuellement actifs est disponible dans $-. Apres la lecture des options, les n arguments restants sont affectés, dans l'ordre aux paramètres positionnels $1, $2, ... $n. Si aucune option et aucun argument n'est fournis, on affiche la liste des variables du shell. Le code de retour est toujours Vrai, sauf si une option illégale a été trouvée.

shift [n]
Les paramètres positionnels à partir de n+1 ... sont renommés en $1 .... Les paramètres représentés par les nombres $# jusqu'à $#-n+1 sont supprimés. Si n vaut 0, aucun paramètres n'est modifié. Si n est omis, on suppose qu'il vaut 1. n doit être un nombre non-négatif inférieur ou égal à $#. Si n est supérieur à $#, les paramètres positionnels ne sont pas modifiés. Le code de retour est supérieur à 0 si n est supérieur à $# ou inférieur à 0. Sinon le code de retour est nul.
suspend [-f]
Suspend l'exécution du shell jusqu'à la réception d'un signal SIGCONT. L'option -f élimine le message d'erreur s'il s'agit d'un shell de login, et force sa suspension. Le code de retour est nul sauf si l'on utilise un shell de login et si l'option -f n'est pas fournie, ou encore si le mécanisme de contrôle des jobs n'est pas disponible.
test expr
[ expr ]
Renvoie la valeur 0 (vrai) ou 1 (faux) en fonction de l'évaluation de l'expression conditionnelle expr. Les expressions peuvent être unaires ou binaires. Les opérations unaires servent généralement à examiner l'état d'un fichier. Il existe des opérateurs de comparaison tant sur les chaînes que sur les nombres. Les opérateurs et les opérandes doivent être des arguments séparés. Si un fichier est de la forme /dev/fd/n, alors on teste le descripteur de fichier n.
-b fichier
Vrai si le fichier existe et est un fichier spécial bloc.
-c fichier
Vrai si le fichier existe et est un fichier spécial caractère.
-d fichier
Vrai si le fichier existe et est un répertoire
-e fichier
Vrai si le fichier existe.
-f fichier
Vrai si le fichier existe et est un fichier régulier.
-g fichier
Vrai si le fichier existe et a son bit Set-GID positionné.
-k fichier
Vrai si le fichier existe et a son bit ``sticky'' positionné.
-L fichier
Vrai si le fichier existe et est un lien symbolique.
-p fichier
Vrai si le fichier existe et est un tube nommé (FIFO).
-r fichier
Vrai si le fichier existe et est accessible en lecture.
-s fichier
Vrai si le fichier existe et a une taille non nulle.
-S fichier
Vrai si le fichier existe et est une socket
-t fd
Vrai si fd est ouvert sur un terminal.
-u fichier
Vrai si le fichier existe et a son bit Set-UID positionné.
-w fichier
Vrai si le fichier existe et est accessible en écriture.
-x fichier
Vrai si le fichier existe et est exécutable.
-O fichier
Vrai si le fichier existe et appartient à l'ID effectif de l'utilisateur.
-G fichier
Vrai si le fichier existe et appartient à l'ID effectif du groupe de l'utilisateur.
fichier_1 -nt fichier_2
Vrai si le fichier_1 est plus récent que (nt=newer than) le fichier_2, d'après les dates de modification.
fichier_1 -ot fichier_2
Vrai si le fichier_1 est plus vieux que (ot = older than) le fichier_2.
fichier_1 -ef fichier_2
Vrai si lefichier_1 et le fichier_2 sont sur le même péripherique et ont les mêmes numéros d'i-noeuds.
-z chaîne
Vrai si la longueur de la chaîne est nulle.
-n chaîne
chaîne
Vrai si la longueur de la chaîne est non-nulle.
chaîne_1 = chaîne_2
Vrai si les deux chaînes sont égales.
chaîne_1 != chaîne_2
Vrai si les deux chaînes sont différentes.
! expression
Vrai si l'expression est fausse.
expression_1 -a expression_2
Vrai si l'expression_1 ET l'expression_2 sont toutes deux vraies.
expr1 -o expr2
Vrai si l'expression_1 OU l'expression_2 est vraie.
arg1 OP arg2
OP est l'un des opérateurs suivants -eq, -ne, -lt, -le, -gt, ou -ge. Ces opérateurs arithmétiques binaires renvoient la valeur vraie si arg_1 est respectivement égal, différent, inférieur, inférieur ou égal, supérieur, supérieur ou égal à arg2. Arg1 et arg2 peuvent être des entiers positifs, des entiers négatifs, ou l'expression spéciale -l chaîne, qui évalue la longueur de la chaîne.
times
Affiche les durées cumulées utilisateur et système pour le shell et les processus lancés par ce shell. Le code de retour est nul.
trap [-l] [cmd] [sigspec]
La commande cmd sera lue et exécutée lorsque le shell recevra l'un des signaux sigspec. Si cmd est absent ou si elle vaut -, tous les signaux indiqués reprennent leurs comportements originaux (qu'ils avaient au démarrage du shell). Si cmd est une chaîne nulle, les signaux seront ignorés par le shell et par les commandes qu'il invoque. sigspec peut être spécifié en indiquant des noms de signaux définis dans <signal.h>, ou les numéros des signaux. Si sigspec vaut EXIT (0) la commande cmd sera exécutée au moment de quitter le shell. Sans arguments, trap affiche la liste des commandes associées à chaque numéro de signal. L'option -l affiche la liste des noms de signaux, et leurs numéros correspondants. Un argument -- désactive la recherche d'option dans le reste des arguments. Les signaux ignorés lors de l'invocation du shell ne peuvent pas être capturés ni reprendre leurs comportements par défaut. Lors de la création d'un processus fils, les signaux capturés reprennent leur comportement par défaut. Le code de retour est faux si un nom ou un numéro de signal est invalide, sinon trap renvoie une valeur vraie.
type [-all] [-type | -path] nom [nom ...]
sans option, indique comment chaque nom doit être interprété si on l'utilise en nom de commande. Si l'attribut -type est utilisé, type affiche une des phrases suivantes alias, keyword, function, builtin, ou file selon que le nom soit un alias, un mot-clé réservé au shell, une fonction, une commande interne, ou un fichier sur le disque. Si le nom n'est pas trouvé, rien n'est affiché et le code de retour est faux. Si l'argument -path est utilisé, type renvoie le nom du fichier qui sera exécuté si l'on tape le nom en guise de commande, ou rien si le -type n'est pas file. Si une commande est disponible dans la table de hachage, -path affiche la valeur de cette table, qui n'est pas nécéssairement le fichier apparaissant en premier dans le PATH. Si l'option -all est invoquée, type affiche tous les emplacements contenant un exécutable du nom indiqué. Ceci inclut les alias et les fonctions, sauf si l'option -path est également présente. La table de hachage des commandes n'est pas consultée avec l'option -all. type accepte les raccourcis -a, -t, et -p à la place de -all, -type, et -path, respectivement. Un argument -- désactive la recherche d'option dans la suite des arguments. type renvoie vrai si l'un des arguments est trouvé, et faux si aucun n'a été trouvé.
ulimit [-SHacdfmstpnuv [limite]]
Ulimit fournit, sur les systèmes qui le permettent, un mécanisme de controle des ressources disponibles pour le shell et pour les processus qu'il lance. La valeur de la limite peut être un nombre (utilisant les unités particulières de la ressources), ou la valeur unlimited. Les options H et S précisent si la limite doit être dure (Hard), ou souple (Soft). Une limite dure ne peut pas être augmentée une fois qu'elle a été positionnée. Une limite souple peut être augmentée jusqu'à la hauteur de la limite dure correspondante. Par défaut, les limites fixées sont souples. Si la limite est omise, on affiche la valeur de la limite souple pour la ressource indiquée, sauf si l'option H est fournie. Quand plusieurs ressources sont indiquées, leurs noms, et leurs unites respectives sont affichés avant les valeurs. Les options sont interprétées ainsi :
-a
affichage de toutes les limites actuelles
-c
la taille maximale pour la création d'un fichier core
-d
la taille maximale du segment de données d'un processus
-f
la taille maximale d'un fichier créé par le shell
-m
la taille maximale de la partie résidente d'un processus
-s
la taille maximale de la pile
-t
la durée maximale, en seconde, de temps CPU accordé à un processus.
-p
la taille d'un tube (pipe) en blocs de 512 octets (ceci n'est pas modifiable)
-n
le nombre maximal de descripteurs de fichiers ouverts simultanément (la plupart de systèmes ne permettent pas de modifier ceci)
-u
le nombre maximal de processus autorisés pour un seul utilisateur
-v
la quantité de mémoire virtuelle disponible pour le shell

Un argument -- désactive la recherche d'option dans le reste des arguments. Si une limite est fournie, la ressource correspondante recevra cette limite (l'option -a ne permet que l'affichage). Si aucune option n'est indiquée, la ressource -f est prise par défaut. Les valeurs s'expriment en kilo-octets, sauf pour -t, ou elles s'expriment en secondes, -p, qui utilise des unités de blocs de 512 octets, -n et -u, qui n'ont pas d'unités. La valeur renvoyée est 0 sauf si une option illégale est détectée, si un argument non-numérique autre que unlimited est fourni comme limite, ou si une erreur se produit durant la modification de la limite.

umask [-S] [mode]
Le masque de création de fichier de l'utilisateur est fixé au mode indiqué. Si mode commence par un chiffre, il est interprété comme un nombre octal, sinon il est considéré comme un masque symbolique, semblable à ceux acceptes par chmod(1). Si mode est omis, ou si l'option -S est fournie, la valeur courante du masque est affichée. L'option -S affiche le masque sous forme symbolique, l'affichage par défaut étant en octal. Un argument -- désactive la recherche d'option dans la suite des arguments. Le code de retour est nul si le mode a pu être changé correctement, ou si on a omis l'argument mode, et faux sinon.
unalias [-a] [nom ...]
Suprime le nom de la liste des alias définis. Si l'option -a est demandée, toutes les définitions d'alias sont supprimées. La valeur renvoyée est vraie sauf si un nom mentionné n'est pas un alias defini.
unset [-fv] [nom ...]
Supprimer la variable (ou la fonction si l'option -f est mentionnée), associée à chaque nom indiqué. Un argument -- désactive la recherche d'option dans la suite des arguments. Remarquez que PATH, IFS, PPID, PS1, PS2, UID, et EUID ne peuvent pas être supprimés, et que si une des variables RANDOM, SECONDS, LINENO, ou HISTCMD est supprimée, elle perd ses propriétés spécifiques, même s'il elle est recréée ultérieurement. Le code de retour est vrai, à moins qu'un des noms n'existe pas, ou ne soit pas suppressible.
wait [n]
Attend que le processus indique se termine, et renvoie son code de retour. n peut indiquer un PID, ou un job. S'il s'agit d'un indicateur de job, on attendra la fin de tous les processus du tube de ce job. Si n est omis, on attend la fin de tous les processus fils actuellement actifs, et le code de retour sera zéro. Si n se rapporte à un processus ou un job inexistant, le code de retour sera 127. Dans tous les autres cas, le code de retour sera celui du dernier processus ou job attendu.
 

VOIR AUSSI

Bash Features, Brian Fox et Chet Ramey
The Gnu Readline Library, Brian Fox et Chet Ramey
The Gnu History Library, Brian Fox et Chet Ramey
A System V Compatible Implementation of 4.2BSD Job Control, David Lennert
Portable Operating System Interface (POSIX) Part 2: Shell and Utilities, IEEE
[NDT]Le shell Bash par Newham et Rosenblatt est traduit en francais chez O'Reilly
sh(1), ksh(1), csh(1)
emacs(1), vi(1)
readline(3)
 

FICHIERS

/bin/bash
L'exécutable bash.
/etc/profile
Le fichier d'initialisation globale, exécutée par les shells de login.
~/.bash_profile
Le fichier d'initialisation personnalisée, exécutée par les shells de login.
~/.bashrc
Le fichier de démarrage personnel, pour les shells interactifs.
~/.bash_logout
Le fichier de sortie des shells de login lors de la déconnection.
~/.inputrc
Le fichier d'initialisation personnalisée de readline.
 

AUTEURS

Brian Fox, Free Software Foundation (auteur principal)
bfox@ai.MIT.Edu

Chet Ramey, Case Western Reserve University
chet@ins.CWRU.Edu

 

RAPPORT DE BOGUE

Si vous trouvez un bug dans bash, vous êtes encouragés à nous en faire part. Tout d'abord vous devez vous assurer qu'il s'agit réellement d'un dysfonctionnement, et qu'il apparaît bien dans la dernière version de bash disponible.

Une fois que vous êtes sûrs qu'il s'agit bien d'un bug, utilisez la commande bashbug pour nous envoyer un rapport. Si vous avez trouvé une correction, n'hésitez pas à l'envoyer en même temps. Les simples suggestions, ou les remarques d'ordre `philosophique' peuvent être transmises à bug-bash@prep.ai.MIT.Edu ou postées dans le groupe Usenet gnu.bash.bug.

TOUS les rapports de bugs doivent contenir :

Le numéro de version de bash
Le matériel et le système d'exploitation utilisés
La version du compilateur utilisé pour compiler bash.
Une description du comportement du bug. [NDT : En anglais évidemment]
Un petit script, ou une manipulation qui met en évidence le bug.

bashbug insère automatiquement les trois premiers éléments de cette liste dans le formulaire qu'il fournit pour remplir le rapport de bug.

Les commentaires et rapports d'erreurs concernant la version originale de cette page de manuel doivent être transmis à chet@ins.CWRU.Edu. Ceux concernant la version francaise peuvent être envoyés à ccb@club-internet.fr.  

BOGUES

Cet interpréteur est volumineux et lent.

Il y a quelques différences subtiles de comportement entre bash et les versions traditionnelles de sh, principalement à cause des spécifications POSIX.

L'utilisation des alias peut avoir des conséquences inattendues.

Les commmandes internes de l'interpréteur et les fonctions ne peuvent ni être arrétées (par contrôle-C) ni relancées (à l'aide de fg et bg)

Les séquences de commandes de la forme `a ; b ; c' ne sont pas gérées proprement lors d'une interruption de processus. En cas de suspension d'une telle séquence, l'interpréteur exécute immédiatement la commande suivante de la séquence. Il suffit de placer cette séquence entre parenthèses pour la forcer à créer un sous-shell, qui, lui, sera interruptible en bloc.

Les commandes à l'intérieur de $(...) (cf SUBSTITUTION DE COMMANDES) ne sont pas analysées avant la réalisation de la complétion. Celà peut retarder l'affichage de messages d'erreurs pendant un certain temps après la frappe de la commande.

Les variables de type tableau ne peuvent pas (encore) être exportées.

 

TRADUCTION

Christophe Blaess, 1997.
Mise à jour de bash 1.14 à bash 2.03 : Thierry Vignaud <tvignaud@mandrakesoft.com>, 1999


 

Index

NOM
SYNOPSIS
COPYRIGHT
DESCRIPTION
OPTIONS
ARGUMENTS
INVOCATION
DÉFINITIONS
MOTS RÉSERVÉS
GRAMMAIRE DU SHELL
Commandes simples
Tubes (Pipelines)
Listes
Commandes composées
COMMENTAIRES
PROTECTION
PARAMÈTRES
Paramètres Positionnels
Paramètres Spéciaux
Variables du Shell
EXPANSION
Expansion des accolades
Développement du Tilde
Remplacement des paramètres
Substitution de commandes
Évaluation Arithmétique
Substitution de Processus
Séparation des mots
Développement des noms de fichiers
Suppression des protections
REDIRECTION
Redirection d'entrée
Redirection de sortie
Redirection pour Ajout en Sortie
Redirection de la sortie standard et de la sortie d'erreur.
Document en ligne
Dédoublement de descripteur de fichier
Ouverture en Lecture/Écriture d'un descripteur de fichier
FONCTIONS
ALIAS
CONTRÔLE DES JOBS
SIGNAUX
ÉXÉCUTION DES COMMANDES
ENVIRONNEMENT
CODE DE RETOUR
SYMBOLE D'ACCUEIL (PROMPT)
BIBLIOTHÈQUE READLINE
Commandes de déplacement
Commandes de manipulation de l'historique
Commande d'édition de texte
Effacement et récuperation
Arguments numériques
Complétion
Macros Claviers
Divers
HISTORIQUE
EXPANSION DE L'HISTORIQUE
Indicateur d'évènement
Indicateurs de mots
Modificateurs
CALCUL ARITHMÉTIQUE
COMMANDES INTERNES DU SHELL
VOIR AUSSI
FICHIERS
AUTEURS
RAPPORT DE BOGUE
BOGUES
TRADUCTION

This document was created by man2html using the manual pages.
Time: 17:36:31 GMT, October 23, 2013

SVENSKA - SVENSKA - SVENSKA - ja - pl