umask

BASH(1)                      General Commands Manual                     BASH(1)



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

SYNOPSIS
       bash [options] [chaîne_de_commande | fichier]

COPYRIGHT
       Bash is Copyright (C) 1989-2020 by the Free Software Foundation, Inc.

DESCRIPTION
       Bash est un interpréteur de commandes (shell) compatible sh qui exécute
       les commandes lues depuis l'entrée standard ou depuis un fichier. Bash
       inclut aussi des fonctionnalités utiles des interpréteurs de commandes
       Korn et C (ksh et csh).

       Bash vise à être une implémentation conforme à la partie relative aux
       interpréteurs de commandes et utilitaires des spécifications IEEE POSIX
       (norme IEEE 1003.1). Bash peut être configuré pour être conforme à la
       norme POSIX par défaut.

OPTIONS
       Toutes les options d'interpréteur monocaractères documentées dans la
       description de la commande interne set, y compris -o, peuvent être
       utilisées comme options si l'interpréteur est invoqué. De plus, bash
       accepte les options suivantes lors de son appel :

       -c        Si l'option -c est présente, les commandes sont lues depuis le
                 premier argument chaîne_de_commande qui n’est pas une option.
                 Si des arguments suivent la chaîne_de_commande, le premier
                 argument est assigné à $0 et tous les autres sont affectés aux
                 paramètres positionnels. Le nom de l'interpréteur, utilisé pour
                 les messages d'avertissement et d'erreur, est fixé par
                 l'assignation à $0.
       -i        Si l'option -i est présente, l'interpréteur est interactif.
       -l        Faire que bash se comporte comme s'il avait été appelé comme
                 interpréteur de commandes de connexion (consultez APPEL
                 ci-dessous).
       -r        Si l'option -r est présente, l'interpréteur devient restreint
                 (consultez INTERPRÉTEUR RESTREINT ci-dessous).
       -s        Si l'option -s est présente ou s'il ne reste plus d'argument
                 après le traitement des options, alors les commandes sont lues
                 depuis l'entrée standard. Cette option permet d'affecter les
                 paramètres positionnels lors de l'appel d'un interpréteur
                 interactif ou de la lecture de l'entrée à travers un tube.
       -D        Une liste de toutes les chaînes entre guillemets doubles
                 précédées de $ est affichée sur la sortie standard. Ce sont les
                 chaînes qui sont soumises à une traduction quand le paramètre
                 linguistique régional n'est ni C ni POSIX. Cela implique
                 l'option -n ; aucune commande ne sera exécutée.
       [-+]O [option_shopt]
                 option_shopt est une des options de l'interpréteur acceptées
                 par la commande interne shopt (consultez COMMANDES INTERNES DE
                 L'INTERPRÉTEUR ci-dessous). Si option_shopt est présente, -O
                 crée cette option ; +O la détruit. Si option_shopt n'est pas
                 fournie, les noms et valeurs des options de l'interpréteur
                 acceptées par shopt sont affichés sur la sortie standard. Si
                 l'option d'appel est +O, la sortie est affichée dans un format
                 réutilisable en entrée.
       --        Deux caractères -- indiquent la fin des options et désactivent
                 le traitement des arguments. Tous les arguments après le --
                 sont traités comme des noms de fichiers et paramètres. - est
                 équivalent à --.

       Bash reconnaît également plusieurs options multicaractères. Ces options
       doivent, pour être reconnues, apparaître sur la ligne de commande avant
       les options monocaractères.

       --debugger
              Prend les dispositions pour que le paramétrage du traçage soit
              exécuté avant que l'interpréteur démarre. Enclenche le mode de
              traçage étendu (consultez ci-dessous la description de l'option
              extdebug de la commande interne shopt).
       --dump-po-strings
              Équivalent à -D, mais la sortie est dans le format des fichiers po
              (objets portables) de l'outil GNU gettext.
       --dump-strings
              Équivalent à -D.
       --help Affiche un message d'aide sur la sortie standard et termine avec
              succès.
       --init-file fichier
       --rcfile fichier
              Exécuter les commandes contenues dans fichier plutôt que celles du
              fichier personnel d'initialisation standard ~/.bashrc si
              l'interpréteur est interactif (consultez APPEL ci-dessous).

       --login
              Équivalent à -l.

       --noediting
              Ne pas utiliser la bibliothèque GNU readline pour lire les lignes
              de commande, lorsque l'interpréteur est interactif.

       --noprofile
              Ne lire ni le fichier d'initialisation commun à tout le système
              /etc/profile ni les fichiers personnels d'initialisation
              ~/.bash_profile, ~/.bash_login ou ~/.profile. Par défaut, bash lit
              ces fichiers lorsqu'il est appelé comme interpréteur de commandes
              de connexion (consultez APPEL ci-dessous).

       --norc Ne pas lire ou exécuter le fichier personnel d'initialisation
              ~/.bashrc lorsque l'interpréteur est interactif. Cette option est
              activée par défaut si l'interpréteur est appelé sous le nom sh.

       --posix
              Aligner le comportement de bash sur la norme (mode POSIX), en ce
              qui concerne les options dont l'action par défaut diffère de la
              norme POSIX. La section VOIR AUSSI ci-dessous référence un
              document précisant la façon dont le mode POSIX affecte le
              comportement de bash.

       --restricted
              L'interpréteur devient restreint (consultez INTERPRÉTEUR RESTREINT
              ci-dessous).

       --rpm-requires
              Produire la liste des fichiers qui sont requis pour l'exécution du
              script. Cela implique l'option -n et est sujet aux mêmes
              limitations que la vérification d'erreurs au moment de la
              compilation. La substitution de commandes, les expressions
              conditionnelles et la commande interne eval ne sont pas analysées
              et donc certaines dépendances peuvent être manquées.

       --verbose
              Équivalent à -v.

       --version
              Affiche le numéro de version de bash sur la sortie standard et
              termine avec succès.

ARGUMENTS
       S'il reste des arguments sur la ligne de commande après traitement des
       options et que ni l'option -c, ni l'option -s n'ont été fournies, le
       premier argument est supposé être le nom du fichier dans lequel lire les
       commandes d'interpréteur. Si bash est appelé de cette façon, le nom du
       ficher est affecté à $0 et les arguments restants aux autres paramètres
       positionnels. Bash lit et exécute les commandes depuis ce fichier, puis
       termine. L'état final de bash est l'état final de la dernière commande
       exécutée dans le script. Si aucune commande n'a été exécutée, l'état
       final est 0. Une tentative est d'abord faite de trouver le fichier dans
       le répertoire actuel et, si aucun fichier n'est trouvé, l'interpréteur
       cherche le script dans les répertoires contenus dans PATH.

APPEL
       Un interpréteur de commandes est dit de connexion (login shell) si le
       premier caractère de son argument numéro zéro est un - ou s'il est appelé
       avec l'option --login.

       Un interpréteur est interactif s'il est appelé sans argument autre que
       des options (à moins que l'option -s soit spécifiée) et sans l'option -c,
       dont l'entrée standard et la sortie d'erreur sont toutes deux connectées
       à des terminaux (comme déterminé par la fonction isatty(3)), ou s'il est
       appelé avec l'option -i.  PS1 est créée et $- contient la lettre i si
       bash est interactif, ce qui permet à un script ou à un fichier
       d’initialisation de tester cet état.

       Le paragraphe suivant décrit comment bash exécute ses fichiers
       d'initialisation. Si un de ces fichiers existe mais n'est pas accessible
       en lecture, bash signale une erreur. Les tildes sont remplacés par des
       noms de fichiers comme décrit ci-dessous dans Développement du tilde dans
       le paragraphe DÉVELOPPEMENTS.

       Lorsque bash est lancé comme interpréteur de commandes de connexion
       interactif ou comme interpréteur non interactif avec l'option --login, il
       lit et exécute tout d'abord les commandes se trouvant dans le fichier
       /etc/profile si ce fichier existe. Après lecture de ce fichier, il
       recherche ~/.bash_profile, ~/.bash_login et ~/.profile, dans cet ordre,
       puis lit et exécute les commandes se trouvant dans le premier fichier
       existant et accessible en lecture. L'option --noprofile peut être
       utilisée à l'appel de l'interpréteur pour empêcher ce comportement.

       Lorsqu'un interpréteur de commandes de connexion interactif termine, ou
       qu'un interpréteur de commandes de connexion non interactif exécute la
       commande interne exit, bash lit et exécute les commandes des fichiers
       ~/.bash_logout et /etc/bash.bash_logout, s'ils existent.

       Quand un interpréteur interactif démarre sans être un interpréteur de
       commandes de connexion, bash lit et exécute les commandes se trouvant
       dans ~/.bashrc s'il existe. Ce comportement peut être empêché à l'aide de
       l'option --norc. L'option --rcfile fichier forcera bash à lire et
       exécuter les commandes dans fichier plutôt que dans ~/.bashrc.

       Quand bash est démarré de façon non interactive, par exemple pour lancer
       un script, il consulte la variable BASH_ENV dans l'environnement,
       développe son contenu si elle existe et considère cette valeur comme le
       nom d'un fichier à lire et exécuter. Bash se comporte comme si la
       commande suivante était exécutée :
              if [ -n "$BASH_ENV" ]; then . "$BASH_ENV"; fi
       mais la valeur de la variable PATH n'est pas utilisée pour rechercher le
       fichier.

       Si bash est appelé sous le nom sh, il essaye d'imiter le comportement de
       démarrage des versions historiques de sh aussi fidèlement que possible,
       tout en restant conforme à la norme POSIX. Lorsqu'il est appelé comme
       interpréteur de commandes de connexion interactif ou non interactif avec
       l'option --login, il essaye d'abord de lire et exécuter, dans cet ordre,
       les commandes de /etc/profile puis de ~/.profile. L'option --noprofile
       peut être utilisée pour empêcher ce comportement. Quand il est appelé en
       tant qu'interpréteur interactif sous le nom sh, bash consulte la variable
       ENV, développe sa valeur si elle est définie et utilise le résultat en
       tant que nom de fichier à lire et exécuter. Comme un interpréteur appelé
       sous le nom sh n'essaye ni de lire, ni d'exécuter des commandes d'un
       autre fichier de démarrage, l'option --rcfile n'a aucun effet. Un
       interpréteur non interactif appelé sous le nom sh n'essaie de lire aucun
       autre fichier d'initialisation. Quand il est appelé sous le nom sh, bash
       entre en mode POSIX après avoir lu les fichiers d'initialisation.

       Quand bash est appelé en mode POSIX comme avec l'option --posix sur la
       ligne de commande, il suit la norme POSIX pour les fichiers de démarrage.
       Dans ce mode, les interpréteurs interactifs développent la variable ENV
       et les commandes sont lues et exécutées à partir du fichier dont le nom
       est la valeur développée. Aucun autre fichier d'initialisation n'est lu.

       Bash tente de déterminer s'il est exécuté avec son entrée standard reliée
       à une connexion réseau, comme quand il est exécuté par le démon lançant
       les interpréteurs de commandes à distance, généralement rshd, ou le démon
       d'interpréteur sécurisé sshd. Si bash conclut qu'il est exécuté de cette
       façon, il lit et exécute les commandes de ~/.bashrc si ce fichier existe
       et est accessible en lecture. Il n'a pas ce comportement lorsqu'il est
       appelé sous le nom sh. L'option --norc peut être utilisée pour empêcher
       ce comportement et l'option --rcfile peut être utilisée pour forcer la
       lecture d'un autre fichier, mais rshd et sshd n'appellent généralement
       pas l'interpréteur avec ces options et ne permettent pas de les indiquer.

       Si l'interpréteur est lancé avec un identifiant (de groupe) d'utilisateur
       effectif différent de l'identifiant (de groupe) d'utilisateur réel et si
       l'option -p n'est pas fournie, aucun fichier d'initialisation n'est lu,
       les fonctions de l'interpréteur ne sont pas importées depuis
       l'environnement, les variables SHELLOPTS, BASHOPTS, CDPATH, et
       GLOBIGNORE, si présentes dans l'environnement, sont ignorées, et
       l'identifiant de l'utilisateur effectif est configuré à celui de
       l'utilisateur réel. Si l'option -p est fournie à l'appel, le comportement
       au démarrage est le même mais l'identifiant d'utilisateur effectif n'est
       pas modifié.

DÉFINITIONS
       Les définitions suivantes sont utilisées dans toute la suite ce document.
       blanc  Une espace ou une tabulation.
       mot    Une suite de caractères considérée comme une unité élémentaire par
              l'interpréteur. On parle également de lexème (« token »).
       nom    Un mot ne contenant que des caractères alphanumériques et des
              tirets bas (« underscore »), commençant par une lettre ou un tiret
              bas. On s'y réfère également sous le terme identificateur.
       métacaractère
              Un caractère qui, non protégé, sépare les mots. Un de ceux-ci :
              |  & ; ( ) < > space tab newline
       opérateur de contrôle
              Un lexème ayant une fonction de contrôle. C'est l'un des symboles
              suivants :
              || & && ; ;; ;& ;;& ( ) | |& <newline>

MOTS RÉSERVÉS
       Les mots réservés sont des mots qui ont une signification spéciale pour
       l'interpréteur. Les mots suivants sont reconnus comme réservés lorsqu'ils
       ne sont pas protégés et sont soit le premier mot d'une commande
       (consultez GRAMMAIRE DE L'INTERPRÉTEUR ci-dessous), le troisième mot
       d'une commande case ou select (seul in est valable), ou le troisième mot
       d'une commande for (seuls in et do sont valables) :

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

GRAMMAIRE DE L'INTERPRÉTEUR
   Commandes simples
       Une commande simple est une suite d'affectations facultatives de
       variables, suivie de mots séparés par des blancs et de redirections, et
       terminée par un opérateur de contrôle. Le premier mot indique la commande
       à exécuter et est passé comme argument zéro. Les mots restants sont
       transmis comme arguments à la commande appelée.

       La valeur renvoyée par une commande simple est son état final ou 128+n si
       la commande a été terminée par le signal n.

   Pipelines
       Un pipeline est une suite d'une ou plusieurs commandes séparées par un
       des opérateurs de contrôle | ou |&. Le format d'un pipeline est :

              [time [-p]] [!] commande_1 [ [||&] commande_2 ... ]

       La sortie standard de la commande_1 est connectée par un tube à l'entrée
       standard de la commande_2. Cette connexion est effectuée avant toute
       redirection indiquée par la commande elle-même (consultez REDIRECTIONS
       ci-dessous). Si |& est utilisé, la sortie d'erreur standard de la
       commande_1, en plus de sa sortie standard, est connectée à l'entrée
       standard de la commande_2 dans le tube ; c'est un raccourci pour 2>&1 |.
       Cette redirection implicite de la sortie d'erreur standard vers la sortie
       standard est réalisée après toute redirection précisée par la commande.

       L'état renvoyé par un pipeline est l'état final de la dernière commande,
       à moins que l'option pipefail soit activée. Si pipefail est activée,
       l'état renvoyé par le pipeline est la valeur de la dernière commande (la
       plus à droite) à terminer avec un état différent de zéro ou zéro si
       toutes les commandes se terminent avec succès. Si le mot réservé !
       précède un pipeline, l'état final de ce pipeline sera la négation logique
       de l'état final tel que décrit ci-dessus. L'interpréteur attend que
       toutes les commandes du pipeline soient terminées avant de renvoyer une
       valeur.

       Si le mot réservé time précède un pipeline, les temps passés par le
       programme en modes utilisateur et système sont indiqués quand le pipeline
       se termine. L'option -p modifie le format de sortie pour celui indiqué
       par POSIX. Quand l'interpréteur est en mode POSIX, il ne reconnaît pas
       time comme un mot réservé si le lexème suivant commence par un « - ». La
       variable TIMEFORMAT peut contenir une chaîne de format indiquant comment
       les informations de chronométrage doivent être affichées ; consultez
       ci-dessous la description de TIMEFORMAT dans Variables de l'interpréteur.

       Quand l'interpréteur est en mode POSIX, time peut être suivi d'un
       changement de ligne. Dans ce cas, l'interpréteur affiche le temps
       utilisateur et système total consommé par l'interpréteur et ses enfants.
       La variable TIMEFORMAT peut être utilisée pour indiquer le format des
       informations de temps.

       Toute commande dans un pipeline est exécutée comme un processus séparé
       (c'est-à-dire dans un sous-interpréteur). Consultez ENVIRONNEMENT
       D'EXÉCUTION DES COMMANDES pour une description d'un environnement de
       sous-interpréteur. Si l'option lastpipe est activée en utilisant la
       commande interne shopt (consultez la description de shopt ci-dessous), le
       dernier élément d'un pipeline peut être exécuté par le processus de
       l'interpréteur.

   Listes
       Une liste est une suite d'un ou plusieurs pipelines séparés par l'un des
       opérateurs ;, &, && ou || et facultativement terminée par ;, & ou
       <changement de ligne>.

       Dans cette liste d'opérateurs, && et || ont une priorité identique,
       suivis par ; et &, qui ont également une priorité identique.

       Une suite d'un ou plusieurs changements de ligne peut apparaître dans une
       liste à la place d'un point-virgule pour délimiter les commandes.

       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-interpréteur. L'interpréteur
       n'attend pas que la commande se termine et l'état renvoyé est 0. Elles
       sont désignées comme des commandes asynchrones. Les commandes séparées
       par un ; sont exécutées successivement, l'interpréteur attend que chaque
       commande se termine tour à tour. L'état renvoyé est l'état final de la
       dernière commande exécutée.

       Les listes ET et OU sont des suites d'un ou plusieurs pipelines séparés
       respectivement par les opérateurs de contrôle && et ||. Les listes ET et
       OU sont exécutées avec associativité à gauche. Une liste ET est de la
       forme

              commande_1 && commande_2

       commande_2 est exécutée si, et seulement si, commande_1 renvoie zéro
       comme état final (succès).

       Une liste OU a la forme

              commande_1 || commande_2

       commande_2 est exécutée si, et seulement si, commande_1 renvoie un état
       final différent de zéro. L'état renvoyé par des listes ET et OU est
       l'état final de la dernière commande exécutée dans la liste.

   Commandes composées
       Une commande composée est l'une des constructions suivantes. Dans la
       plupart des cas, une liste dans une description de commande pourrait être
       séparée du reste de la commande par un ou plusieurs changements de ligne,
       et pourrait être suivie d’un changement de ligne à la place d’un
       point-virgule.

       (liste)
              liste est exécutée dans un sous-interpréteur (consultez
              ENVIRONNEMENT D'EXÉCUTION DES COMMANDES ci-dessous). 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. L'état renvoyé est l'état final de la
              liste.

       { liste; }
              liste est simplement exécutée avec l'environnement de
              l'interpréteur en cours. liste doit se terminer par un changement
              de ligne ou un point-virgule. Cette construction est connue sous
              le nom de commandes groupées. L'état renvoyé est l'état final de
              la liste. Remarquez que contrairement aux métacaractères ( et ), {
              et } sont des mots réservés qui ne doivent apparaître que là où un
              mot réservé peut être reconnu. Puisqu'ils ne conduiront pas à un
              découpage en mots, ils doivent être séparés de la liste par un
              blanc ou un autre métacaractère de l'interpréteur.

       ((expression))
              L'expression est évaluée selon les règles décrites ci-dessous dans
              ÉVALUATION ARITHMÉTIQUE. Si la valeur arithmétique de l'expression
              est différente de zéro, l'état renvoyé est 0 ; sinon l'état
              renvoyé est 1. C'est exactement équivalent à let "expression".

       [[ expression ]]
              Renvoie un état de 0 ou 1 selon l'évaluation de la condition
              expression. Les conditions sont composées de primitives décrites
              ci-dessous dans CONDITIONS. Le découpage en mots et le
              développement des chemins ne sont pas effectués sur les mots entre
              [[ et ]] ; le développement des tildes, des paramètres, des
              variables, le développement arithmétique, la substitution de
              commande et de processus, ainsi que la suppression des protections
              sont effectués. Les opérateurs conditionnels comme -f ne doivent
              pas être protégés afin d'être reconnus comme primitives.

              Lorsqu'ils sont utilisés avec [[, les opérateurs < et > ordonnent
              d'un point de vue lexicographique en utilisant les paramètres
              linguistiques régionaux actuels.

              Quand les opérateurs == et != sont utilisés, la chaîne placée à
              droite de l'opérateur est considérée comme étant un motif dont la
              correspondance est recherchée selon les règles décrites ci-dessous
              dans Motifs génériques, comme si l’option extglob de
              l’interpréteur était activée. L’opérateur = est équivalent à ==.
              Si l'option d'interpréteur nocasematch est activée, la mise en
              correspondance est effectuée sans tenir compte de la casse
              (différence majuscule/minuscule) des caractères alphabétiques. La
              valeur renvoyée est 0 si les chaînes correspondent (==) ou ne
              correspondent pas (!=), au motif et 1 sinon. Toute partie du motif
              peut être protégée pour forcer la partie protégée à correspondre
              en tant que chaîne.

              Un opérateur binaire supplémentaire, =~, est disponible, avec la
              même priorité que == et !=. Lorsqu'il est utilisé, la chaîne à
              droite de l'opérateur est considérée comme une expression
              rationnelle étendue POSIX et est mise en correspondance en
              conséquence (en utilisant habituellement les interfaces POSIX
              regcomp et regexec comme avec regex(3)). La valeur renvoyée est 0
              si la chaîne correspond au motif et 1 si elle ne correspond pas.
              Si l'expression rationnelle n'est pas syntaxiquement correcte, la
              valeur renvoyée de l'expression conditionnelle est 2. Si l'option
              d'interpréteur nocasematch est activée, la mise en correspondance
              est effectuée sans tenir compte de la casse. Toute partie du motif
              peut être protégée pour forcer la partie protégée à correspondre
              en tant que chaîne. Les expressions entre crochets des expressions
              rationnelles doivent être traitées prudemment, car les caractères
              de protection habituels perdent leur signification entre crochets.
              Si le motif est stocké dans une variable de l’interpréteur, la
              protection de développement de variable force le motif entier à
              correspondre en tant que chaîne.

              Le motif correspondra s'il correspond à n'importe quelle partie de
              la chaîne. Ancrer le motif avec les opérateurs d'expression
              rationnelle ^ et $ pour le forcer à correspondre à la totalité de
              la chaîne. La variable tableau BASH_REMATCH enregistre quelle
              partie de la chaîne correspond au motif. L'élément de BASH_REMATCH
              d'indice 0 contient la partie de la chaîne correspondant à la
              totalité de l'expression rationnelle. Les sous-chaînes
              correspondant aux sous-expressions entre parenthèses dans
              l'expression rationnelle sont sauvegardées avec les indices
              restants de BASH_REMATCH. L'élément de BASH_REMATCH d'indice n est
              la partie de la chaîne correspondant à la n-ième sous-expression
              entre parenthèses.

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

              ( expression )
                     Renvoie la valeur de l'expression. Cela peut être utilisé
                     pour surpasser la priorité normale des opérateurs.
              ! expression
                     Vrai si expression est fausse.
              expression1 && expression2
                     Vrai si expression1 et expression2 sont toutes les deux
                     vraies.
              expression1 || expression2
                     Vrai si expression1 ou expression2 est vraie.

              Les opérateurs && et || n'évaluent pas expression2 si la valeur de
              expression1 suffit à déterminer la valeur renvoyée par la
              condition tout entière.

       for nom [ [ in [ mot ... ] ] ; ] do liste ; done
              La liste de mots suivant in est développée, produisant une liste
              d'éléments. La variable nom prend tour à tour 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 existants (consultez PARAMÈTRES
              ci-dessous). L'état renvoyé est l'état final de la dernière
              commande exécutée. Si le développement des éléments suivant in
              conduit à une liste vide, aucune commande n'est exécutée et l'état
              renvoyé est 0.

       for (( expr1 ; expr2 ; expr3 )) ; do liste ; done
              L'expression arithmétique expr1 est d'abord évaluée selon les
              règles décrites ci-dessous sous ÉVALUATION ARITHMÉTIQUE.
              L'expression arithmétique expr2 est ensuite évaluée répétitivement
              jusqu'à valoir zéro. Chaque fois que expr2 est évaluée en une
              valeur différente de zéro, liste est exécutée et l'expression
              arithmétique expr3 est évaluée. Si l'une des expressions est
              omise, elle est considérée comme s'évaluant à 1. La valeur
              renvoyée est l'état final de la dernière commande dans liste qui
              est exécutée ou faux si l'une des expressions est incorrecte.

       select nom [ in mot ] ; do liste ; done
              La liste de mots à la suite de in est développée, produisant 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 (consultez
              PARAMÈTRES ci-dessous). L'invite PS3 est affichée 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, alors ce mot est
              affecté à la valeur de la variable nom. Si la ligne est vide, les
              mots et l'invite sont affichés à nouveau. Si une fin de fichier
              (EOF) est lue, la commande se termine. Toute autre valeur lue
              force la variable nom à être définie à NULL. La ligne lue est
              conservée dans la variable REPLY. La liste est exécutée après
              chaque sélection, jusqu'à ce qu'une commande break soit atteinte.
              L'état final de select est l'état final de la dernière commande
              exécutée dans la liste ou zéro si aucune commande n'a été
              exécutée.

       case mot in [ [(] motif [ | motif ] ... ) liste ;; ] ... esac
              Une commande case commence d'abord par développer le mot, puis
              essaye de le mettre en correspondance tour à tour avec chacun des
              motifs en utilisant les règles de mise en correspondance dans
              Motifs génériques ci-dessous. Le mot est développé en utilisant le
              développement du tilde, le développement des paramètres et des
              variables, le développement arithmétique, la substitution de
              commande, la substitution de processus et la suppression des
              protections. Chaque motif examiné est développé en utilisant le
              développement du tilde, le développement des paramètres et des
              variables, le développement arithmétique, la substitution de
              commande et la substitution de processus. Si l'option
              d'interpréteur nocasematch est activée, la mise en correspondance
              est effectuée sans tenir compte de la casse des caractères
              alphabétiques. 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 essai si l'opérateur ;; est utilisé. Si ;& est
              utilisé au lieu de ;;, l'exécution continue avec la liste associée
              au jeu de motifs suivant. Si ;;& est utilisé au lieu de ;;,
              l'interpréteur essaye la liste de motifs suivante, si elle existe,
              et exécute toute liste associée à un motif correspondant,
              poursuivant l'exécution de la déclaration de cas comme si la liste
              de motifs n'avait pas de correspondance. Le code de retour est
              zéro si aucun motif ne correspond. Sinon il est le code de retour
              de la dernière commande exécutée dans la liste.

       if liste; then liste; [ elif liste; then liste; ] ... [ else liste; ] fi
              La liste du if est exécutée. Si son état final est zéro, la liste
              du then est exécutée. Sinon, chacune des listes des elif est
              exécutée tour à tour et si son état final est zéro, la liste du
              then associé est exécutée et la commande termine. Sinon, la liste
              du else, si présente, est exécutée. L'état final est l'état final
              de la dernière commande exécutée ou zéro si aucune condition n'a
              été satisfaite.

       while liste-1; do liste-2; done
       until liste-1; do liste-2; done
              La commande while répète la liste liste-2 tant que la dernière
              commande de la liste liste-1 renvoie un état final de zéro. La
              commande until est identique à la commande while, sauf que le test
              est inversé : la liste-2 est exécutée tant que la dernière
              commande de la liste-1 renvoie un état final différent de zéro.
              L'état final des commandes while et until est l'état final de la
              dernière commande exécutée dans la liste-2 ou zéro si aucune
              commande n'a été exécutée.

   Coprocessus
       Un coprocessus est une commande d'interpréteur précédée par le mot
       réservé coproc. Un coprocessus est exécuté de façon asynchrone dans un
       sous-interpréteur, comme si la commande se terminait par l'opérateur de
       contrôle &, avec un tube bidirectionnel établi entre l'interpréteur
       d'exécution et le coprocessus.

       Le format d'un coprocessus est :

              coproc [NOM] commande [redirections]

       Un coprocessus appelé NOM est créé. Si NOM n'est pas fourni, le nom par
       défaut est COPROC. NOM ne doit pas être fourni si commande est une
       commande simple (voir ci-dessus) ; sinon, il est interprété comme le
       premier mot d'une commande simple. Quand le coprocessus est exécuté,
       l'interpréteur crée une variable tableau (consultez Tableaux ci-dessous)
       appelée NOM dans le contexte de l'interpréteur d'exécution. La sortie
       standard de commande est connectée par un tube à un descripteur de
       fichier dans l'interpréteur d'exécution, et ce descripteur de fichier est
       affecté à NOM[0]. L'entrée standard de commande est connectée par un tube
       à un descripteur de fichier dans l'interpréteur d'exécution, et ce
       descripteur de fichier est affecté à NOM[1]. Ce tube est établi avant
       toute redirection indiquée par la commande (consultez REDIRECTIONS
       ci-dessous). Les descripteurs de fichier peuvent être utilisés comme
       arguments aux commandes d'interpréteur et redirections en utilisant les
       développements standards de mot. Les descripteurs de fichier autres que
       ceux créés pour exécuter des substitutions de commande et de processus,
       ne sont pas disponibles dans les sous-interpréteurs. L'identifiant du
       processus (PID) de l'interpréteur engendré pour exécuter le coprocessus
       est la valeur disponible de la variable NAME_PID. La commande interne
       wait peut être réutilisée pour attendre que le coprocessus soit terminé.

       Puisque le coprocessus est créé comme une commande asynchrone, la
       commande coproc se termine toujours avec succès. L'état renvoyé d'un
       coprocessus est l'état final de commande.

   Définitions des fonctions de l'interpréteur
       Une fonction de l'interpréteur est un objet qui est appelé comme une
       commande simple et qui exécute une commande composée avec un nouveau jeu
       de paramètres positionnels. Les fonctions de l'interpréteur sont
       déclarées de la façon suivante :

       nomfonction () commande-composée [redirection]
       function nomfonction [()] commande-composée [redirection]
              Cela définit une fonction possédant le nomfonction mentionné. Le
              mot réservé function est facultatif. S'il est fourni, les
              parenthèses sont facultatives. Le corps de la fonction est la
              commande composée commande-composée (consultez Commandes composées
              ci-dessus). Cette commande est généralement une liste de commandes
              entre { et }, mais peut être n'importe quelle commande décrite
              dans Commandes composées ci-dessus, avec une exception : si le mot
              réservé function est utilisé mais que les parenthèses ne sont pas
              fournies, les accolades sont nécessaires. La commande-composée est
              exécutée chaque fois que nomfonction est indiqué comme le nom
              d'une commande normale. En mode POSIX, nomfonction ne peut pas
              être le nom d’une des commandes internes spéciales de POSIX
              (« special builtins »). En mode par défaut, un nom de fonction
              peut être n'importe quel mot de l'interpréteur non protégé qui ne
              contient pas de $ Toutes les redirections (consultez REDIRECTIONS
              ci-dessous) indiquées lorsqu'une fonction est définie sont
              effectuées lorsque la fonction est exécutée. Le code de retour
              d'une définition de fonction est zéro, à moins qu'une erreur de
              syntaxe ne se produise ou qu'une fonction en lecture seule
              n'existe déjà avec le même nom. Lorsque la fonction est exécutée,
              le code de retour est celui de la dernière commande exécutée dans
              le corps de la fonction (consultez FONCTIONS ci-dessous).

COMMENTAIRES
       Dans un interpréteur non interactif ou dans un interpréteur interactif
       avec l'option interactive_comments activée par la commande interne shopt
       (consultez COMMANDES INTERNES DE L'INTERPRÉTEUR ci-dessous), un mot
       commençant par # conduit à ignorer ce mot et tous les caractères restants
       sur la ligne. Un interpréteur interactif sans l'option
       interactive_comments n'autorise pas les commentaires. L'option
       interactive_comments est activée par défaut dans les interpréteurs
       interactifs.

PROTECTIONS
       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 désactiver le traitement des
       caractères spéciaux, éviter la reconnaissance des mots réservés ou
       empêcher le développement des paramètres.

       Tous les métacaractères décrits ci-dessus dans DÉFINITIONS ont des
       significations spéciales pour l'interpréteur et doivent être protégés
       pour ne représenter que leur propre caractère.

       Lorsque les outils de développement de l'historique des commandes sont
       utilisés (consultez DÉVELOPPEMENT DE L'HISTORIQUE ci-dessous), le
       caractère de développement de l'historique, généralement !, doit être
       protégé pour éviter le développement de l'historique.

       Il y a trois mécanismes de protection : le caractère de protection, les
       guillemets simples (« single quotes ») et les guillemets doubles
       (« double quotes »).

       Le caractère de protection est une contre-oblique (\) non protégée. Il
       préserve la valeur littérale du caractère qui le suit, à l'exception du
       <changement de ligne>. Si un couple \<changement de ligne> apparaît et si
       la contre-oblique n'est pas elle-même protégée, l'ensemble \<changement
       de ligne> est considéré comme une continuation de ligne (c'est-à-dire
       qu'il est supprimé du flux d'entrée et ignoré en pratique).

       Encadrer des caractères entre des guillemets simples préserve la valeur
       littérale de chacun des caractères entre guillemets simples. Un guillemet
       simple ne peut pas être placé entre deux guillemets simples, même s'il
       est précédé d'une contre-oblique.

       Encadrer des caractères entre des guillemets doubles préserve la valeur
       littérale de chacun des caractères sauf $, `, \ et, lorsque le
       développement de l'historique est activé, !. Quand l'interpréteur et en
       mode POSIX, le ! n'a pas de signification particulière entre des
       guillemets doubles, même quand le développement de l'historique est
       activé. Les caractères $ et ` conservent leurs significations spéciales
       entre guillemets doubles. La contre-oblique ne conserve sa signification
       spéciale que lorsqu'elle est suivie par l'un des caractères suivants : $,
       `, ", \ ou <changement de ligne>. Un guillemet double peut être protégé
       entre deux guillemets doubles en étant précédé d'une contre-oblique. S'il
       est activé, le développement de l'historique sera effectué, à moins qu'un
       ! apparaissant entre guillemets doubles ne soit protégé par une
       contre-oblique. La contre-oblique précédant le ! n'est pas supprimée.

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

       Les mots de la forme $'chaîne' sont traités spécialement. Le mot est
       développé en chaîne avec les caractères protégés par contre-oblique
       remplacés comme indiqué par le standard ANSI C. Les suites de protection
       par contre-oblique, si présentes, sont décodées comme suit :
              \a     alerte (alarme) ;
              \b     effacement arrière (« backspace ») ;
              \e
              \E     caractère de protection ;
              \f     saut de page (« form feed ») ;
              \n     saut de ligne (« new line ») ;
              \r     retour chariot (« carriage return ») ;
              \t     tabulation horizontale ;
              \v     tabulation verticale ;
              \\     contre-oblique ;
              \'     guillemet simple ;
              \"     guillemet double ;
              \?     point d'interrogation ;
              \nnn   le caractère 8 bits dont la valeur en octal vaut nnn (un à
                     trois chiffres) ;
              \xHH   le caractère 8 bits dont la valeur hexadécimale est HH (un
                     ou deux chiffres hexadécimaux) ;
              \uHHHH le caractère Unicode (ISO/IEC 10646) dont la valeur
                     hexadécimale est HHHH (un à quatre chiffres hexadécimaux) ;
              \UHHHHHHHH
                     le caractère Unicode (ISO/IEC 10646) dont la valeur
                     hexadécimale est HHHHHHHH (un à huit chiffres
                     hexadécimaux) ;
              \cx    un caractère contrôle-x.

       Le résultat développé est protégé par des guillemets simples comme si le
       symbole dollar n'avait pas été présent.

       Une chaîne entre guillemets doubles précédée d'un symbole dollar
       ($"chaine") conduira à la traduction de la chaîne selon les paramètres
       linguistiques régionaux en vigueur. L'infrastructure de gettext parcourt
       le catalogue de messages et effectue la traduction, en utilisant les
       variables de l'interpréteur LC_MESSAGES et TEXTDOMAIN. Si les paramètres
       linguistiques régionaux actuels sont C ou POSIX, ou, s'il n'y a pas de
       traduction disponible, le symbole dollar est ignoré. Si la chaîne est
       traduite et remplacée, le résultat est protégé par des guillemets
       doubles.

PARAMÈTRES
       Un paramètre est une entité permettant de stocker des valeurs. Il peut
       être un nom, un nombre ou un des caractères spéciaux décrits ci-dessous,
       dans Paramètres spéciaux. Une variable est un paramètre noté par un nom.
       Une variable possède une valeur et zéro ou plusieurs attributs. Les
       attributs sont affectés en utilisant la commande interne declare
       (consultez declare dans COMMANDES INTERNES DE L'INTERPRÉTEUR ci-dessous).

       Un paramètre est créé si une valeur lui a été affectée. La chaîne NULL
       est une valeur correcte. Une fois qu'une variable est créée, elle ne peut
       être détruite qu'en utilisant la commande interne unset (consultez
       COMMANDES INTERNES DE L'INTERPRÉTEUR ci-dessous).

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

              nom=[valeur]

       Si aucune valeur n'est indiquée, une chaîne NULL est affectée à la
       variable. Toutes les valeurs sont sujettes au développement du tilde, des
       paramètres et des variables, à la substitution de commande, au
       développement arithmétique et à la suppression des protections (consultez
       DÉVELOPPEMENTS ci-dessous). Si une variable a son attribut integer
       configuré, alors la valeur est soumise à l'évaluation arithmétique, même
       si la syntaxe $((...)) n'est pas utilisée (consultez Développement
       arithmétique ci-dessous). Le découpage en mots n'est pas effectué, à
       l'exception de « $@ » comme expliqué ci-dessous dans Paramètres spéciaux.
       Le développement des chemins n'est pas effectué. Les affectations peuvent
       également apparaître comme argument des commandes internes suivantes :
       alias, declare, typeset, export, readonly et local (commandes de
       déclaration). En mode POSIX, ces commandes internes pourraient apparaître
       dans une commande après une ou plusieurs instances de la commande interne
       command et conserver ces propriétés d’affectation.

       Dans le contexte où une affectation affecte une valeur à une variable de
       l'interpréteur ou à un indice de tableau, l'opérateur += peut être
       utilisé pour ajouter ou additionner à la précédente valeur de la
       variable. Cela comprend des arguments pour les commandes internes, comme
       declare, qui acceptent des affectations (commandes de déclaration).
       Lorsque l'opérateur += est appliqué à une variable dont l'attribut
       integer (entier) a été positionné, la valeur est évaluée comme une
       expression arithmétique et additionnée à la valeur actuelle de la
       variable qui est également évaluée. Lorsque += est appliqué à une
       variable tableau en utilisant l'affectation composée (consultez Tableaux
       ci-dessous), la valeur de la variable n'est pas détruite (comme elle
       l'est lorsque = est utilisé) et les nouvelles valeurs sont ajoutées au
       tableau, en commençant à l'indice maximal du tableau plus un (pour les
       tableaux indicés) ou ajoutées comme un couple clef valeur pour un tableau
       associatif. Lorsque l'opérateur est appliqué à une variable de type
       chaîne, la valeur est développée et concaténée en valeur de la variable.

       L’attribut nameref peut être affecté à une variable en utilisant l’option
       -n des commandes internes declare et local (consultez la description des
       commandes declare et local ci-dessous) pour créer une nameref ou une
       référence vers une autre variable. Cela permet aux variables d’être
       manipulées indirectement. À chaque fois qu’une variable nameref est
       référencée, affectée, détruite ou a ses attributs modifiés (autrement
       qu'en utilisant ou en changeant l'attribut nameref lui-même), l’opération
       est en fait réalisée sur la variable indiquée par la valeur de la
       variable nameref. nameref est généralement utilisée dans des fonctions
       d’interpréteur pour référencer une variable dont le nom est passé en
       argument de la fonction. Par exemple, si un nom de variable est passé en
       premier argument à une fonction d’interpréteur, exécuter
              declare -n ref=$1
       dans la fonction crée une variable de nameref ref dont la valeur est le
       nom de la variable passée en premier argument. Les références et
       affectations de ref et les modifications de ses attributs sont traitées
       comme des références, affectations et modifications d'attribut sur la
       variable dont le nom a été passé par $1. Si la variable de contrôle dans
       une boucle for a l’attribut nameref, la liste de mots peut être une liste
       de variables d’interpréteur et une référence de nom est établie pour
       chaque mot de la liste, tour à tour, lorsque la boucle est exécutée.
       L’attribut nameref ne peut pas être donné aux variables de type tableau.
       Cependant, les variables nameref peuvent référencer des variables de type
       tableau et des variables de type tableau indicé. nameref peut être
       détruit en utilisant l’option -n de la commande interne unset. Sinon, si
       unset est exécuté avec le nom d’une variable nameref en argument, la
       variable référencée par la variable nameref sera détruite.

   Paramètres positionnels
       Un paramètre positionnel est un paramètre noté par un ou plusieurs
       chiffres (à l'exception du chiffre 0 seul). Les paramètres positionnels
       sont affectés avec les arguments de l'interpréteur lors de son appel. Ils
       peuvent être réaffectés avec la commande interne set. On ne peut pas
       utiliser les affectations pour les paramètres positionnels. Ils sont
       temporairement remplacés lors de l'exécution d'une fonction de
       l'interpréteur (consultez FONCTIONS ci-dessous).

       Un paramètre positionnel constitué de plusieurs chiffres doit être
       encadré par des accolades lors de son développement (consultez
       DÉVELOPPEMENTS ci-dessous).

   Paramètres spéciaux
       L'interpréteur traite plusieurs paramètres spécifiquement. Ces paramètres
       peuvent uniquement être consultés, il n'est pas permis de leur affecter
       une valeur.
       *      Se développe en l'ensemble des paramètres positionnels, commençant
              par le premier. Quand le développement n’est pas entre guillemets
              doubles, tous les paramètres positionnels se développent en mots
              séparés. Dans les contextes où il sont réalisés, ces mots sont
              soumis à d’autres découpages en mots et développements de chemin.
              Quand le développement se produit entre des guillemets doubles, *
              se transforme en un seul mot constitué de la valeur de tous les
              paramètres positionnels séparés par le premier caractère de la
              variable spéciale IFS. C'est-à-dire que « $* » est équivalent à
              « $1c$2c... », où c est le premier caractère de la valeur de la
              variable IFS. Si IFS est inexistante, les paramètres sont séparés
              par des espaces. Si IFS est NULL, les paramètres sont accolés sans
              séparateurs.
       @      Se développe en ensemble des paramètres positionnels, commençant
              par le premier. Dans les contextes où le découpage en mots est
              réalisé, chaque paramètre positionnel se développe en un mot
              séparé ; si ces mots ne sont pas entre des guillemets doubles, ils
              sont sujets au découpage de mot. Dans les contextes où il n'y a
              pas de découpage en mots, chaque paramètre positionnel se
              développe en un mot distinct séparé par des espaces. Quand le
              développement a lieu entre guillemets doubles, chaque paramètre se
              développe en un mot distinct. C'est-à-dire que « $@ » est
              équivalent à « $1 » « $2 » .... Si le développement des guillemets
              doubles survient dans un mot, le développement du premier
              paramètre est accolé à la première partie du mot d'origine et le
              développement du dernier paramètre est accolé à la dernière partie
              du mot d'origine. Quand il n'y a pas de paramètres positionnels,
              « $@ » et $@ ne se développent en rien (c'est-à-dire qu'ils sont
              simplement éliminés).
       #      Correspond au nombre de paramètres positionnels, en base décimale.
       ?      Se développe en état final du dernier pipeline exécuté au premier
              plan.
       -      Est remplacé par la liste des options de l'interpréteur indiquées
              durant l'appel, configurées avec la commande interne set ou celles
              créées par l'interpréteur lui-même (comme avec l'option -i).
       $      Se transforme en PID de l'interpréteur. Dans un sous-interpréteur
              (), il se transforme en PID de l'interpréteur et non pas du
              sous-interpréteur.
       !      Se transforme en PID de la dernière tâche placée en arrière-plan,
              soit exécutée comme une commande asynchrone, soit en utilisant la
              commande interne bg (consultez CONTRÔLE DES TÂCHES ci-dessous).
       0      Se développe en nom de l'interpréteur ou du script. Ce paramètre
              est créé lors de l'initialisation de l'interpréteur. Si bash est
              appelé 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 nom de fichier utilisé
              pour appeler bash, comme indiqué par l'argument zéro.

   Variables de l'interpréteur
       Les variables suivantes sont créées par l'interpréteur :

       _      Au lancement de l'interpréteur, contient le chemin d'accès utilisé
              pour appeler l'interpréteur, ou le script en cours d'exécution tel
              qu'il est passé dans l'environnement ou dans la liste des
              arguments. Devient ensuite le dernier argument de la commande
              simple précédente exécutée au premier plan, après développement.
              Contient également le 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 consultation.
       BASH   Se développe en chemin d'accès complet à l'instance actuelle de
              bash.
       BASHOPTS
              Liste des options activées de l'interpréteur, séparées par des
              deux-points « : ». Chaque mot de la liste est un argument correct
              pour l'option -s de la commande interne shopt (consultez COMMANDES
              INTERNES DE L'INTERPRÉTEUR ci-dessous). Les options apparaissant
              dans BASHOPTS sont celles indiquées comme actives par shopt. 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 en lecture seule.
       BASHPID
              Se transforme en PID du processus de l'interpréteur bash actuel.
              Diffère de $$ sous certaines conditions, comme dans les
              sous-interpréteurs ne nécessitant pas que bash soit réinitialisé.
              Les assignations à BASHPID n'ont pas d”effet. Si BASHPID est
              détruite, elle perd ses propriétés spéciales, même si elle est
              recréée par la suite.
       BASH_ALIASES
              Une variable de type tableau associatif dont les éléments
              correspondent à une liste interne d'alias comme celle gérée par la
              commande interne alias. Les éléments ajoutés à ce tableau
              apparaissent dans la liste d'alias ; cependant, la destruction
              d'éléments du tableau ne provoque pas actuellement le retrait des
              alias de la liste d'alias. Si BASH_ALIASES est détruite, elle perd
              ses propriétés spéciales, même si elle est recréée par la suite.
       BASH_ARGC
              Une variable de type tableau contenant le nombre de paramètres de
              chaque trame de la pile d'appel d'exécution de l'interpréteur bash
              actuel. Le nombre de paramètres du sous-programme actuel (fonction
              de l'interpréteur ou du script exécuté par . ou source) est au
              sommet de la pile. Lorsqu'un sous-programme est exécuté, le nombre
              de paramètres passés est placé dans BASH_ARGC. L'interpréteur crée
              BASH_ARGC seulement dans le mode de traçage étendu (consultez
              ci-dessous la description de l'option extdebug de la commande
              interne shopt). La configuration de extdebug après que
              l'interpréteur ait démarré l'exécution d'un script, ou le
              référencement de cette variable quand extdebug n'existe pas, peut
              provoquer une incohérence des valeurs.
       BASH_ARGV
              Une variable de type tableau contenant tous les paramètres de la
              pile d'appel d'exécution de l'interpréteur bash actuel. Le dernier
              paramètre du dernier sous-programme est au sommet de la pile ; le
              premier paramètre de l'appel initial est en bas. Lorsqu'un
              sous-programme est exécuté, les paramètres fournis sont placés
              dans BASH_ARGV.  BASH_ARGV est créé uniquement dans le mode de
              traçage étendu (consultez ci-dessous la description de l'option
              extdebug de la commande interne shopt). La configuration de
              extdebug après que l'interpréteur ait démarré l'exécution d'un
              script, ou le référencement de cette variable quand extdebug
              n'existe pas peut provoquer une incohérence des valeurs.
       BASH_ARGV0
              Quand elle est référencée, cette variable développe le nom de
              l'interpréteur ou du script de l'interpréteur (identique à $0 ;
              voir la description du paramètre spécial 0 ci-dessus).
              L'affectation d'une valeur à BASH_ARGV0 fait que cette valeur est
              aussi assignée à $0. Si BASH_ARGV0 est détruite, elle perd ses
              propriétés spéciales, même si elle est recréée par la suite.
       BASH_CMDS
              Une variable de type tableau associatif dont les éléments
              correspondent à une table de hachage interne de commandes comme
              celle gérée par la commande interne hash. Les éléments ajoutés à
              ce tableau apparaissent dans la table de hachage ; cependant, la
              destruction d'éléments du tableau ne provoque pas actuellement le
              retrait des noms de commandes de la table de hachage. Si BASH_CMDS
              est détruite, elle perd ses propriétés spéciales, même si elle est
              recréée par la suite.
       BASH_COMMAND
              La commande en cours d'exécution ou sur le point d'être exécutée,
              à moins que l'interpréteur n'exécute une commande à la suite d'une
              capture, auquel cas c'est la commande s'exécutant au moment de la
              capture. Si BASH_COMMAND est détruite, elle perd ses propriétés
              spéciales, même si elle est recréée par la suite.
       BASH_EXECUTION_STRING
              L'argument commande de l'option d'appel -c.
       BASH_LINENO
              Une variable de type tableau dont les éléments sont les numéros de
              ligne des fichiers sources où chaque élément correspondant de
              FUNCNAME a été invoqué. ${BASH_LINENO[$i]} est le numéro de la
              ligne dans le fichier source (${BASH_SOURCE[$i+1]}) où
              ${FUNCNAME[$i]} a été appelé (ou ${BASH_LINENO[$i-1]} si consulté
              depuis une autre fonction de l'interpréteur). Utilisez LINENO pour
              obtenir le numéro de ligne actuel.
       BASH_LOADABLES_PATH
              Liste des répertoires, séparés par des deux-points « : », que
              l'interpréteur consulte lorsqu'il cherche les commandes internes
              chargeables dynamiquement spécifiées par la commande enable.
       BASH_REMATCH
              Une variable de type tableau dont les éléments sont affectés avec
              l'opérateur binaire =~ dans la commande conditionnelle [[.
              L'élément d'indice 0 est la partie de la chaîne correspondant à
              l'expression rationnelle complète. L'élément d'indice n est la
              partie de la chaîne correspondant à la n-ième sous-expression
              entre parenthèses.
       BASH_SOURCE
              Une variable de type tableau dont les éléments sont les noms des
              fichiers source où les noms des fonctions d'interpréteur
              correspondants à la variable de type tableau FUNCNAME sont
              définis. La fonction d'interpréteur ${FUNCNAME[$i]} est définie
              dans le fichier ${BASH_SOURCE[$i]} et appelée depuis
              ${BASH_SOURCE[$i+1]}.
       BASH_SUBSHELL
              Incrémentée dans tous les sous-interpréteurs et environnements de
              sous-interpréteur quand l’interpréteur commence à s’exécuter dans
              cet environnement. La valeur initiale est 0. Si BASH_COMMAND est
              détruite, elle perd ses propriétés spéciales, même si elle est
              recréée par la suite.
       BASH_VERSINFO
              Une variable de type tableau protégée en écriture dont les
              éléments représentent la version de cette instance de bash. Cette
              valeur est affectée aux éléments du tableau comme suit :
              BASH_VERSINFO[0]        Le numéro majeur de la version (release).
              BASH_VERSINFO[1]        Le numéro mineur de la version (version).
              BASH_VERSINFO[2]        Le niveau de correctif.
              BASH_VERSINFO[3]        Le numéro de compilation.
              BASH_VERSINFO[4]        Le statut de cette version (par exemple
                                      beta1).
              BASH_VERSINFO[5]        La valeur de MACHTYPE.
       BASH_VERSION
              Se développe en une chaîne décrivant le numéro de version de cette
              instance de bash.
       COMP_CWORD
              Un indice dans ${COMP_WORDS} du mot contenant la position actuelle
              du curseur. Cette variable n'est disponible que dans les fonctions
              de l'interpréteur appelées par les outils de complètement
              programmables (consultez Complètement programmable ci-dessous).
       COMP_KEY
              La touche (ou dernière touche d'une suite de touches) utilisée
              pour appeler la fonction de complètement actuelle.
       COMP_LINE
              La ligne de commande actuelle. Cette variable n'est disponible que
              dans les fonctions de l'interpréteur appelées par les outils de
              complètement programmables (consultez Complètement programmable
              ci-dessous).
       COMP_POINT
              L'indice de la position actuelle du curseur relatif au début de la
              commande actuelle. Si la position actuelle du curseur est à la fin
              de la commande actuelle, la valeur de cette variable est égale à
              ${#COMP_LINE}. Cette variable n'est disponible que dans les
              fonctions de l'interpréteur et les commandes externes appelées par
              les outils de complètement programmables (consultez Complètement
              programmable ci-dessous).
       COMP_TYPE
              Configurée à une valeur entière correspondant au type de
              complètement essayé qui a provoqué l'appel d'une fonction de
              complètement : TAB pour un complètement normal, ? pour l'affichage
              des complètements après tabulations successives, ! pour
              l'affichage des alternatives de complètement de mot partiel, @
              pour afficher les complètements si le mot n'est pas modifié, ou %
              pour le menu de complètement. Cette variable n'est disponible que
              dans les fonctions de l'interpréteur et les commandes externes
              appelées par les outils de complètement programmables (consultez
              Complètement programmable ci-dessous).
       COMP_WORDBREAKS
              Le jeu de caractères que la bibliothèque readline considère comme
              séparateurs de mots lors du complètement de mot. Si
              COMP_WORDBREAKS est détruite, elle perd ses propriétés spéciales,
              même si elle est recréée par la suite.
       COMP_WORDS
              Une variable de type tableau (consultez Tableaux ci-dessous)
              consistant en mots individuels de la ligne de commande actuelle.
              La ligne est découpée en mots comme readline la découperait, en
              utilisant COMP_WORDBREAKS tel que décrit ci-dessus. Cette variable
              n'est disponible que dans les fonctions de l'interpréteur appelées
              par les outils de complètement programmables (consultez
              Complètement programmable ci-dessous).
       COPROC Une variable de type tableau (consultez Tableaux ci-dessous) créée
              pour représenter les descripteurs de fichier pour les sorties
              depuis et les entrées vers un coprocessus non nommé (consultez
              Coprocessus ci-dessus).
       DIRSTACK
              Une variable de type tableau (consultez Tableaux ci-dessous)
              représentant le contenu actuel de la pile de répertoires. Les
              répertoires apparaissent dans la pile dans l'ordre dans lequel la
              commande interne dirs les affiche. Les affectations des éléments
              de cette variable tableau peuvent être utilisés pour modifier les
              répertoires déjà dans la pile, mais les commandes internes pushd
              et popd doivent être utilisées pour ajouter et enlever des
              répertoires. L'affectation de cette variable ne modifiera pas le
              répertoire actuel. Si DIRSTACK est détruite, elle perd ses
              propriétés spéciales, même si elle est recréée par la suite.
       EPOCHREALTIME
              À chaque fois que ce paramètre est consulté, il se développe en
              nombre de secondes écoulées depuis l'Epoch Unix (consultez
              time(3)) comme valeur en virgule flottante avec une granularité
              d'une microseconde. Les affectations à EPOCHREALTIME sont
              ignorées. Si EPOCHREALTIME est détruite, elle perd ses propriétés
              spéciales, même si elle est recréée par la suite.
       EPOCHSECONDS
              À chaque fois que ce paramètre est consulté, il se développe en
              nombre de secondes écoulées depuis l'Epoch Unix (consultez
              time(3)). Les affectations à EPOCHSECONDS sont ignorées. Si
              EPOCHSECONDS est détruite, elle perd ses propriétés spéciales,
              même si elle est recréée par la suite.
       EUID   Contient l'UID effectif de l'utilisateur, initialisé au démarrage
              de l'interpréteur. Cette variable est en lecture seule.
       FUNCNAME
              Une variable de type tableau contenant le nom de toutes les
              fonctions de l'interpréteur actuellement dans la pile d'appel
              d'exécution. L'élément d'indice 0 est le nom de l'une des
              fonctions en cours d'exécution dans l'interpréteur. L'élément le
              plus bas (celui avec l'indice le plus grand) est "main".  Cette
              variable n'existe que si une fonction de l'interpréteur est en
              cours d'exécution. Les affectations de FUNCNAME n'ont aucun effet.
              Si FUNCNAME est détruite, elle perd ses propriétés spéciales, même
              si elle est recréée par la suite.

              Cette variable peut être utilisée avec BASH_LINENO et BASH_SOURCE.
              Chaque élément de FUNCNAME a des éléments correspondant dans
              BASH_LINENO et BASH_SOURCE pour décrire la pile d'appel. Par
              exemple, ${FUNCNAME[$i]} a été appelé depuis le fichier
              ${BASH_SOURCE[$i+1]} à la ligne numéro ${BASH_LINENO[$i]}. La
              commande interne caller affiche la pile d'appel actuelle utilisant
              ces renseignements.
       GROUPS Une variable de type tableau contenant la liste des groupes dont
              l'utilisateur est membre. Les affectations de GROUPS n'ont aucun
              effet. Si GROUPS est détruite, elle perd ses propriétés spéciales,
              même si elle est recréée par la suite.
       HISTCMD
              Le numéro d'historique, ou l'indice dans la file d'historique, de
              la commande en cours. Les affectations de HISTCMD sont ignorées.
              Si HISTCMD est détruite, elle perd ses propriétés spéciales, même
              si elle est recréée par la suite.
       HOSTNAME
              Automatiquement configurée au nom de la machine actuelle.
       HOSTTYPE
              Automatiquement configurée en chaîne décrivant de façon unique le
              type de machine sur laquelle bash s'exécute. La valeur par défaut
              dépend du système.
       LINENO Chaque fois que ce paramètre est consulté, l'interpréteur 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.
              Hors d'un script ou d'une fonction, la valeur n'a pas
              nécessairement de sens. Si LINENO est détruite, elle perd ses
              propriétés spéciales, même si elle est recréée par la suite.
       MACHTYPE
              Automatiquement configurée en chaîne décrivant le type du système
              sur lequel bash s'exécute, dans le format standard de GNU
              processeur-compagnie-système. La valeur par défaut dépend du
              système.
       MAPFILE
              Une variable de type tableau (consultez Tableaux ci-dessous) créée
              pour représenter le texte lu par la commande interne mapfile si
              aucun nom de variable n'a été fourni.
       OLDPWD Le répertoire de travail précédent tel que configuré par la
              commande cd.
       OPTARG La valeur du dernier argument d'option traité par la commande
              interne getopts (consultez COMMANDES INTERNES DE L'INTERPRÉTEUR
              ci-dessous).
       OPTIND L'indice du prochain argument à traiter par la commande interne
              getopts (consultez COMMANDES INTERNES DE L'INTERPRÉTEUR
              ci-dessous).
       OSTYPE Automatiquement configurée en chaîne décrivant le système
              d'exploitation sur lequel bash s'exécute. La valeur par défaut
              dépend du système.
       PIPESTATUS
              Une variable de type tableau (consultez Tableaux ci-dessous)
              contenant une liste des états finaux des processus exécutés dans
              le pipeline exécuté le plus récemment au premier plan (qui peut
              éventuellement contenir une seule commande).
       PPID   L'identifiant du processus parent de l'interpréteur. Cette
              variable est en lecture seule.
       PWD    Le répertoire de travail actuel tel que configuré par la commande
              cd.
       RANDOM À chaque fois que ce paramètre est consulté, un entier aléatoire
              entre 0 et 32767 est engendré. L'affectation d'une valeur à RANDOM
              initialise (ensemence) la suite de nombres aléatoires. Si RANDOM
              est détruite, elle perd ses propriétés spéciales, même si elle est
              recréée par la suite.
       READLINE_LINE
              Le contenu du tampon de ligne readline, pour utiliser avec "bind
              -x" (consultez COMMANDES INTERNES DE L'INTERPRÉTEUR ci-dessous).
       READLINE_MARK
              La position de la marque (point d'insertion enregistré) dans le
              tampon de ligne readline, pour utiliser avec "bind -x" (consultez
              COMMANDES INTERNES DE L'INTERPRÉTEUR ci-dessous). Les caractères
              entre le point d'insertion et la marque sont souvent appelés la
              zone.
       READLINE_POINT
              La position du point d'insertion dans le tampon de ligne readline,
              pour utiliser avec "bind -x" (consultez COMMANDES INTERNES DE
              L'INTERPRÉTEUR ci-dessous).
       REPLY  Configurée en ligne de saisie lue par la commande interne read
              lorsqu'aucun argument n'a été fourni.
       SECONDS
              À chaque fois que ce paramètre est consulté, le temps en seconde
              écoulé depuis le lancement de l'interpréteur est renvoyé. Si une
              valeur est affectée à SECONDS, la valeur renvoyée lors d’une
              consultation ultérieure est le temps en seconde écoulé depuis
              l'affectation, ajouté à la valeur affectée. Le temps en seconde au
              moment du lancement de l'interpréteur et l'heure actuelle sont
              toujours déterminés en interrogeant l'horloge système. Si SECONDS
              est détruite, elle perd ses propriétés spéciales, même si elle est
              recréée par la suite.
       SHELLOPTS
              Liste des options activées de l'interpréteur, séparées par des
              deux-points « : ». Chaque mot de la liste est un argument correct
              pour l'option -o de la commande interne set (consultez COMMANDES
              INTERNES DE L'INTERPRÉTEUR ci-dessous). Les options apparaissant
              dans SHELLOPTS sont celles 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 en lecture seule.
       SHLVL  Incrémenté de 1 à chaque appel d'une instance de bash.
       SRANDOM
              Cette variable engendre un nombre pseudo-aléatoire de 32 bits
              chaque fois qu'elle est consultée. Le générateur de nombres
              aléatoires n'est pas linéaire sur les systèmes qui prennent en
              charge /dev/urandom ou arc4random, aussi chaque nombre renvoyé n'a
              aucune relation avec les nombres précédents. Le générateur de
              nombre aléatoire ne peut pas être ensemencé, aussi les
              affectations à cette variable n'ont aucun effet. Si SRANDOM est
              détruite, elle perd ses propriétés spéciales, même si elle est
              recréée par la suite.
       UID    Contient l'UID de l'utilisateur actuel, initialisé au démarrage de
              l'interpréteur. Cette variable est en lecture seule.

       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 ci-dessous.

       BASH_COMPAT
              La valeur est utilisée pour définir le niveau de compatibilité de
              l’interpréteur. Consultez MODE DE COMPATIBILITÉ DE L'INTERPRÉTEUR
              ci-dessous pour une description des différents niveaux de
              compatibilité et leurs conséquences. La valeur peut être un nombre
              décimal (par exemple 4.2) ou entier (par exemple 42) correspondant
              au niveau de compatibilité voulu. Si BASH_COMPAT est détruite ou
              définie comme une chaîne vide, le niveau de compatibilité est
              défini à la valeur par défaut de la version actuelle. Si
              BASH_COMPAT est définie à une valeur de niveau de compatibilité
              impossible, l’interpréteur affiche un message d’erreur et définit
              le niveau de compatibilité à la valeur par défaut de la version
              actuelle. Les valeurs possibles correspondent aux niveaux de
              compatibilité décrits ci-dessous dans MODE DE COMPATIBILITÉ DE
              L'INTERPRÉTEUR. Par exemple, 4.2 et 42 sont des valeurs possibles
              qui correspondent à l'option compat42 de shopt et définissent le
              niveau de compatibilité à 42. La version actuelle est aussi une
              valeur possible.
       BASH_ENV
              Si ce paramètre existe 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 dans ~/.bashrc. La
              valeur de BASH_ENV est soumise au développement des paramètres, à
              la substitution de commande et au développement arithmétique avant
              d'être considérée comme un nom de fichier.  PATH n'est pas
              utilisée pour rechercher le fichier obtenu.
       BASH_XTRACEFD
              Si configurée à une valeur entière correspondant à un descripteur
              de fichier correct, bash écrira la trace de sortie si set -x est
              activé vers ce descripteur de fichier. Le descripteur de fichier
              est fermé quand BASH_XTRACEFD est détruite ou qu'une nouvelle
              valeur lui est affectée. Détruire BASH_XTRACEFD ou lui affecter la
              chaîne vide conduit la trace de sortie à être envoyée vers la
              sortie d'erreur standard. Remarquez que configurer BASH_XTRACEFD à
              2 (le descripteur de fichier de la sortie d'erreur standard) puis
              la détruire revient à fermer la sortie d'erreur standard.
       CDPATH Le chemin de recherche de la commande interne cd. Il s'agit d'une
              liste de répertoires, séparés par des deux-points « : », que
              l'interpréteur consulte lorsqu'il cherche un sous-répertoire
              destination de la commande cd. Un exemple de valeur est
              ".:~:/usr".
       CHILD_MAX
              Définir le nombre de valeurs d’état de sortie des enfants dont
              l’interpréteur doit se souvenir. Bash ne permettra pas à cette
              valeur d’être inférieure à un minimum imposé par POSIX, ni d’être
              supérieure à une valeur maximale (8192 pour l’instant). La valeur
              minimale dépend du système.
       COLUMNS
              Utilisée par la commande composée select pour déterminer la
              largeur du terminal lors de l'affichage des listes de sélection.
              Automatiquement configurée si l’option checkwinsize est activée ou
              dans un interpréteur interactif à la réception d'un signal
              SIGWINCH.
       COMPREPLY
              Une variable de type tableau dans lequel bash lit les
              complètements possibles produits par une fonction de
              l'interpréteur appelée par les outils de complètement
              programmables (consultez Complètement programmable ci-dessous).
              Chaque élément du tableau contient un complètement possible.
       EMACS  Si bash trouve cette variable dans l'environnement lorsque
              l'interpréteur démarre avec la valeur "t", il considère que
              l'interpréteur est lancé dans un tampon d'interpréteur d'Emacs et
              désactive l'édition en ligne.
       ENV    Développé et exécuté de façon similaire à BASH_ENV (consultez
              APPEL ci-dessus) quand l'interpréteur interactif est invoqué en
              mode POSIX.
       EXECIGNORE
              Une liste, séparée par des deux-points « : », de motifs de
              l'interpréteur (voir Motifs génériques) définissant la liste de
              noms de fichier à ignorer par la commande de recherche utilisant
              PATH. Les fichiers dont les noms de chemin complets correspondent
              à un de ces motifs ne sont pas considérés comme des fichiers
              exécutables en vue du complètement et de l'exécution de commande
              au moyen d'une recherche dans PATH. Cela n'affecte pas le
              comportement des commandes [, test et [[. Les noms de chemin
              complets dans la table de hachage des commandes ne sont pas sujets
              à EXECIGNORE. Utiliser cette variable pour ignorer des fichiers de
              bibliothèque partagée dont le bit exécutable est présent, mais qui
              ne sont pas des fichiers exécutables. La correspondance de motif
              respecte la configuration de l'option d'interpréteur extglob.
       FCEDIT L'éditeur par défaut utilisé par la commande interne fc.
       FIGNORE
              Une liste de suffixes, séparés par des deux-points « : », que bash
              ignorera lors du complètement des noms de fichiers (consultez
              READLINE ci-dessous). Un nom de fichier dont le suffixe correspond
              à l'un de ceux mentionnés dans FIGNORE est exclu de la liste des
              noms de fichiers correspondant pour le complètement. Par exemple,
              cette variable peut prendre la valeur ".o:~".
       FUNCNEST
              Si configurée à une valeur numérique strictement positive, cela
              définit le niveau maximal d'imbrication de fonctions. Les
              invocations de fonctions qui dépassent ce niveau d'imbrication
              forceront la commande actuelle à abandonner.
       GLOBIGNORE
              Une liste de motifs séparés par des deux-points « : », définissant
              l'ensemble des noms de fichier à ignorer lors du développement des
              chemins. Si un nom de fichier correspondant à un des motif de
              développement des chemins correspond également à un des motifs
              dans GLOBIGNORE, il est supprimé de la liste des correspondances.
       HISTCONTROL
              Une liste de valeurs, séparées par des deux-points « : »,
              commandant la façon dont les commandes sont sauvegardées dans la
              file d'historique. Si la liste des valeurs contient la valeur
              ignorespace, les lignes commençant par une espace ne sont pas
              sauvegardées dans la file d'historique. La valeur ignoredups
              conduit à ne pas sauvegarder une ligne correspondant exactement à
              la ligne de commande précédente. La présence de ignoreboth est un
              condensé pour ignorespace et ignoredups. La valeur erasedups
              conduit à retirer de la file d'historique toutes les lignes
              précédant la ligne actuelle et lui correspondant avant que cette
              ligne y soit sauvegardée. Toute valeur qui ne fait pas partie de
              la liste ci-dessus est ignorée. Si HISTCONTROL est inexistante ou
              si elle ne contient pas une valeur correcte, toutes les lignes
              lues par l'analyseur de l'interpréteur seront sauvegardées dans la
              file d'historique, selon la valeur de HISTIGNORE. La seconde ligne
              et les suivantes d'une commande multiligne ne sont pas testées et
              sont ajoutées dans l'historique indépendamment de la valeur de
              HISTCONTROL.
       HISTFILE
              Le nom du fichier dans lequel l'historique des commandes est
              sauvegardé (consultez HISTORIQUE ci-dessous). Par défaut, il
              s'agit de ~/.bash_history. Si inexistante, l'historique des
              commandes n'est pas sauvegardé lorsqu'un interpréteur se termine.
       HISTFILESIZE
              Le nombre maximal de lignes contenues dans le fichier
              d'historique. Quand cette variable contient une valeur, le fichier
              d’historique est tronqué, si besoin, pour ne pas contenir plus que
              ce nombre de lignes en enlevant les entrées les plus anciennes. Ce
              fichier est aussi tronqué à cette taille après son écriture quand
              un interpréteur se termine. Si la valeur est 0, le fichier
              d’historique est tronqué à une taille nulle. Les valeurs non
              numériques ou négatives empêchent la troncature. L’interpréteur
              définit la valeur par défaut à la valeur de HISTSIZE après avoir
              lu tous les fichiers d’initialisation.
       HISTIGNORE
              Une liste de motifs, séparés par des deux-points « : »,
              déterminant quelles lignes de commande devraient être sauvegardées
              dans la file d'historique. Chaque motif est accroché au début de
              la ligne et doit correspondre à celle-ci complètement (aucun ajout
              de « * » implicite). Chaque motif est comparé à chaque ligne après
              application des vérifications de HISTCONTROL. En plus des motifs
              génériques usuels de l'interpréteur, « & » correspond à la ligne
              précédente de l'historique. « & » peut être protégée par une
              contre-oblique ; la contre-oblique est supprimée avant de tenter
              une comparaison. La seconde ligne et les suivantes d'une commande
              composée multiligne ne sont pas testées et sont ajoutées dans
              l'historique quelque soit la valeur de HISTIGNORE. La
              correspondance de motif respecte la configuration de l'option
              d'interpréteur extglob.
       HISTSIZE
              Le nombre de commandes à mémoriser dans l'historique (consultez
              HISTORIQUE ci-dessous). Si la valeur est 0, les commandes ne sont
              pas sauvegardées dans la liste d’historique. Les valeurs négatives
              permettent de sauvegarder toutes les commandes dans la liste
              d’historique (sans limite). L’interpréteur définit la valeur par
              défaut à 500 après avoir lu tous les fichiers d’initialisation.
       HISTTIMEFORMAT
              Si cette variable existe et n'est pas NULL, sa valeur est utilisée
              comme une chaîne de caractères par strftime(3) afin d'imprimer
              l'horodatage associé à chaque élément de l'historique affiché par
              la commande interne history. Si cette variable existe, les
              horodatages sont écrits dans le fichier d'historique afin d'être
              conservés au fur et à mesure des sessions de l'interpréteur. Cela
              utilise le caractère de commentaire d'historique pour distinguer
              l'horodatage des autres lignes de l'historique.
       HOME   Le répertoire d'accueil de l'utilisateur actuel ; l'argument par
              défaut de la commande interne cd. La valeur de cette variable est
              aussi utilisée lors du développement du tilde.
       HOSTFILE
              Contient le nom d'un fichier ayant le même format /etc/hosts qui
              devra être lu lorsque l'interpréteur aura besoin de compléter un
              nom de machine. La liste des complètements possibles de noms de
              machine peut être changée pendant l'exécution de l'interpréteur ;
              à la tentative de complètement de nom de machine suivant le
              changement de valeur, bash ajoute le contenu du nouveau fichier à
              la liste existante. Si HOSTFILE existe mais est vide, ou désigne
              un fichier non accessible en lecture, bash essaie de lire
              /etc/hosts pour obtenir la liste des complètements de noms de
              machine possibles. Lorsque HOSTFILE est détruite, la liste des
              noms de machine est effacée.
       IFS    Le séparateur de champs interne Internal Field Separator ») qui
              est utilisé pour le découpage en mots après les développements et
              pour découper les lignes en mots avec la commande interne read. La
              valeur par défaut est « <espace><tab><changement_de_ligne> ».
       IGNOREEOF
              Commande le comportement d'un interpréteur interactif à la
              réception d'un caractère EOF (fin de fichier) comme unique saisie.
              Si elle existe, la valeur est le nombre de caractères EOF
              consécutifs qui doivent être tapés comme premiers caractères sur
              une ligne de saisie avant que bash ne termine. Si la variable
              existe mais que sa valeur n'est pas numérique ou si elle n'a pas
              de valeur, la valeur par défaut est 10. Si elle n'existe pas, EOF
              signifie la fin de la saisie pour l'interpréteur.
       INPUTRC
              Le nom du fichier d’initialisation pour readline, prioritaire sur
              le fichier par défaut de ~/.inputrc (consultez READLINE
              ci-dessous).
       INSIDE_EMACS
              Si cette variable apparaît dans l'environnement quand le script
              démarre, bash considère qu'il s'exécute dans un tampon
              d'interpréteur d'Emacs et peut désactiver l'édition de ligne,
              suivant la valeur de TERM.
       LANG   Utilisée pour déterminer le paramètre linguistique régional pour
              toute catégorie non spécifiquement sélectionnée par une variable
              commençant par LC_.
       LC_ALL Cette variable surpasse LANG et toute autre variable LC_ indiquant
              une catégorie de paramètres linguistiques régionaux.
       LC_COLLATE
              Cette variable détermine l'ordre de collation utilisé pour trier
              les résultats du développement des chemins et détermine le
              comportement des expressions d’intervalle, des classes
              d'équivalences et des suites de collations dans le développement
              des chemins et la correspondance de motifs.
       LC_CTYPE
              Cette variable détermine l'interprétation des caractères et le
              comportement des classes de caractères lors du développement des
              chemins et de la recherche de correspondances de motifs.
       LC_MESSAGES
              Cette variable détermine le paramètre linguistique régional
              utilisé pour traduire les chaînes entre guillemets doubles
              précédées d'un $.
       LC_NUMERIC
              Cette variable détermine le paramètre linguistique régional
              utilisé pour formater les nombres.
       LC_TIME
              Cette variable détermine le paramètre linguistique régional
              utilisé pour les données et le temps.
       LINES  Utilisée par la commande composée select pour déterminer la taille
              des colonnes lors de l'affichage des listes de sélection.
              Automatiquement configurée si l’option checkwinsize est activée ou
              dans un interpréteur interactif à la réception d'un signal
              SIGWINCH.
       MAIL   Si ce paramètre correspond à un nom de fichier ou de répertoire et
              si la variable MAILPATH est inexistante, bash informe
              l'utilisateur de l'arrivée de messages dans le fichier indiqué ou
              le répertoire au format Maildir.
       MAILCHECK
              Indique la durée (en seconde) au bout de laquelle bash vérifie si
              un nouveau message est arrivé. La valeur par défaut est
              60 secondes. Lorsque le délai est écoulé, l'interpréteur vérifiera
              la présence d'un courrier électronique avant d'afficher son invite
              de base. Si cette variable est inexistante, ou contient une valeur
              strictement négative, l'interpréteur désactive la vérification du
              courrier.
       MAILPATH
              Une liste de noms de fichiers séparés par des deux-points « : »,
              dans lesquels on vérifiera 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 de courrier actuel. Exemple :
              MAILPATH='/usr/spool/mail/bfox?"Vous avez du
              courrier":~/shell-mail?"$_ a du courrier !"'
              Bash peut être configurée pour fournir une valeur par défaut pour
              cette variable (il n'y a pas de valeur par défaut), mais
              l'emplacement du fichier de boîte à lettres dépend du système (par
              exemple /var/mail/$USER).
       OPTERR Si configurée à la valeur 1, bash affiche les messages d'erreurs
              engendrés par la commande interne getopts (consultez COMMANDES
              INTERNES DE L'INTERPRÉTEUR ci-dessous).  OPTERR est initialisée
              avec la valeur 1 à chaque appel de l'interpréteur ou au lancement
              d'un script.
       PATH   Le chemin de recherche des commandes à exécuter. Il s'agit d'une
              liste de répertoires, séparés par des deux-points « : » dans
              lesquels l'interpréteur recherche les commandes (consultez
              EXÉCUTION DES COMMANDES ci-dessous). Un nom de répertoire de
              taille nulle (NULL) dans la valeur de PATH désigne le répertoire
              actuel. Un répertoire NULL peut apparaître comme deux deux-points
              consécutifs ou comme des deux-points en début ou en fin. Le chemin
              par défaut dépend du système et est choisi par l'administrateur
              installant bash. Une valeur commune est
              ``/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin''.
       POSIXLY_CORRECT
              Si cette variable existe dans l'environnement lorsque bash
              démarre, l'interpréteur passe en mode POSIX avant de lire les
              fichiers d’initialisation comme si l'option --posix avait été
              fournie. Si elle est créée pendant que l'interpréteur est en cours
              d'exécution, bash active le mode POSIX comme si la commande set -o
              posix a été exécutée. Quand l'interpréteur passe en mode POSIX, il
              configure cette variable si elle ne l'a pas déjà été.
       PROMPT_COMMAND
              Si cette variable existe et est un tableau, la valeur de chaque
              élément existant est exécutée comme commande préalablement à
              l'affichage de chaque invite de base. Si elle existe mais n'est
              pas une variable de type tableau, sa valeur est utilisée comme
              commande à exécuter à la place.
       PROMPT_DIRTRIM
              Si elle contient un nombre supérieur à zéro, cette valeur est
              utilisée comme nombre de répertoires finaux à conserver lors du
              développement des protections de chaîne d'invite \w et \W
              (consultez INVITES ci-dessous). Les caractères supprimés sont
              remplacés par une ellipse.
       PS0    La valeur de ce paramètre est développée (consultez INVITES
              ci-dessous) puis affichée par les interpréteurs interactifs après
              la lecture d'une commande et avant son exécution.
       PS1    La valeur de ce paramètre est développée puis utilisée comme
              chaîne d'invite de base (consultez INVITES ci-dessous). La valeur
              par défaut est « \s-\v\$  ».
       PS2    La valeur de ce paramètre est développée comme PS1 puis utilisée
              comme chaîne d'invite secondaire. La valeur par défaut est « >  ».
       PS3    La valeur de ce paramètre est utilisée comme invite de la commande
              select (consultez GRAMMAIRE DE L'INTERPRÉTEUR ci-dessus).
       PS4    La valeur de ce paramètre est développée comme PS1 puis affichée
              avant chaque commande affichée par bash lors d'un suivi
              d'exécution. Le premier caractère de PS4 est répété autant de fois
              que nécessaire pour indiquer le niveau d'imbrication. La valeur
              par défaut est « +  ».
       SHELL  Cette variable développe le chemin d'accès complet à
              l'interpréteur de commandes. Si elle est inexistante au démarrage
              de l'interpréteur, bash lui affecte le chemin d'accès complet à
              l'interpréteur de commandes de connexion de l'utilisateur actuel.
       TIMEFORMAT
              La valeur de ce paramètre est utilisée en tant que chaîne de
              format indiquant comment les informations de paramétrage doivent
              être affichées pour les pipelines précédés du mot réservé time. Le
              caractère % introduit une suite de caractères de protection qui
              est développée en valeur de temps ou autre information. Les suites
              de caractères de protection et leurs significations sont les
              suivantes ; les crochets marquent les parties facultatives.
              %%        Un % seul (non interprété).
              %[p][l]R  Le temps écoulé en seconde.
              %[p][l]U  Le temps processeur écoulé en mode utilisateur en
                        seconde.
              %[p][l]S  Le temps processeur écoulé en mode système en seconde.
              %P        Le pourcentage de temps processeur utilisé calculé avec
                        (%U + %S) / %R.

              Le p facultatif est un chiffre indiquant la précision, le nombre
              de chiffres après la virgule. Une valeur de 0 conduit à affichage
              de nombres entiers. Trois chiffres au plus peuvent être affichés
              après la virgule ; toute valeur supérieure à 3 sera modifiée en 3.
              Si p n'est pas précisé, la valeur 3 est utilisée.

              Le l facultatif indique un format plus long, incluant les minutes,
              de la forme MMmSS.DDs. La valeur de p détermine si la partie
              décimale est affichée ou non.

              Si cette variable n'existe pas, bash agit comme si elle avait la
              valeur $'\nreal\t%3lR\nuser\t%3lU\nsys\t%3lS'. Si la valeur est
              NULL, aucune information de chronométrage n'est affichée. Un
              caractère final de changement de ligne est ajouté quand la chaîne
              de format est affichée.
       TMOUT  Si configurée en valeur strictement positive, TMOUT est traitée
              comme le délai par défaut pour la commande interne read. La
              commande select se termine s'il n'y a pas de saisie au bout de
              TMOUT secondes lorsque l'entrée vient d'un terminal. Dans un
              interpréteur interactif, la valeur est interprétée comme une durée
              en seconde à attendre une ligne de saisie après avoir affiché
              l'invite de base. Bash se termine après avoir attendu pendant ce
              temps en seconde si aucune saisie de ligne complète n'est arrivée.
       TMPDIR Si existante, bash utilise sa valeur comme nom de répertoire dans
              lequel bash crée les fichiers temporaires nécessaires au
              fonctionnement de l'interpréteur.
       auto_resume
              Cette variable commande le comportement de l'interpréteur
              vis-à-vis de l'utilisateur et du contrôle des tâches. Si cette
              variable existe, les commandes simples constituées d'un seul mot,
              sans redirection, sont considérées comme de possibles relances de
              tâches suspendues. Aucune ambiguïté n'est possible, si plusieurs
              tâches commencent par la chaîne saisie, la tâche à laquelle il a
              été accédé le plus récemment est sélectionnée. Le nom d'une tâche
              suspendue, dans ce contexte, est la ligne de commande utilisée
              pour la lancer. Si configurée à la valeur exact, la chaîne fournie
              doit correspondre exactement au nom d'une tâche suspendue ; si
              configurée à substring, la chaîne fournie doit correspondre à une
              sous-chaîne du nom de la tâche suspendue. La valeur substring
              donne une fonctionnalité analogue à l'identificateur de tâche %?
              (consultez CONTRÔLE DES TÂCHES ci-dessous). Si configurée à toute
              autre valeur, la chaîne fournie doit être le préfixe du nom d'une
              tâche suspendue ; cela fournit une fonctionnalité analogue à
              l'identificateur de tâche %string.
       histchars
              Les deux ou trois caractères commandant le développement de
              l'historique et le découpage en lexèmes (consultez DÉVELOPPEMENT
              DE L'HISTORIQUE ci-dessous). Le premier caractère est le caractère
              de développement de l'historique, celui qui indique le début d'un
              développement d'historique (normalement « ! »). Le second
              caractère est celui de substitution rapide, utilisé comme
              raccourci pour relancer la commande précédente, en modifiant une
              partie de la chaîne (par défaut « ^ »). Le troisième caractère
              facultatif est celui qui indique, lorsqu'on le trouve en début de
              mot que le reste de la ligne est un commentaire (normalement
              « # »). Ce caractère de commentaire empêche le développement de
              l'historique pour tous les mots restants sur la ligne. Il ne
              conduit pas nécessairement l'analyseur de l'interpréteur à
              considérer le reste de la ligne comme un commentaire.

   Tableaux
       Bash fournit des variables de type tableau indicé ou associatif, à une
       dimension. Toute variable peut être utilisée comme tableau indicé ; la
       commande interne declare peut servir à déclarer explicitement un tableau.
       Il n'y a pas de limitation maximale à la taille d'un tableau, ni
       d'obligation à indicer les éléments ou les affecter de façon contiguë.
       Les tableaux indicés sont consultés avec des entiers (évaluations
       arithmétiques comprises) commençant à zéro ; les tableaux associatifs
       sont consultés avec des chaînes arbitraires. Sauf mention contraire, les
       indices de tableaux indicés ne doivent pas être des entiers négatifs.

       Un tableau indicé est créé automatiquement si une variable quelconque est
       affectée en utilisant la syntaxe nom[indice]=valeur. L'indice est traité
       comme une expression arithmétique et doit s'évaluer en un nombre. declare
       -a nom permet de déclarer explicitement un tableau indicé (consultez
       COMMANDES INTERNES DE L'INTERPRÉTEUR ci-dessous). declare -a nom[indice]
       est aussi accepté ; l'indice est ignoré.

       Les tableaux associatifs sont créés en utilisant declare -A nom.

       Des attributs peuvent être indiqués pour une variable tableau en
       utilisant les commandes internes declare et readonly. Les attributs
       s'appliquent à tous les éléments d'un tableau.

       Les tableaux sont affectés en utilisant l'affectation composée de la
       forme nom=(valeur_1 ... valeur_n), où chaque valeur peut être de la forme
       [indice]=chaîne. Les affectations de tableau indicé ne nécessitent rien
       d’autre que chaîne. Chaque valeur de la liste est développée en utilisant
       tous les développements de l'interpréteur décrits ci-dessous dans
       DÉVELOPPEMENTS. Lors de l'affectation de tableaux indicés, si les
       crochets et les indices facultatifs sont fournis, les affectations ont
       lieu en conséquence ; sinon l'indice de l'élément affecté est le dernier
       indice affecté plus un. L'indexation commence à zéro.

       Lors de l'affectation à un tableau associatif, les mots d'une affectation
       composée peuvent être soit des affectations pour lesquelles un indice est
       requis, soit une liste de mots qui est interprétée comme une séquence
       alternant clés et valeurs : nom=( clé1 valeur1 clé2 valeur2 ...). Elles
       sont traitées de la même manière que nom=( [clé1]=valeur1 [clé2]=valeur2
       ...). Le premier mot de la liste détermine comment les autres mots sont
       interprétés ; toutes les affectations d'une liste doivent être du même
       type. Lors de l'utilisation de paires clé/valeur, les clés ne peuvent pas
       être absentes ou vides ; une valeur finale absente est traitée comme une
       chaîne vide.

       Cette syntaxe est aussi acceptée par la commande interne declare. Les
       éléments individuels du tableau sont affectés en utilisant la syntaxe
       nom[indice]=valeur présentée ci-dessus. Lors de l’affectation vers un
       tableau indicé, si nom est indicé avec un nombre négatif, ce nombre est
       considéré comme ajouté à l'indice maximal de nom plus un, ainsi, un
       indice négatif compte à rebours depuis la fin du tableau et un indice -1
       fait référence au dernier élément du tableau.

       Tout élément d'un tableau est accessible avec la notation ${nom[indice]}.
       Les accolades sont nécessaires pour éviter les conflits avec le
       développement des chemins. Si indice est @ ou *, le mot se développe en
       tous les éléments de nom. Ces deux indices ne diffèrent que lorsque le
       mot apparaît entre guillemets doubles. Si le mot est entre guillemets
       doubles, ${nom[*]} se développe en un seul mot contenant les valeurs de
       chaque élément du tableau séparées par le premier caractère de la
       variable spéciale IFS et ${nom[@]} développe chaque élément de nom en un
       mot distinct. Quand il n'y a pas d'élément dans le tableau, ${nom[@]} ne
       se développe en rien. Si le développement entre guillemets doubles
       survient à l'intérieur d'un mot, le développement du premier paramètre
       est accolé à la première partie du mot original et le développement du
       dernier paramètre est accolé à la dernière partie du mot original. Le
       comportement est analogue à celui des paramètres spéciaux * et @
       (consultez Paramètres spéciaux ci-dessus). ${#nom[indice]} s'évalue en
       longueur de l'élément ${nom[indice]}. Si l'indice est * ou @, il s'évalue
       en nombre d'éléments dans le tableau. Si l'indice utilisé pour référencer
       un élément de tableau indicé s'évalue en un nombre négatif, il est
       considéré comme ajouté à l'indice maximal du tableau plus un, ainsi, un
       indice négatif compte à rebours depuis la fin du tableau et un indice -1
       fait référence au dernier élément du tableau.

       Le référencement d'une variable tableau sans indice est équivalent au
       référencement d'un tableau avec un indice de 0. Toute référence à une
       variable utilisant un indice valable est légale et bash créera un tableau
       si nécessaire.

       Une variable tableau est considérée configurée si une valeur a été
       affectée à un indice. La chaîne NULL est une valeur possible.

       Les clefs (indices) d’un tableau peuvent être aussi bien obtenues que les
       valeurs. ${!nom[@]} et ${!nom[*]} se développent en indices assignés dans
       la variable tableau nom. Le traitement entre guillemets doubles est
       similaire au développement des paramètres spéciaux @ et * entre
       guillemets doubles.

       La commande interne unset sert à détruire les tableaux. unset nom[indice]
       détruit l'élément de tableau d'indice indice, pour à la fois les tableaux
       indicés et les tableaux associatifs. Les indices négatifs des tableaux
       indicés sont traités comme décrit précédemment. Supprimer le dernier
       élément d'une variable tableau ne détruit pas la variable. unset nom, où
       nom est un tableau, ou unset nom[indice], avec indice valant * ou @
       supprime le tableau entier.

       Lors de l'utilisation d'un nom de variable avec un indice comme argument
       d'une commande comme avec unset, sans utiliser la syntaxe des
       développements de mots décrite précédemment, l'argument est sujet au
       développement de chemin. Si le développement de chemin n'est pas
       souhaité, l'argument doit être protégé.

       Les commandes internes declare, local et readonly acceptent toutes une
       option -a pour préciser un tableau indicé et une option -A pour préciser
       un tableau associatif. Si les deux options sont fournies, -A est
       prioritaire. La commande interne read accepte une option -a pour affecter
       une liste de mots lus depuis l'entrée standard dans un tableau. Les
       commandes internes set et declare affichent les valeurs d'un tableau
       d'une façon qui permet de les réutiliser pour des affectations.

DÉVELOPPEMENTS
       Les développements sont appliqués à la ligne de commande après avoir été
       découpée en mots. Sept types de développements sont effectués : le
       développement des accolades, le développement du tilde, le développement
       des paramètres et des variables, la substitution de commande, le
       développement arithmétique, le découpage en mots et le développement des
       chemins.

       L'ordre des développements est : développement des accolades ;
       développement du tilde, des paramètres, des variables et arithmétique, et
       substitution de commande (effectuée de la gauche vers la droite) ;
       découpage en mots ; et développement des chemins.

       Sur les systèmes qui le permettent, un développement supplémentaire a
       lieu : la substitution de processus. Il est réalisé en même temps que le
       développement du tilde, des paramètres, des variables et arithmétique, et
       que la substitution de commande.

       Après la réalisation de ces développements, les caractères de protection
       présents dans le mot original sont supprimés à moins qu'ils n'aient été
       protégés eux-mêmes (suppression des protections)

       Seuls le développement des accolades, le découpage en mots et le
       développement des chemins peuvent modifier le nombre de mots. Les autres
       développements transforment un mot unique en un autre mot unique. La
       seule exception à cette règle est le développement de « $@ » et
       « ${nom[@]} », ainsi que, dans la plupart des cas, $* et ${name[*]} comme
       expliqué précédemment (consultez PARAMÈTRES).

   Développement des accolades
       Le développement des accolades est un mécanisme permettant de produire
       des chaînes quelconques. Il est similaire au développement des chemins,
       mais les noms de fichiers produits n'existent pas nécessairement. Les
       motifs qui seront développés prennent la forme d'un préambule facultatif,
       suivi soit par une série de chaînes séparées par des virgules, soit par
       l'expression d'une série entre accolades, et suivi par un post-scriptum
       facultatif. Le préambule est inséré devant chacune des chaînes contenues
       entre les accolades et le post-scriptum est concaténé à 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
       résultats de chaque développement ne sont pas triés, l'ordre de gauche à
       droite est conservé. Par exemple a{d,c,b}e se développe en « ade ace
       abe ».

       Une expression de série est de la forme {x..y[..incr]}, où x et y sont
       soit des entiers, soit des caractères uniques, et incr, un incrément
       facultatif, est un entier. Lorsqu'il s'agit d'entiers, l'expression est
       remplacée par la liste des nombres entre x et y inclus. Les entiers
       fournis peuvent être préfixés par 0 pour forcer chaque terme à avoir la
       même longueur. Si x ou y commencent par un zéro, l'interpréteur essaiera
       de forcer tous les termes créés à la même longueur, en ajoutant des zéros
       au besoin. S'il s'agit de caractères, l'expression se développe en
       l’ensemble des caractères situés entre x et y, inclus, d'un point de vue
       lexicographique en utilisant les paramètres régionaux par défaut de C.
       Remarquez que x et y doivent être du même type. Si l'incrément est
       fourni, il est utilisé comme différence entre chaque terme. L'incrément
       par défaut est 1 ou -1 suivant les valeurs de x et y.

       Le développement des accolades est effectué avant tout autre
       développement et tous les caractères ayant une signification spéciale
       pour les autres développements 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.

       Un développement d'accolades correctement formé doit contenir des
       accolades ouvrante et fermante non protégées et au moins une virgule non
       protégée ou une expression de série correcte. Tout développement
       d'accolades incorrectement formé est laissé inchangé. Un { ou un ,
       peuvent être protégés par une contre-oblique pour éviter d'être
       considérés comme partie d'une expression entre accolades. Pour éviter
       tout conflit avec le développement des paramètres, la chaîne ${ n'est pas
       considérée comme éligible au développement des accolades, et empêche le
       développement d'accolades jusqu'au } fermant.

       Cette construction est typiquement utilisée comme raccourci lorsque le
       préfixe commun aux chaînes à engendrer est plus long que dans les
       exemplesprécédents :

              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 historiques de sh. sh n'effectue aucun traitement sur les
       accolades ouvrantes et fermantes lorsqu'elles apparaissent dans un mot et
       les laisse inchangées. Bash supprime les accolades dans les mots, après
       développement. Par exemple, si le mot file{1,2} est fourni à sh, il reste
       inchangé en sortie. En revanche, il est transformé en file1 file2 par
       bash. Si une compatibilité stricte avec sh est nécessaire, lancez bash
       avec l'option +B ou désactivez le développement des accolades avec
       l'option +B de la commande set (consultez COMMANDES INTERNES DE
       L'INTERPRÉTEUR ci-dessous).

   Développement du tilde
       Si un mot commence par un caractère tilde (« ~ ») non protégé, tous les
       caractères précédant la première barre oblique non protégée (voire tous
       les caractères s'il n'y a pas de barre oblique non protégée), sont
       considérés comme un préfixe tilde. Si aucun caractère du préfixe tilde
       n'est protégé, les caractères suivant le tilde sont traités comme un
       identifiant de connexion possible. Si cet identifiant de connexion est la
       chaîne NULL, le tilde est remplacé par la valeur du paramètre
       d'interpréteur HOME. Si HOME n'existe pas, le répertoire d'accueil de
       l'utilisateur exécutant l'interpréteur est utilisé à la place. Sinon le
       préfixe tilde est remplacé par le répertoire d'accueil associé à
       l'identifiant de connexion indiqué.

       Si le préfixe tilde est « ~+ », la valeur de la variable de
       l'interpréteur PWD le remplace. Si le préfixe tilde est « ~- », la valeur
       de la variable de l'interpréteur OLDPWD, si existante, lui est
       substituée. Si les caractères à la suite du tilde dans le préfixe tilde
       représentent un nombre N préfixé facultativement par un « + » ou un « - »
       le préfixe tilde est remplacé par l'élément correspondant de la pile de
       répertoires telle qu'il serait affiché par la commande interne dirs
       appelée avec le préfixe tilde en argument. Si les caractères à la suite
       du tilde dans le préfixe tilde représentent un nombre sans un « + » ou
       « - » en tête, on suppose qu'il s'agit de « + ».

       Si l'identifiant de connexion est incorrect ou si le développement du
       tilde échoue, le mot est inchangé.

       Chaque affectation de variable vérifie immédiatement la présence de
       préfixes tilde non protégés suivant un : ou le premier =. Dans ces cas,
       le développement des tildes est aussi effectué. On peut donc utiliser des
       noms de fichiers avec des tildes dans des affectations de PATH, MAILPATH
       et CDPATH et l'interpréteur affectera la valeur développée.

       Bash effectue aussi le développement des tildes sur les mots satisfaisant
       les conditions d'affectations de variable (comme décrit précédemment dans
       PARAMÈTRES) quand elles apparaissent comme arguments de commandes
       simples. Bash ne le fait pas en mode POSIX sauf pour les commandes de
       déclaration listées ci-dessus.

   Remplacement des paramètres
       Le caractère « $ » permet d'introduire le développement des paramètres,
       la substitution de commande ou le développement arithmétique. Le nom du
       paramètre ou du symbole à développer peut être encadré par des accolades
       facultatives mais permettant d'éviter le développement de la variable à
       partir de caractères la suivant immédiatement et qui pourraient être
       considérés comme appartenant à son nom.

       Lorsque les accolades sont utilisées, l'accolade de fin correspondante
       est le premier caractère « } » ni protégé par une contre-oblique, ni
       inclus dans une chaîne protégée, un développement arithmétique, une
       substitution de commande ou un développement des paramètres.

       ${paramètre}
              est remplacé par la valeur du paramètre. Les accolades sont
              nécessaires quand le paramètre est un paramètre positionnel ayant
              plusieurs chiffres, ou si le paramètre est suivi de caractères
              n'appartenant pas à son nom. Le paramètre est un paramètre
              d’interpréteur (comme décrit précédemment dans PARAMÈTRES) ou une
              référence de tableau (Tableaux).

       Si le premier caractère du paramètre est un point d'exclamation (!), et
       si le paramètre n'est pas un nameref, il introduit un niveau
       d'indirection de variable. Bash utilise la valeur formée par le
       développement du reste du paramètre en tant que nouveau paramètre. Cette
       variable est alors développée et la valeur utilisée pour le reste du
       développement plutôt que le développement du paramètre original. On
       appelle ce mécanisme le développement indirect. La valeur est sujette au
       développement de tildes et de paramètres, à la substitution de commande
       ou au développement arithmétique. Si le paramètre est un nameref, le
       développement porte sur le nom du paramètre référencé par le paramètre
       plutôt que sur le développement indirecte complet. Les exceptions à cela
       sont les développements de ${!préfixe*} et de ${!nom[@]} décrits
       ci-dessous. Le point d'exclamation doit immédiatement suivre l'accolade
       ouvrante afin d'introduire l'indirection.

       Dans chacun des cas ci-dessous, le mot est soumis au développement de
       tilde, au développement des paramètres, à la substitution de commande et
       au développement arithmétique.

       Quand il n'effectue pas de développement de sous-chaîne, en utilisant les
       formes documentées ci-dessous (par exemple :-), bash teste si le
       paramètre est inexistant ou NULL. L'absence de deux-points induit un test
       sur la seule inexistence du paramètre.

       ${paramètre:-mot}
              Utilisation de valeur par défaut. Si le paramètre est inexistant
              ou NULL, le développement du mot est substitué. Sinon, c'est la
              valeur du paramètre qui est substituée.
       ${paramètre:=mot}
              Affectation de valeur par défaut. Si le paramètre est inexistant
              ou NULL, le développement du mot lui est affecté. La valeur du
              paramètre est alors substitué. Les paramètres positionnels et
              spéciaux ne peuvent pas être affectés de cette façon.
       ${paramètre:?mot}
              Affichage d'erreur si NULL ou inexistant. Si le paramètre est
              inexistant ou NULL, 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 termine, s'il n'est pas
              interactif. Sinon, la valeur du paramètre est substituée.
       ${paramètre:+mot}
              Utilisation de valeur alternative. Si le paramètre est NULL ou
              inexistant, rien n'est substitué. Sinon le développement du mot
              est substitué.
       ${paramètre:début}
       ${paramètre:début:longueur}
              Développement des sous-chaînes. Se développe pour fournir la
              sous-chaîne de longueur indiquée (en caractère) commençant au
              début. Si le paramètre est @, un tableau indicé par @ ou *, ou un
              nom de tableau associatif, le résultat diffère comme décrit
              ci-dessous. Si la longueur est omise, fournit la sous-chaîne
              commençant au caractère indiqué par début et s'étendant jusqu'à la
              fin de la valeur. La longueur et le début sont des expressions
              arithmétiques (consultez ÉVALUATION ARITHMÉTIQUE ci-dessous).

              Si le début est négatif, sa valeur est considérée à partir de la
              fin du contenu du paramètre. Si longueur est négatif, sa valeur
              est considérée comme une position en caractère à partir de la fin
              de la valeur du paramètre plutôt que comme un nombre de
              caractères, et le développement est constitué des caractères entre
              le début et cette position. Remarquez que les positions négatives
              doivent être séparées des deux-points par au moins une espace pour
              éviter d’être confondues avec le développement de :-.

              Si le paramètre est @, le résultat correspond à longueur
              paramètres positionnels commençant au début. Une valeur négative
              de début est considérée relative au plus grand paramètre
              positionnel plus un (ainsi un indice -1 fait référence au dernier
              paramètre positionnel). C’est une erreur de développement si
              longueur est évaluée en nombre négatif.

              Si le paramètre est un nom de tableau indicé par @ ou *, le
              résultat est les longueur éléments du tableau commençant à
              ${paramètre[début]}. Une valeur négative de début est prise
              relativement à la valeur maximale de l'indice du tableau considéré
              plus un. C’est une erreur de développement si longueur est évaluée
              en nombre négatif.

              Le développement de sous-chaîne appliqué à un tableau associatif
              produit des résultats non définis.

              L'indexation des sous-chaînes commence à zéro, sauf pour les
              paramètres positionnels pour lesquels l'indexation commence à 1
              par défaut. Si début est 0, et que les paramètres positionnels
              sont utilisés, la liste est préfixée par $0.

       ${!préfixe*}
       ${!préfixe@}
              Noms correspondant au préfixe. Se développe en noms des variables
              dont les noms commencent par préfixe, séparés par le premier
              caractère de la variable spéciale IFS. Si @ est utilisé et que le
              développement apparaît entre guillemets doubles, chaque nom de
              variable se développe séparément.

       ${!nom[@]}
       ${!nom[*]}
              Liste des clefs du tableau. Si nom est une variable de type
              tableau, elle se développe en liste des indices (clefs) du tableau
              affecté à nom. Si nom n'est pas un tableau, se développe en 0 si
              nom existe et en NULL sinon. Quand @ est utilisé et que le
              développement apparaît entre guillemets doubles, chaque clef se
              développe en un mot séparé.

       ${#paramètre}
              Longueur du paramètre. Est remplacé par la longueur, en
              caractères, de la valeur du paramètre. Si le paramètre est * ou @,
              la valeur est le nombre de paramètres positionnels. Si le
              paramètre est un nom de tableau indicé par * ou @, la valeur
              donnée est le nombre d'éléments du tableau. Si le paramètre est un
              nom de tableau indicé par un nombre négatif, ce nombre est
              considéré comme ajouté à l'indice maximal de paramètre plus un
              (ainsi un indice négatif compte à rebours depuis la fin du tableau
              et un indice -1 fait référence au dernier élément).

       ${paramètre#mot}
       ${paramètre##mot}
              Retrait du motif correspondant au préfixe. Le mot est développé
              pour fournir un motif, comme dans le développement des chemins et
              mis en correspondance avec la valeur développée du paramètre avec
              les règles décrites dans Motifs génériques ci-dessous. Si le motif
              correspond au début de la valeur du paramètre, alors le
              développement prend la valeur développée du paramètre après
              suppression du plus court (cas « # ») ou du plus long (cas « ## »)
              motif correspondant. Si le paramètre est @ ou *, l'opération de
              suppression de motif est appliquée à chaque paramètre positionnel
              tour à tour et le développement est la liste résultante. Si le
              paramètre est une variable tableau indicée par @ ou *, l'opération
              de suppression de motif est appliquée à chaque élément du tableau
              tour à tour et le développement est la liste résultante.

       ${paramètre%mot}
       ${paramètre%%mot}
              Retrait du motif correspondant au suffixe. Le mot est développé
              pour fournir un motif, comme dans le développement des chemins et
              mis en correspondance avec la valeur développée du paramètre avec
              les règles décrites dans Motifs génériques ci-dessous. Si le motif
              correspond à une portion finale de la valeur développée du
              paramètre, alors le développement prend la valeur développée du
              paramètre après suppression du plus court (cas « % ») ou du plus
              long (cas « %% ») motif correspondant. Si le paramètre est @ ou *,
              l'opération de suppression de motif est appliquée à chaque
              paramètre positionnel tour à tour et le développement est la liste
              résultante. Si le paramètre est une variable tableau indicée par @
              ou *, l'opération de suppression de motif est appliquée à chaque
              élément du tableau tour à tour et le développement est la liste
              résultante.

       ${paramètre/motif/chaîne}
              Substitution de motif. Le motif est développé produire un motif
              comme dans le développement des chemins. Le paramètre est
              développé et la plus longue portion correspondant au motif est
              remplacée par la chaîne. La mise en correspondance est réalisée en
              utilisant les règles décrites dans Motifs génériques ci-dessous.
              Si le motif commence par /, toutes les correspondances au motif
              sont remplacées par la chaîne. Normalement, seule la première
              correspondance est remplacée. Si le motif commence par #, il doit
              correspondre au début de la valeur développée du paramètre. Si le
              motif commence par %, il doit correspondre à la fin du
              développement du paramètre. Si la chaîne est NULL, les portions
              correspondant au motif sont supprimées et le / suivant le motif
              peut être omis. Si l'option d'interpréteur nocasematch est
              activée, la mise en correspondance est réalisée sans tenir compte
              de la casse des caractères alphabétiques. Si le paramètre est @ ou
              *, l'opération de substitution est appliquée à chacun des
              paramètres positionnels tour à tour et le développement est la
              liste résultante. Si le paramètre est une variable tableau indicée
              par @ ou *, l'opération de substitution s'applique à chaque
              élément du tableau tour à tour et le développement est la liste
              résultante.

       ${paramètre^motif}
       ${paramètre^^motif}
       ${paramètre,motif}
       ${paramètre,,motif}
              Modification de la casse. Ce développement modifie la casse des
              caractères alphabétiques du paramètre. Le motif est développé pour
              fournir un motif, comme dans le développement des chemins. Chaque
              caractère de la valeur développée du paramètre est testé par
              rapport au motif et, en cas de correspondance, sa casse est
              convertie. Le motif ne devrait pas essayer de correspondre à plus
              d’un caractère. L'opérateur ^ convertit les lettre minuscules
              correspondant à ce motif en majuscules ; l'opérateur , convertit
              les lettre majuscules correspondant à ce motif en minuscules. Les
              développements ^^ et ,, convertissent tous les caractères
              correspondant à leur valeur développée ; les développements ^ et ,
              convertissent seulement le premier caractère de la valeur
              développée correspondant. Si motif est omis, il est traité comme
              un ?, ce qui correspond à n'importe quel caractère. Si le
              paramètre est @ ou *, la modification de casse s'applique à chaque
              paramètre positionnel tour à tour et le développement est la liste
              résultante. Si le paramètre est une variable tableau indicée par @
              ou *, la modification de casse s'applique à chaque élément du
              tableau tour à tour et le développement est la liste résultante.

       ${paramètre@opérateur}
              Transformation de paramètre. Le développement est soit une
              transformation de la valeur du paramètre ou des informations sur
              paramètre lui-même, selon la valeur de opérateur. Chaque opérateur
              est une lettre unique :

              U      Le développement est une chaîne qui est la valeur de
                     l'argument avec des caractères alphabétiques en minuscule
                     convertis en majuscule.
              u      Le développement est une chaîne qui est la valeur de
                     l'argument avec son premier caractère converti en
                     majuscule, si c'est un caractère alphabétique.
              L      Le développement est une chaîne qui est la valeur de
                     l'argument avec les caractères alphabétiques en majuscule
                     convertis en minuscule.
              Q      Le développement est une chaîne qui est la valeur de
                     l'argument protégée dans un format réutilisable en entrée
                     de l'interpréteur.
              E      Le développement est une chaîne qui est la valeur du
                     paramètre avec des suites de caractères de protection par
                     contre-oblique développée comme avec le mécanisme de
                     protection $'...'.
              P      Le développement est une chaîne qui est le résultat du
                     développement de lavaleur du paramètre comme s'il
                     s'agissait d'une chaîne d'invite (consultez INVITES
                     ci-dessous).
              A      Le développement est une chaîne sous la forme d'une
                     affectation ou d'une commande declare qui, lorsqu'elle est
                     évaluée, recréera paramètre avec sa valeur et ses
                     attributs.
              K      Produit une version potentiellement protégée de la valeur
                     de l'argument, sauf qu'il affiche les valeurs des tableaux
                     indicés et associatifs comme une séquence de paires
                     clé/valeur protégées (consultez Tableaux ci-dessus).
              a      Le développement est une chaîne consistant en valeurs
                     d'indicateur représentant les attributs de paramètre.

              Si le paramètre est @ ou *, l'opération est appliquée à chaque
              paramètre positionnel tour à tour et le développement est la liste
              résultante. Si le paramètre est une variable tableau indicée par @
              ou *, l'opération est appliquée à chaque élément du tableau tour à
              tour et le développement est la liste résultante.

              Le résultat du développement est sujet au découpage en mots et au
              développement des chemins comme décrit ci-dessous.

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

              $(commande)
       ou
              `commande`

       Bash effectue le développement en exécutant la commande dans un
       environnement de sous-interpréteur et en remplaçant la substitution de
       commande par sa sortie standard dont les éventuels sauts de lignes finaux
       sont supprimés. Les changements de ligne internes ne sont pas supprimés
       mais peuvent disparaître lors du découpage en mots. La substitution de
       commande $(cat fichier) peut être remplacée par l'équivalent plus rapide
       $(< fichier).

       Quand l'ancienne forme de substitution avec les accents graves « ` » est
       utilisée, le caractère contre-oblique garde sa signification propre sauf
       lorsqu'il est suivi de $, ` ou \. Le premier accent grave non protégé par
       une contre-oblique termine la substitution de commande. Quand on utilise
       la forme $(commande), tous les caractères entre parenthèses constituent
       la commande ; aucun n'est traité spécifiquement.

       Les substitutions de commande peuvent être imbriquées. Pour imbriquer en
       utilisant la forme à accents graves, il faut protéger les accents graves
       internes avec des contre-obliques.

       Si la substitution apparaît entre guillemets doubles, le découpage en
       mots et le développement des chemins ne sont pas effectués sur ses
       résultats.

   Développement arithmétique
       Le développement arithmétique permet de remplacer une expression
       arithmétique par le résultat de son évaluation. Le format du
       développement arithmétique est :

              $((expression))

       L'expression est traitée comme si elle était entre guillemets doubles,
       mais un guillemet double à l'intérieur de parenthèses n'est pas traité
       spécifiquement. Tous les lexèmes dans l'expression sont sujets au
       développement des paramètres et des variables, à la substitution de
       commande et à la suppression des protections. Le résultat est traité
       comme l’expression arithmétique à évaluer. Les développements
       arithmétiques peuvent être imbriqués.

       L'évaluation est effectuée en suivant les règles décrites ci-dessous dans
       ÉVALUATION ARITHMÉTIQUE. Si l'expression est incorrecte, bash affiche un
       message indiquant l'échec et aucune substitution n'a lieu.

   Substitution de processus
       La substitution de processus permet à une entrée ou une sortie d'un
       processus d’être référencée en utilisant un nom de fichier. Elle prend la
       forme <(liste) ou >(liste). La liste de processus est exécutée de façon
       asynchrone est son entrée ou sortie apparaît comme un nom de fichier. Le
       nom de ce fichier est passé en argument à la commande actuelle comme
       résultat de ce développement. Si on utilise la forme >(liste), le fichier
       passé en argument devra être lu pour obtenir la sortie de la liste. La
       substitution de processus est prise en charge sur les systèmes acceptant
       le mécanisme des tubes nommés (FIFO) ou la méthode /dev/fd de nommage de
       fichiers ouverts.

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

   Découpage en mots
       Les résultats du développement des paramètres, de la substitution de
       commande et du développement arithmétique qui ne se trouvent pas entre
       guillemets doubles sont analysés par l'interpréteur afin d'appliquer le
       découpage en mots.

       L'interpréteur considère chaque caractère du paramètre IFS comme un
       délimiteur et découpe le résultat des autres développements en mots
       utilisant ces caractères comme terminaisons de champ. Si IFS est
       inexistante ou si sa valeur est exactement
       <espace><tab><changement_de_ligne>, la valeur par défaut, alors les
       suites de caractères <espace>, <tab> et <changement_de_ligne> au début ou
       à la fin du résultat des développements précédents sont ignorés, et toute
       suite de caractères de IFS ni au début ni à la fin sert à délimiter les
       mots. Si IFS a une valeur autre que celle par défaut, alors les suites de
       caractères blancs espace et tabulation et changement_de_ligne sont
       ignorées en début et fin de mot, à condition que ces caractères blancs se
       trouvent dans la valeur de IFS (un caractère blanc de IFS). Tout
       caractère de IFS qui n'est pas un caractère blanc, se trouvant à côté
       d'un caractère blanc de IFS, délimite un champ. Une suite de caractères
       blancs de IFS est également traitée comme un délimiteur. Si la valeur de
       IFS est NULL, aucun découpage en mots n'a lieu.

       Les arguments NULL explicites ("" ou '') sont conservés et passés à des
       commandes comme chaînes vides. Les arguments NULL implicites non
       protégés, résultant du développement des paramètres qui n'ont pas de
       valeurs, sont supprimés. Si un paramètre sans valeur est développé entre
       guillemets doubles, le résultat est un argument NULL qui est conservé et
       passé à une commande comme une chaîne vide. Quand un argument NULL
       protégé apparaît comme appartenant à un mot dont l'expansion n'est pas
       NULL, l'argument NULL est supprimé. C'est-à-dire que le mot -d'' devient
       -d après le découpage en mots et le retrait de l'argument NULL.

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

   Développement des chemins
       Après le découpage en mots, à moins que l'option -f soit présente, 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 fichier correspondant à ce
       motif (consultez Motifs génériques ci-dessous). Si aucun nom de fichier
       ne correspond et si l'option d'interpréteur nullglob n'est pas activée,
       le mot reste inchangé. Si l'option nullglob existe et si aucune
       correspondance n'est trouvée, le mot est supprimé. Si l'option
       d'interpréteur failglob existe et si aucune correspondance n'est trouvée,
       un message d'erreur est affiché et la commande n'est pas exécutée. Si
       l'option d'interpréteur nocaseglob est activée, la correspondance est
       effectuée sans tenir compte de la casse des caractères alphabétiques.
       Quand un motif est utilisé pour le développement des chemins, le
       caractère « . » au début d'un nom ou immédiatement à la suite d'une barre
       oblique doit être explicitement mis en correspondance, à moins que
       l'option d'interpréteur dotglob n'existe. Les noms de fichier « . » et
       « .. » doivent toujours être explicitement mis en correspondance, même si
       l'option dotglob existe. Dans les autres cas, le caractère « . » n'est
       pas traité spécifiquement. Lors de la correspondance avec un chemin, le
       caractère barre oblique doit toujours être mis en correspondance
       explicitement par une barre oblique dans le motif, mais dans les autres
       contextes de correspondance, il peut être mis en correspondance par un
       caractère de motif spécial comme décrit ci-dessous dans Motifs
       génériques. Voyez la description de la commande shopt dans COMMANDES
       INTERNES DE L'INTERPRÉTEUR pour une description des options
       d'interpréteur nocaseglob, nullglob, failglob et dotglob.

       La variable de l'interpréteur GLOBIGNORE peut servir à restreindre
       l'ensemble des noms de fichiers correspondant à un motif. Si GLOBIGNORE
       existe, chaque nom de fichier qui correspond aussi à un motif de
       GLOBIGNORE est supprimé de la liste des correspondances. Si l'option
       nocaseglob existe, la mise en correspondance avec les motifs dans
       GLOBIGNORE est réalisée sans tenir compte de la casse. Les noms de
       fichiers « . » et « .. » sont toujours ignorés quand GLOBIGNORE existe et
       n'est pas NULL. Toutefois, configurer GLOBIGNORE avec une valeur non NULL
       a pour effet d'activer l'option d'interpréteur dotglob, ainsi tous les
       autres noms de fichiers commençant par « . » correspondront. Pour obtenir
       l'ancien comportement ignorant les noms commençant par « . », placez
       « .* » dans l'un des motifs de GLOBIGNORE. L'option dotglob est
       désactivée si la variable GLOBIGNORE est inexistante. La correspondances
       de motifs respecte la configuration de l'option d'interpréteur extglob.

       Motifs génériques

       Tout caractère apparaissant dans un motif, hormis les caractères spéciaux
       décrits ci-dessous, correspond à lui-même. Le caractère NUL ne peut pas
       se trouver dans un motif. Une contre-oblique protège le caractère qui la
       suit ; la contre-oblique de protection est supprimée lors de la recherche
       de correspondance. Les caractères spéciaux de motifs doivent être
       protégés s'ils sont destinés à une correspondance littérale.

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

              *      Correspond à n'importe quelle chaîne, y compris la chaîne
                     NULL. Si l'option globstar de l'interpréteur est activée,
                     et que * est utilisé dans un contexte de développement des
                     chemins, deux * adjacents sont utilisés pour un seul motif
                     correspondant à tous les fichiers et zéro ou plus de
                     répertoires et sous-répertoires. Lorsqu'il sont suivis de
                     /, deux * adjacents correspondront seulement aux
                     répertoires et sous-répertoires.
              ?      Correspond à n'importe quel caractère.
              [...]  Correspond à tout caractère entre les crochets. Un couple
                     de caractères séparés par un trait d'union indique une
                     expression d’intervalle ; tout caractère qui correspond à
                     n'importe quel caractère situé entre les deux bornes
                     incluses, en utilisant les suites de collations et le jeu
                     de caractères des paramètres linguistiques régionaux
                     actuels, est capturé. Si le premier caractère suivant le [
                     est un ! ou un ^ alors la correspondance se fait sur tous
                     les caractères hors intervalle. L'ordre de tri des
                     caractères dans les expressions d’intervalle est déterminé
                     par les paramètres linguistiques régionaux actuels et par
                     les valeurs des variables de l'interpréteur LC_COLLATE et
                     LC_ALL si existantes. Pour obtenir l’interprétation
                     traditionnelle des expressions d’intervalle, où [a-d] est
                     équivalent à [abcd], configurez la valeur de la variable
                     d’interpréteur LC_ALL à C ou activez l’option
                     d’interpréteur globasciiranges. Un - peut faire partie du
                     motif de correspondance à condition d’être le premier ou le
                     dernier caractère de l'ensemble. Un ] peut faire partie du
                     motif de correspondance à condition d’être le premier
                     caractère de l'ensemble.

                     Entre [ et ], on peut indiquer une classe de caractère en
                     utilisant la syntaxe [:classe:], où classe est l'une des
                     classes suivantes, définies dans la norme POSIX :
                     alnum alpha ascii blank cntrl digit graph lower print punct
                     space upper word xdigit
                     Une classe correspond à n'importe quel caractère qui s'y
                     trouve. La classe de caractères word correspond aux
                     lettres, aux chiffres et au caractère souligné « _ ».

                     Entre [ et ], on peut indiquer une classe d'équivalence en
                     utilisant la syntaxe [=c=] qui correspond à n'importe quel
                     caractère ayant le même poids de collation (comme indiqué
                     par les paramètres linguistiques régionaux actuels) que le
                     caractère c.

                     Entre [ et ], la syntaxe [.symbole.] correspond au symbole
                     de collation symbole.

       Si l'option extglob d'interpréteur est activée par la commande interne
       shopt plusieurs opérateurs de correspondance étendue sont reconnus. Dans
       la description suivante, une liste-motif est une liste d'un ou plusieurs
       motifs séparés par des |. Les motifs composés sont formés en utilisant un
       ou plusieurs sous-motifs comme suit :

              ?(liste-motif)
                     Correspond à zéro ou une occurrence des motifs indiqués.
              *(liste-motif)
                     Correspond à zéro ou plusieurs occurrences des motifs
                     indiqués.
              +(liste-motif)
                     Correspond à une ou plusieurs occurrences des motifs
                     indiqués.
              @(liste-motif)
                     Correspond à une occurrence exactement des motifs indiqués.
              !(liste-motif)
                     Correspond à tout sauf l'un des motifs indiqués.

       La mise en correspondance de motifs étendus complexes avec de longues
       chaînes est lente surtout quand les motifs contiennent des alternances et
       les chaînes contiennent plusieurs correspondances. L'utilisation de
       correspondances séparées avec des chaînes plus courtes ou en utilisant
       des tableaux de chaînes à la place d'une longue chaîne unique peut être
       plus court.

   Suppression des protections
       Après les développements précédents, toutes les occurrences non protégées
       des caractères \, ' et " qui ne résultent pas d'un des développements
       ci-dessus sont supprimées.

REDIRECTIONS
       Avant qu'une commande ne soit exécutée, il est possible de rediriger son
       entrée ou sa sortie en utilisant une notation spéciale prise en compte
       par l'interpréteur. La redirection permet aux descripteurs de fichier
       d’être dupliqués, ouverts, fermés, de faire référence à d’autres fichiers
       et peut modifier les fichiers lus et écrits par la commande. Les
       redirections permettent également de modifier les descripteurs de
       fichiers dans l'environnement d’exécution actuel de l'interpréteur. Les
       opérateurs de redirection suivants peuvent précéder ou apparaître
       n'importe où dans une commande simple ou suivre une commande. Les
       redirections sont traitées dans leur ordre d'apparition, de gauche à
       droite.

       Toutes les redirections pouvant être précédées par un numéro de
       descripteur de fichier peuvent aussi être précédées par un mot de la
       forme {nom_de_variable}. Dans ce cas, pour chaque opérateur de
       redirection à part >&- et <&-, l'interpréteur de commande allouera un
       descripteur de fichier supérieur ou égal à 10 et l'affectera à
       nom_de_variable. Si >&- ou <&- sont précédés de {nom_de_variable}, la
       valeur de nom_de_variable définit le descripteur de fichier à fermer. Si
       {nom_de_variable} est fournie, la redirection persiste au-delà de la
       portée de la commande, permettant au programmeur de l'interpréteur de
       gérer le descripteur de fichier lui-même.

       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 <,
       la redirection se rapporte à l'entrée standard (descripteur de fichier
       0). Si le premier caractère de l'opérateur de redirection est >, la
       redirection se rapporte à la sortie standard (descripteur de fichier 1).

       Le mot qui suit l'opérateur de redirection dans les descriptions
       suivantes, à moins qu'il en soit fait état autrement, est soumis au
       développement des accolades, du tilde, des paramètres et des variables, à
       la substitution de commande, au développement arithmétique, à la
       suppression des protections, au développement des chemins et au découpage
       en mots. S'il se développe en plusieurs mots, bash signale une erreur.

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

              ls > liste_répertoires 2>&1

       redirige à la fois la sortie standard et la sortie d'erreur standard 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 standard a été dupliquée de la sortie standard avant
       que celle-ci ne soit redirigée vers liste_répertoires.

       Bash gèrent plusieurs noms de fichier spécifiquement quand ils sont
       utilisés dans des redirections. Si le système d'exploitation sur lequel
       bash s'exécute fournit ces fichiers spéciaux, bash les utilise ;sinon, il
       les émule en interne avec le comportement décrit ci-dessous.

              /dev/fd/df
                     Si df est un entier correct, le descripteur de fichier df
                     est dupliqué.
              /dev/stdin
                     Le descripteur de fichier 0 est dupliqué.
              /dev/stdout
                     Le descripteur de fichier 1 est dupliqué.
              /dev/stderr
                     Le descripteur de fichier 2 est dupliqué.
              /dev/tcp/hôte/port
                     Si hôte est un nom de machine ou une adresse Internet
                     corrects et si port est un numéro de port entier ou un nom
                     de service, bash tentera d'ouvrir la socket TCP
                     correspondante.
              /dev/udp/hôte/port
                     Si hôte est un nom de machine ou une adresse Internet
                     corrects et si port est un numéro de port entier ou un nom
                     de service, bash tentera d'ouvrir la socket UDP
                     correspondante.

       Un échec à l'ouverture ou à la création de fichier conduit à l'échec de
       la redirection.

       Les redirections utilisant des descripteurs de fichiers supérieurs à 9
       doivent être utilisées avec précaution, car des conflits peuvent survenir
       avec les descripteurs de fichiers utilisés en interne par l'interpréteur.

   Redirection d'entrée
       Une redirection d'entrée conduit à l'ouverture en lecture avec le
       descripteur de fichier numéro n du fichier dont le nom résulte du
       développement du mot ou en tant qu'entrée standard (descripteur de
       fichier 0) si n n'est pas indiqué.

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

              [n]<mot

   Redirection de sortie
       Une redirection de sortie conduit à l'ouverture en écriture du fichier
       dont le nom résulte du développement du mot avec comme descripteur de
       fichier n ou en tant que sortie standard (descripteur de fichier 1) si n
       n'est pas indiqué. Si le fichier n'existe pas, il est créé. S'il existait
       déjà, sa taille est réduite à zéro.

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

              [n]>mot

       Si l'opérateur de redirection est > et si l'option noclobber de la
       commande interne set est activée, la redirection échouera si le fichier
       dont le nom résulte du développement du mot existe et est un fichier
       normal. Si l'opérateur de redirection est >| ou l'opérateur > avec
       l'option noclobber de la commande interne set n'est pas activée, la
       redirection sera tentée même si le fichier dont le nom résulte du
       développement du mot existe.

   Ajout d'une sortie redirigée
       La redirection de la sortie de cette façon conduit à l'ouverture du
       fichier dont le nom résulte du développement du mot pour ajouter au
       descripteur de fichier n ou à la sortie standard (descripteur de fichier
       1) si n n'est pas indiqué. Si le fichier n'existe pas, il est créé.

       Le format général pour les sorties avec ajout est :

              [n]>>mot

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

       Il y a deux formes pour rediriger les sortie standard et sortie d'erreur
       standard :

              &>mot
       et
              >&mot

       La première des deux formes est préférée. C'est sémantiquement équivalent
       à

              >mot 2>&1

       En utilisant la deuxième forme, mot ne peut pas être développé en nombre
       ou -. Si c’est le cas, les autres opérateurs de redirection s’appliquent
       (consultez Dédoublement de descripteurs de fichier ci-dessous) pour des
       raisons de compatibilité.

   Ajout de la sortie standard et de la sortie d'erreur standard
       Cette construction permet l'ajout simultané de la sortie standard
       (descripteur 1) et de la sortie d'erreur standard (descripteur 2), dans
       un fichier dont le nom est le résultat du développement du mot.

       La forme pour ajouter les sortie standard et sortie d'erreur standard
       est :

              &>>mot

       C'est sémantiquement équivalent à

              >>mot 2>&1

       (consultez Dédoublement de descripteurs de fichier ci-dessous).

   Document en ligne
       Ce type de redirection commande à l'interpréteur de lire son entrée de la
       source actuelle jusqu'à ce qu'il voit une ligne contenant seulement le
       délimiteur prévu (sans blancs finaux). Toutes les lignes lues jusqu'à ce
       point sont ensuite utilisées comme entrée standard (ou comme descripteur
       de fichier n, si n est spécifié) pour une commande.

       Le format des documents en ligne est le suivant :

              [n]<<[-]mot
                      document_en_ligne
              délimiteur

       Aucun développement des paramètres ou des variables, ni substitution de
       commande, ni développement arithmétique ou des chemins n’est effectué sur
       le mot. Si une partie du mot est protégée, le délimiteur est le résultat
       de la suppression des protections sur mot et les lignes du
       document_en_ligne ne sont pas développées. Si mot n'est pas protégé,
       toutes les lignes du document_en_ligne sont soumises au développement des
       paramètres, à la substitution de commande et au développement
       arithmétique, la suite de caractères \<changement_de_ligne> est ignorée
       et \ doit être utilisée 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 de l'entrée, y compris dans la ligne
       contenant délimiteur. Cela permet d'indenter de façon naturelle les
       documents en ligne au sein des scripts.

   Chaînes en ligne
       Une variante aux documents en ligne, le format est :

              [n]<<<mot

       Le mot est sujet au développement du tilde, des paramètres et des
       variables, à la substitution de commande, au développement arithmétique
       et à la suppression des protections. Ni le développement des chemins, ni
       le découpage en mots ne sont réalisés. Le résultat est fourni comme une
       seule chaîne, avec l'ajout d'un caractère de changement de ligne, à la
       commande sur son entrée standard (ou sur le descripteur de fichier n, si
       n est spécifié).

   Dédoublement de descripteurs 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 noté
       par n devient une copie de ce descripteur. Si les chiffres du mot ne
       correspondent pas à un descripteur ouvert en lecture, une erreur de
       redirection se produit. Si le mot prend la forme -, le descripteur n est
       fermé. Si n n'est pas mentionné, l'entrée standard (descripteur 0) est
       utilisée.

       L'opérateur

              [n]>&mot

       est utilisé de façon similaire pour dupliquer les descripteurs de sortie.
       Si n n'est pas explicité, la sortie standard (descripteur 1) est
       utilisée. Si les chiffres du mot ne correspondent pas à un descripteur en
       écriture, une erreur de redirection se produit. Si mot est évalué en -,
       le descripteur de fichier n est fermé. Dans le cas particulier où n est
       omis et où mot ne se développe pas en un ou plusieurs chiffres, ou -, les
       sorties standard et d'erreur standard sont toutes deux redirigées comme
       décrit précédemment.

   Déplacement de descripteurs de fichiers
       L'opérateur de redirection

              [n]<&chiffre-

       déplace le descripteur de fichier chiffre vers le descripteur de fichier
       n ou sur l'entrée standard (descripteur de fichier 0) si n n'est pas
       indiqué. chiffre est fermé après avoir été dupliqué en n.

       De la même façon, l'opérateur de redirection

              [n]>&chiffre-

       déplace le descripteur de fichier chiffre vers le descripteur de fichier
       n ou sur la sortie standard (descripteur de fichier 1) si n n'est pas
       indiqué.

   Ouverture en Lecture/Écriture d'un descripteur de fichier
       L'opérateur de redirection

              [n]<>mot

       conduit à l'ouverture du fichier dont le nom résulte du développement du
       mot, à la fois en lecture et en écriture et lui affecte le descripteur de
       fichier n ou bien le descripteur 0 si n n'est pas mentionné. Si le
       fichier n'existe pas, il est créé.

ALIAS
       Les alias permettent de substituer une chaîne à un mot lorsqu'il est
       utilisé comme premier mot d'une commande simple. L'interpréteur gère une
       liste d'alias qui peuvent être créés et détruits avec les commandes
       internes alias et unalias (consultez COMMANDES INTERNES DE L'INTERPRÉTEUR
       ci-dessous). L'interpréteur vérifie si le premier mot de chaque commande
       simple, si non protégé, est un alias. Si c'est le cas, ce mot est
       remplacé par le texte de l'alias. Les caractères /, $, ` et = et tout
       métacaractère de l'interpréteur ou caractère de protection décrits
       ci-dessus ne peuvent pas apparaître dans un nom d'alias. Le texte de
       remplacement peut contenir toute entrée correcte pour l'interpréteur, y
       compris les métacaractères de l'interpréteur. L'interpréteur vérifie si
       le premier mot du texte de remplacement est à son tour un alias, mais un
       mot identique à un alias en cours de développement n'est pas développé
       une seconde fois. Cela signifie qu'on peut, par exemple, créer un alias
       ls valant ls -F et bash n'essaiera pas de développer récursivement le
       texte de substitution. Si le dernier caractère de la valeur de l'alias
       est un blanc, alors le prochain mot de commande suivant l'alias connaîtra
       aussi le développement d'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. S'ils sont nécessaires, une fonction de
       l'interpréteur devrait être utilisée (consultez FONCTIONS ci-dessous).

       Les alias ne sont pas développés quand l'interpréteur n'est pas
       interactif sauf si l'option expand_aliases de l'interpréteur est créée
       par la commande shopt (consultez la description de shopt dans COMMANDES
       INTERNES DE L'INTERPRÉTEUR ci-dessous).

       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
       et toutes les lignes qui composent une commande composée, avant
       d'exécuter une des commandes de cette ligne ou de la commande composée.
       Les alias sont développé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. Une commande placée à la suite d'une
       définition d'alias sur la même ligne ne sera pas affectée par ce nouvel
       alias. Ce comportement est également important lors de l'exécution des
       fonctions. Les alias sont développés lorsque la définition de la fonction
       est lue et non pas lors de l'exécution de cette fonction, parce qu'une
       définition de fonction est elle-même une commande. Ainsi des alias
       définis dans une fonction ne sont pas disponibles avant la fin de
       l'exécution de la fonction. Pour plus de tranquillité, placez toujours
       les définitions d'alias sur des lignes isolées et n'utilisez jamais la
       commande alias dans les commandes composées.

       Les alias sont surpassés par les fonctions de l'interpréteur dans la
       plupart des situations.

FONCTIONS
       Une fonction de l'interpréteur, définie comme décrit ci-dessus, dans
       GRAMMAIRE DE L'INTERPRÉTEUR, conserve une suite de commandes pour
       exécution ultérieure. Lorsque le nom d'une fonction de l'interpréteur est
       utilisée comme un simple nom de commande, la liste des commandes
       associées à ce nom de fonction est exécutée. Les fonctions sont exécutées
       dans le contexte de l'interpréteur actuel ; aucun nouveau processus n'est
       créé pour les interpréter (à la différence d'un script). Lorsqu'une
       fonction est exécutée, les arguments de la fonction deviennent les
       paramètres positionnels pendant son exécution. Le paramètre spécial # est
       mis à jour en conséquence. Le paramètre spécial 0 reste inchangé. Le
       premier élément de la variable FUNCNAME contient le nom de la fonction
       pendant son exécution.

       Tous les autres aspects de l'environnement d'exécution de l'interpréteur
       sont identiques entre la fonction et le contexte d'appel, aux exceptions
       suivantes : les captures de DEBUG et RETURN (consultez la description de
       la commande interne trap dans COMMANDES INTERNES DE L'INTERPRÉTEUR
       ci-dessous) ne sont pas héritées, à moins que l'attribut trace ne soit
       positionné pour la fonction (consultez la description de la commande
       interne declare ci-dessous) ou que l'option d'interpréteur -o functrace
       n'ait été activée avec la commande interne set (auquel cas toutes les
       fonctions hériteront des captures de DEBUG et RETURN), et la capture ERR
       n'est pas héritée à moins que l'option d'interpréteur -o errtrace n'ait
       été activée.

       Les paramètres linguistiques régionaux des variables pour les fonctions
       peuvent être déclarés avec la commande interne local. Normalement, les
       variables et leurs valeurs sont partagées entre la fonction et son
       contexte d'appel. Si une variable est déclarée local, la portée visible
       de la variable est restreinte à cette fonction et ses enfants (y compris
       les fonctions qu'ils appellent). Les variables locales « suivent » les
       variables du même nom déclarées pour des portées précédentes. Par
       exemple, une variable locale déclarée dans une fonction masque une
       variable globale du même nom : les références et les affectations se
       réfèrent à la variable locale, sans modifier la variable globale. Quand
       la fonction rend la main, la variable globale est à nouveau visible.

       L'interpréteur utilise les portées dynamiques pour contrôler la
       visibilité d'une variable dans les fonctions. Avec les portées
       dynamiques, les variables visibles et leurs valeurs sont le résultat
       d'une suite d'appels de fonction qui font que l'exécution atteint la
       fonction actuelles. La valeur de la variable vue par une fonction dépend
       de sa valeur dans son contexte d'appel, s'il existe, que le contexte
       d'appel soit la portée « globale » ou une autre fonction de
       l'interpréteur. C'est aussi la valeur qu'une déclaration de variable
       locale « suit », et la valeur qui est restaurée quand la fonction rend la
       main.

       Par exemple, si une variable var est déclarée comme locale dans la
       fonction fonc1, et que fonc1 appelle une autre fonction, fonc2, les
       références à var provenant de la fonc2 seront résolues à la valeur de la
       variable locale var provenant la fonc1, masquant toute variable globale
       nommée var.

       La commande interne unset fonctionne avec les mêmes portées dynamiques :
       si une variable est locale pour la portée actuelle, unset la détruit ;
       autrement, la destruction se réfère à la variable trouvée dans une portée
       d'appel comme décrit ci-dessus. Si une variable pour la portée locale
       actuelle est désactivée, elle reste ainsi jusqu'à ce quelle soit
       réinitialisée dans cette portée ou jusqu'à ce que la fonction rende la
       main. Une fois que la fonction a rendu la main, tout instance de la
       variable dans la portée antérieure deviendra visible. Si la désactivation
       agit sur une variable dans une portée antérieure, toute instance d'une
       variable de ce nom qui avait été masquée deviendra visible.

       La variable FUNCNEST, si configurée à une valeur numérique strictement
       positive, définit le niveau maximal d'imbrication de fonctions. Les
       invocations de fonctions qui dépassent la limite forceront toute la
       commande à abandonner.

       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. Toute commande associée à la capture de RETURN est exécutée
       avant que l'exécution reprenne. 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 la fonction.

       Les noms et les définitions de fonctions peuvent être affichés avec
       l'option -f des commandes internes declare ou typeset. L'option -F de
       declare ou typeset n'affichera que les noms de fonction (et
       facultativement le fichier source et le numéro de ligne, si l'option
       d'interpréteur extdebug est activée). Les fonctions peuvent être
       exportées avec l'option -f de la commande interne export, afin d'être
       automatiquement définies dans les sous-interpréteurs. Une définition de
       fonction peut être supprimée avec l'option -f de la commande interne
       unset.

       Les fonctions peuvent être récursives. La variable FUNCNEST peut être
       utilisée pour limiter la profondeur de la pile d'appel de la fonction et
       restreindre le nombre d'invocations de fonctions. Par défaut, aucune
       limite n'est imposée quant au nombre d'appels récursifs.

ÉVALUATION ARITHMÉTIQUE
       L'interpréteur permet, dans certaines circonstances, l'évaluation
       d'expressions arithmétiques (consultez les commandes internes let et
       declare ainsi que Développement arithmétique). L'évaluation est effectuée
       en utilisant des entiers de longueur fixe, sans vérification du
       débordement. Néanmoins, la division par 0 est capturée et marquée comme
       une erreur. Les opérateurs, leur priorité, leur associativité et leur
       valeur sont identiques à ceux du langage C. La liste suivante
       d'opérateurs est groupée par opérateurs de niveaux de priorité
       identiques. Les niveaux sont décrits par ordre de priorité décroissante.

       id++ id--
              post-incrément et post-décrément de variables
       - +    moins et plus unaires
       ++id --id
              préincrément et prédécrément de variables
       ! ~    négations logique et binaire
       **     exponentiation
       * / %  multiplication, division, reste
       + -    addition, soustraction
       << >>  décalage arithmétique à gauche et à droite
       <= >= < >
              comparaisons
       == !=  égalité et différence
       &      ET binaire
       ^      OU exclusif binaire
       |      OU binaire
       &&     ET logique
       ||     OU logique
       expr?expr:expr
              opérateur conditionnel
       = *= /= %= += -= <<= >>= &= ^= |=
              affectations
       expr1 , expr2
              virgule

       Les variables de l'interpréteur sont utilisables comme opérandes, le
       développement des paramètres étant effectué avant l'évaluation
       arithmétique. Dans une expression, les variables de l'interpréteur
       peuvent également être référencées par leur nom, sans utiliser la syntaxe
       de développement des paramètres. Une variable d'interpréteur NULL ou
       inexistante est évaluée à 0 lorsqu'elle est consultée par son nom sans
       utiliser la syntaxe de développement des paramètres. La valeur d'une
       variable est évaluée comme une expression arithmétique lorsqu'elle est
       consultée, ou lorsqu'une valeur lui est affecté alors que son attribut
       integer (entier) a été positionné en utilisant declare -i. Une valeur
       NULL est évaluée à 0. Une variable d'interpréteur n'a donc pas besoin
       d'avoir son attribut integer positionné pour être utilisable dans un
       calcul.

       Les constantes de type entier suivent la définition du langage C, sans
       suffixes ou constantes de caractères. Les constantes commençant par 0
       sont interprétées comme des nombres octaux. Un en-tête 0x ou 0X indique
       une valeur hexadécimale. Sinon, les nombres ont la forme [base#]n où la
       base facultative est un nombre décimal entre 2 et 64 représentant la base
       arithmétique et n est un nombre exprimé dans cette base. Si la base# est
       omise, la base 10 est utilisée. En indiquant n, si un caractère non
       chiffre est requis, les chiffres supérieurs à 9 sont représentés par les
       lettres minuscules, les lettres majuscules, le « @ » et le « _ », dans
       cet ordre. Si la base est inférieure ou égale à 36, les minuscules et les
       majuscules sont interchangeables pour représenter les nombres entre 10
       et 35.

       Les opérateurs sont évalués par ordre de priorité. Les sous-expressions
       entre parenthèses sont évaluées en premier, ce qui permet de surpasser
       les règles de priorité ci-dessus.

CONDITIONS
       Les conditions sont utilisées par la commande composée [[ et les
       commandes internes test et [ pour vérifier les attributs d'un fichier et
       effectuer des comparaisons arithmétiques ou sur des chaînes. Les
       commandes test et [ déterminent comment elles se comportent à partir du
       nombre d'arguments ; consultez la description de ces commandes pour
       toutes les autres actions spécifiques aux commandes.

       Les conditions se forment à partir des primitives unaires ou binaires
       suivantes. Bash gère plusieurs noms de fichier spécifiquement quand ils
       sont utilisées dans des conditions. Si le système d'exploitation sur
       lequel bash s'exécute fournit ces fichiers spéciaux, bash les utilise ;
       sinon, il les émule en interne avec ce comportement : si n'importe quel
       argument fichier de l'une des primitives est de la forme /dev/fd/n, alors
       le descripteur de fichier n est examiné. Si l'argument fichier de l'une
       des primitives est parmi /dev/stdin, /dev/stdout ou /dev/stderr, le
       descripteur de fichier 0, 1 ou 2, respectivement, est examiné.

       Sauf indication contraire, les primitives relatives aux fichiers suivent
       les liens symboliques et opèrent sur la cible du lien plutôt que sur le
       lien lui-même.

       Lorsqu'ils sont utilisés avec [[, les opérateurs < et > ordonnent d'un
       point de vue lexicographique en utilisant les paramètres linguistiques
       régionaux actuels. La commande test trie en utilisant l'ordre ASCII.

       -a fichier
              Vrai si le fichier existe.
       -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 normal.
       -g fichier
              Vrai si le fichier existe et a son bit Set-GID positionné.
       -h fichier
              Vrai si le fichier existe et est un lien symbolique.
       -k fichier
              Vrai si le fichier existe et a son bit « sticky » positionné.
       -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 strictement positive.
       -t df  Vrai si le descripteur de fichier df est ouvert et se rapporte à
              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.
       -G fichier
              Vrai si le fichier existe et appartient au GID effectif du groupe.
       -L fichier
              Vrai si le fichier existe et est un lien symbolique.
       -N fichier
              Vrai si le fichier existe et a été modifié depuis sa dernière
              lecture.
       -O fichier
              Vrai si le fichier existe et appartient à l'UID effectif de
              l'utilisateur.
       -S fichier
              Vrai si le fichier existe et est une socket.
       fichier_1 -ef fichier_2
              Vrai si le fichier_1 et le fichier_2 se rapportent au même
              périphérique et ont les mêmes numéros d'inœuds.
       fichier_1 -nt fichier_2
              Vrai si le fichier_1 est plus récent que le fichier_2 (selon les
              dates de dernière modification) ou si fichier_1 existe et non
              fichier_2.
       fichier_1 -ot fichier_2
              Vrai si le fichier_1 est plus ancien que le fichier_2 ou si
              fichier_2 existe et non fichier_1.
       -o nom_opt
              Vrai si l'option d'interpréteur nom_opt est activée. Consulter la
              liste des options ci-dessous dans la description de l'option -o de
              la commande interne set.
       -v nom_de_variable
              Vrai si la variable nom_de_variable de l'interpréteur est
              configurée (si une valeur lui a été assignée).
       -R nom_de_variable
              Vrai si la variable nom_de_variable de l'interpréteur est
              configurée et est une référence de nom.
       -z chaîne
              Vrai si la longueur de la chaîne est nulle.
       chaîne
       -n chaîne
              Vrai si la longueur de la chaîne est non nulle.

       chaîne_1 == chaîne_2
       chaîne_1 = chaîne_2
              Vrai si les deux chaînes sont égales. Le symbole = devrait être
              utilisé avec la commande test pour être en conformité POSIX.
              Utilisée avec la commande [[, cela réalise une correspondance de
              motif tel que décrit précédemment (Commandes composées).

       chaîne_1 != chaîne_2
              Vrai si les deux chaînes sont différentes.

       chaîne_1 < chaîne_2
              Vrai si chaîne_1 se trouve avant chaîne_2 dans l'ordre
              lexicographique.

       chaîne_1 > chaîne_2
              Vrai si chaîne_1 se trouve après chaîne_2 dans l'ordre
              lexicographique.

       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 vrai si arg1
              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 ou négatifs. Lorsqu'ils sont utilisés avec la
              commande [[, arg1 et arg2 sont évalués comme des expressions
              arithmétiques (consultez ÉVALUATION ARITHMÉTIQUE ci-dessus).

DÉVELOPPEMENT DES COMMANDES SIMPLES
       Lors de l'exécution d'une commande simple, l'interpréteur effectue les
       développements, affectations et redirections, de gauche à droite dans
       l'ordre suivant.

       1.     Les mots que l'analyseur a repéré comme affectations de variables
              (ceux qui précèdent le nom de la commande) et les redirections
              sont conservées pour un traitement ultérieur.

       2.     Les mots qui ne sont ni des affectations de variables ni des
              redirections sont développés. S'il reste des mots après le
              développement, le premier mot est considéré comme le nom d'une
              commande et les suivants comme ses arguments.

       3.     Les redirections sont effectuées comme décrit ci-dessus dans
              REDIRECTIONS.

       4.     Le texte suivant le signe = de chaque affectation de variable est
              sujet au développement du tilde, des paramètres, à la substitution
              de commande, au développement arithmétique et à la suppression des
              protections avant d'être affecté à la variable.

       Si aucun nom de commande ne résulte des précédentes opérations, les
       affectations de variables modifient l'environnement actuel de
       l'interpréteur. Sinon les variables sont ajoutées à l'environnement de la
       commande exécutée et n'affectent pas l'environnement de l'interpréteur
       actuel. Si l'une des tentatives d'affectation concerne une variable en
       lecture seule, une erreur se produit et la commande termine avec un état
       différent de zéro.

       Si aucun nom de commande n'est obtenu, les redirections sont effectuées
       mais ne modifient pas l'environnement de l'interpréteur actuel. Une
       erreur de redirection conduit à la terminaison de la commande avec un
       état différent de zéro.

       S'il reste un nom de commande après le développement, l'exécution a lieu
       comme décrit ci-dessous. Sinon la commande termine. Si l'un des
       développements contient une substitution de commande, l'état final de la
       commande est l'état final de la dernière substitution de commande
       effectuée. S'il n'y avait aucune substitution de commande, la commande
       termine avec un état de zéro.

EXÉCUTION DES COMMANDES
       Après le découpage de la ligne de commande en mots, si le résultat est
       une commande simple suivie d'une liste facultative d'arguments, les
       actions suivantes sont effectuées.

       Si le nom de la commande ne contient aucune barre oblique, l'interpréteur
       tente de la localiser. S'il existe une fonction de l'interpréteur de ce
       nom, elle est appelée comme nous l'avons vu ci-dessus dans FONCTIONS. Si
       le nom n'est pas celui d'une fonction, l'interpréteur le recherche dans
       la liste des commandes internes. Si une correspondance est trouvée, cette
       commande interne est appelée.

       Si le nom n'est ni celui d'une fonction de l'interpréteur, ni celui d'une
       commande interne et s'il ne contient pas de barre oblique, bash va
       chercher dans chacun des éléments de PATH un répertoire contenant un
       fichier exécutable du nom désiré. Bash utilise une table de hachage pour
       mémoriser les chemins d'accès complets aux fichiers exécutables
       (consultez la commande hash dans COMMANDES INTERNES DE L'INTERPRÉTEUR
       ci-dessous). Une recherche complète dans les répertoires du PATH n'est
       effectuée que si la commande ne se trouve pas dans la table de hachage.
       Si la recherche est infructueuse, l'interpréteur recherche une fonction
       de l'interpréteur appelée command_not_found_handle. Si cette fonction
       existe, elle est appelée dans un environnement d'exécution séparé avec la
       commande d'origine et comme argument les arguments de celle-ci, et l'état
       final de la fonction devient l'état final de ce sous-interpréteur. Si
       cette fonction n'est pas définie, l'interpréteur affiche un message
       d'erreur et renvoie un état final de 127.

       Si la recherche réussit ou si le nom de la commande contient une ou
       plusieurs barres obliques, l'interpréteur exécute le programme demandé
       dans un environnement d'exécution distinct. L'argument 0 est configuré au
       nom indiqué et les éventuels arguments restants de la commande sont
       configurés aux arguments indiqués.

       Si cette exécution échoue parce que le programme n'est pas un exécutable
       et si le fichier n'est pas un répertoire, il est pris pour un script, un
       fichier contenant des commandes d'interpréteur. Un sous-interpréteur est
       alors créé pour exécuter ce script. Ce sous-interpréteur se
       réinitialisera lui-même, comme si un nouvel interpréteur avait été appelé
       pour exécuter le script, à la différence qu'il continuera à mémoriser
       l'emplacement des commandes connues de son parent (consultez hash dans
       COMMANDES INTERNES DE L'INTERPRÉTEUR ci-dessous).

       Si le programme est un fichier commençant par #!, le reste de la première
       ligne indique un interprète pour ce programme. L'interpréteur se chargera
       d'exécuter l'interprète indiqué sur les systèmes d'exploitation qui ne
       gèrent pas eux-mêmes ce format d'exécutable. Les arguments de
       l'interprète consistent en un seul argument facultatif fourni sur la
       première ligne du fichier à la suite du nom de l'interprète, suivi du nom
       du programme, suivi des arguments de la commande s'il y en a.

ENVIRONNEMENT D'EXÉCUTION DES COMMANDES
       L'interpréteur fournit un environnement d'exécution consistant en
       l'ensemble des éléments suivants :

       •      les fichiers ouverts hérités par l'interpréteur à son appel et
              modifiés par les redirections fournies à la commande interne
              exec ;

       •      le répertoire de travail actuel comme configuré par cd, pushd ou
              popd ou hérité par l'interpréteur à son appel ;

       •      le masque de création de fichier comme configuré par umask ou
              hérité du parent de l'interpréteur ;

       •      les captures actuelles configurées par trap ;

       •      les paramètres de l'interpréteur configurés par des affectations
              de variables, avec la commande interne set, ou hérités de
              l'environnement du parent de l'interpréteur ;

       •      les fonctions de l'interpréteur définies lors de l'exécution ou
              héritées de l'environnement du parent de l'interpréteur ;

       •      les options activées à l'appel (par défaut ou avec les arguments
              de ligne de commande) ou par set ;

       •      les options activées par shopt ;

       •      les alias de l'interpréteur définies par la commande alias ;

       •      les ID des divers processus, y compris ceux des tâches en
              arrière-plan, la valeur de $$ et la valeur de PPID.

       Lorsqu'une commande différente d'une commande interne ou d'une fonction
       de l'interpréteur doit être exécutée, elle est appelée dans un
       environnement d'exécution séparé constitué de ce qui suit. Sauf
       indication contraire, les valeurs sont héritées de l'environnement de
       l'interpréteur :


       •      les fichiers ouverts de l'interpréteur, ainsi que toutes
              modifications et ajouts précisés par les redirections de la
              commande ;

       •      le répertoire de travail actuel ;

       •      le masque de création de fichiers ;

       •      les variables et les fonctions de l'interpréteur marquées pour
              l'exportation, ainsi que les variables exportées spécialement pour
              la commande ;

       •      les captures interceptées par l'interpréteur sont réinitialisées
              aux valeurs héritées de l'interpréteur parent et les captures
              ignorées par l'interpréteur restent ignorées.

       Une commande appelée dans un environnement distinct ne peut pas affecter
       l'environnement d'exécution de l'interpréteur.

       Les substitutions de commande, les commandes groupées entre parenthèses
       et les commandes asynchrones sont appelées dans un environnement de
       sous-interpréteur qui est une copie de celui de l'interpréteur, mais les
       captures interceptées par l'interpréteur sont réinitialisées aux valeurs
       que l'interpréteur avait héritées de son parent à son appel. Les
       commandes internes appelées dans un pipeline sont aussi exécutées dans un
       environnement de sous-interpréteur. Les modifications apportées à
       l'environnement d'un sous-interpréteur n'affectent aucunement
       l'environnement d'exécution de l'interpréteur.

       Les sous-interpréteurs engendrés pour exécuter les substitutions de
       commande héritent de la valeur de l'option -e de l'interpréteur parent.
       En dehors du mode POSIX, bash efface l'option -e de tels
       sous-interpréteurs.

       Si une commande est suivie par un & et que le contrôle des tâches n'est
       pas actif, l'entrée standard par défaut de la commande est le fichier
       vide /dev/null. Sinon, la commande appelée hérite des descripteurs de
       fichiers de l'interpréteur appelant comme modifiés par les redirections.

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

       L'interpréteur fournit plusieurs façons de gérer l'environnement. Au
       démarrage, l'interpréteur analyse son propre environnement et crée un
       paramètre pour chaque nom trouvé, en le marquant comme exportable vers
       les processus enfants. 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 toute commande exécutée est l'environnement
       initial de l'interpréteur, dont les valeurs peuvent être modifiées dans
       l'interpréteur, sans les éléments supprimés par la commande unset, et
       avec 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 des affectations de
       paramètres, comme nous l'avons vu ci-dessus dans PARAMÈTRES. Ces
       affectations ne concernent que l'environnement vu par cette commande.

       Si l'option -k est configurée (consultez ci-dessous la commande interne
       set), alors toutes les affectations de paramètres sont placées dans
       l'environnement d'une commande exécutée et non seulement celles qui
       précèdent son nom.

       Quand bash appelle une commande externe, la variable _ est configurée en
       chemin d'accès complet à cette commande et elle est transmise dans
       l'environnement.

CODE DE RETOUR
       L'état final d'une commande exécutée est la valeur renvoyée par l'appel
       système waitpid ou fonction équivalente. Les états finaux prennent leurs
       valeurs entre 0 et 255, néanmoins, comme expliqué ci-dessous,
       l'interpréteur peut utiliser les valeurs supérieures à 125 de façon
       particulière. Les états finaux des commandes internes et composées sont
       également limités à cet intervalle. Sous certaines conditions,
       l'interpréteur utilisera des valeurs particulières pour indiquer des
       modes d'échec particuliers.

       Du point de vue de l'interpréteur, une commande qui termine avec état
       final valant zéro a réussi. Un état final de zéro indique le succès. Un
       état final différent de zéro indique un échec. Quand une commande se
       termine par un signal mortel N, bash utilise la valeur 128+N comme état
       final.

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

       Si une commande échoue à cause d'une erreur survenue lors d'un
       développement ou des redirections, l'état final est strictement plus
       grand que zéro.

       Les commandes internes renvoient un état de 0 (vrai) si réussies et une
       valeur différente de zéro (faux) si une erreur se produit pendant leur
       exécution. Toutes les commandes internes renvoient un état final de 2
       pour indiquer un usage incorrect, en général des options non valables ou
       des arguments manquants.

       Bash lui-même renvoie l'état final de la dernière commande exécutée, à
       moins qu'une erreur de syntaxe ne se produise, auquel cas il termine avec
       une valeur différente de zéro. Consultez aussi ci-dessous la commande
       interne exit.

SIGNAUX
       Quand bash fonctionne de façon interactive, en absence de toute capture,
       il ignore SIGTERM (c'est ainsi que kill 0 ne tue pas un interpréteur
       interactif) et SIGINT est intercepté et géré (c'est ainsi que la commande
       interne wait est interruptible). Dans tous les cas, bash ignore SIGQUIT.
       Si le contrôle des tâches est actif, bash ignore SIGTTIN, SIGTTOU et
       SIGTSTP.

       Les commandes externes lancées par bash ont les gestionnaires de signaux
       configurés aux valeurs héritées par l'interpréteur de son parent. Quand
       le contrôle des tâches n'est pas actif, les tâches en arrière-plan
       ignorent les signaux SIGINT et SIGQUIT en plus des gestionnaires hérités.
       Les commandes exécutées en tant que résultat d'une substitution de
       commande ignorent les signaux de contrôle de tâches émis par le clavier
       SIGTTIN, SIGTTOU et SIGTSTP.

       Par défaut, l'interpréteur termine à la réception de SIGHUP. Avant de
       terminer, un interpréteur interactif renvoie le SIGHUP à toutes les
       tâches en cours ou suspendues. Les tâches suspendues reçoivent aussi
       SIGCONT pour s'assurer qu'elles reçoivent bien le SIGHUP. Pour empêcher
       l'interpréteur d'envoyer le signal à une tâche particulière, elle devrait
       être supprimée de la table des tâches avec la commande interne disown
       (consultez COMMANDES INTERNES DE L'INTERPRÉTEUR ci-dessous) ou marquée
       comme exemptée de SIGHUP en utilisant disown -h.

       Si l'option d'interpréteur huponexit a été configurée avec la fonction
       shopt, bash envoie un signal SIGHUP à toutes les tâches lorsqu'un
       interpréteur de commandes de connexion interactif termine.

       Lorsque bash attend qu'une commande se termine et qu'il reçoit un signal
       pour lequel une capture a été configurée, la capture ne sera pas exécutée
       tant que la commande n'est pas terminée. Lorsque bash attend la fin d'une
       commande asynchrone par la commande interne wait, la réception d'un
       signal pour lequel une capture a été configurée conduira à un retour
       immédiat de la commande interne wait avec un état final supérieur à 128,
       à la suite de quoi la capture est immédiatement exécutée.

CONTRÔLE DES TÂCHES
       Le contrôle des tâches se réfère à la capacité de suspendre (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 du noyau de système
       d'exploitation et de bash.

       L'interpréteur associe une tâche à chaque pipeline. Il maintient une
       table des tâches en cours d'exécution, cette table pouvant être affichée
       avec la commande jobs. Quand bash lance une tâche de façon asynchrone (en
       arrière-plan), il affiche une ligne qui ressemble à :

              [1] 25647

       Cette ligne indique que la tâche est la tâche numéro 1 et que le PID du
       dernier processus dans le pipeline associé à cette tâche est 25647. Tous
       les processus d'un même pipeline font partie de la même tâche. Bash
       utilise la notion de tâche comme base du contrôle des tâches.

       Pour faciliter l'implémentation d'une interface utilisateur pour le
       contrôle de tâches, le système introduit la notion d'ID de groupe de
       processus associés à un terminal. Les membres de ce groupe de processus
       (processus dont le GID est égal au Process Group ID du terminal actuel)
       reçoivent les signaux émis par le clavier comme SIGINT. Ces processus
       sont dits au premier plan. Les processus en arrière-plan sont ceux dont
       le Process-GID diffère de celui du terminal ; ils sont indifférents aux
       signaux émis par le clavier. Seuls les processus au premier plan peuvent
       lire depuis le terminal ou, si l'utilisateur l'indique avec stty tostop,
       y écrire. Les processus en arrière-plan qui tentent une lecture (ou une
       écriture si stty tostop est actif) dans le terminal reçoivent un signal
       SIGTTIN (SIGTTOU) émis par le pilote du terminal du noyau, qui, sauf
       interception, suspend le processus.

       Si le système d'exploitation sur lequel bash fonctionne permet le
       contrôle des tâches, bash fournit des outils pour l'utiliser. La frappe
       d'un caractère de suspension (généralement ^Z, Contrôle-Z) pendant
       l'exécution d'un processus conduit à la suspension de celui-ci et redonne
       la main à bash. La frappe d'un caractère de suspension différée
       (généralement ^Y, Contrôle-Y) conduira à la suspension du processus au
       moment où il tentera de lire des saisies depuis le terminal et la main
       reviendra à bash. L'utilisateur peut alors manipuler l'état de cette
       tâche en utilisant la commande bg (background = arrière-plan) pour en
       continuer l'exécution en arrière-plan, la commande fg (foreground =
       premier plan) pour la continuer au premier plan ou encore la commande
       kill pour la tuer. Un ^Z s'applique immédiatement et a pour effet de bord
       d'éliminer les sorties et saisies en attente.

       Plusieurs façons permettent de se rapporter à une tâche. Le caractère %
       introduit une spécification de tâche (jobspec). Il est possible de se
       rapporter à la tâche numéro n avec %n. Il est également possible de se
       rapporter à une tâche en utilisant un préfixe du nom utilisé pour la
       lancer ou une sous-chaîne qui apparaît dans sa ligne de commande. Par
       exemple, %ce se rapporte à une tâche suspendue dont le nom de commande
       commence par ce. Si ce préfixe correspond à plusieurs tâches, bash
       signale une erreur. Utiliser %?ce, d'un autre côté, se rapporte à toute
       tâche contenant la chaîne ce dans sa ligne de commande. Si la sous-chaîne
       correspond à plusieurs tâches, bash signale une erreur. Les symboles %%
       et %+ se rapportent à la notion de tâche actuelle de l'interpréteur,
       c'est-à-dire la dernière tâche suspendue alors qu'elle était au premier
       plan ou démarrée en arrière-plan. La tâche précédente peut être désignée
       en utilisant %-. Si une seule tâche existe, %+ et %- peuvent tous deux
       être utilisés pour se rapporter à cette tâche. Dans les affichages se
       rapportant aux tâches (par exemple la sortie de la commande jobs), la
       tâche actuelle est toujours annotée d'un + et la tâche précédente d'un -.
       Un simple % (non accompagné de spécification de tâche) se rapporte
       également à la tâche actuelle.

       Il suffit de nommer une tâche pour la ramener au premier plan : %1 est
       synonyme de « fg %1 » et ramène la tâche 1 de l'arrière-plan vers le
       premier plan. De même, « %1 & » reprend la tâche 1 en arrière-plan, de
       façon équivalente à « bg %1 ».

       L'interpréteur est immédiatement prévenu lorsqu'une tâche change d'état.
       Normalement bash attend d'être prêt à afficher son interpréteur avant de
       signaler des changements dans l'état des tâches, afin de ne pas
       interrompre toute autre sortie. Si l'option -b de la commande interne set
       est activée, bash signalera de telles modifications immédiatement. Toute
       capture sur SIGCHLD est exécutée pour chaque enfant qui se termine.

       Si une tentative visant à terminer bash est réalisée alors que des tâches
       sont suspendues (ou, si l'option d'interpréteur checkjobs a été activée
       par la commande interne shopt, en cours d'exécution), l'interpréteur
       affiche un message d'avertissement, et, si l'option d'interpréteur
       checkjobs est activée, affiche la liste les tâches et leurs états. La
       commande jobs peut alors être utilisée pour examiner leur état. Si une
       deuxième tentative est faite pour terminer sans commande intercalaire,
       l'interpréteur n'affiche aucun autre avertissement et les tâches
       suspendues sont terminées.

       Lorsque l'interpréteur est dans l'attente d'une tâche ou d'un processus
       utilisant la commande interne wait et que le contrôle des tâches est
       activé, wait rendra la main quand la tâche changera d'état. L'option -f
       fera que wait attendra que la tâche ou le processus termine avant de
       rendre la main.

INVITES
       Quand il est exécuté de façon interactive, bash affiche l'invite de base
       PS1 dès qu'il est prêt à lire une commande et l'invite secondaire PS2
       quand il a besoin de plus de saisies pour exécuter une commande. Bash
       affiche PS0 après avoir lu une commande, mais avant de l'exécuter. Bash
       affiche PS4 comme décrit ci-dessus avant de tracer chaque commande quand
       l'option -x est activée. Bash permet de personnaliser ces chaînes
       d'invite, en insérant un certain nombre de caractères spéciaux protégés
       par des contre-obliques qui sont décodés comme suit :
              \a     un caractère ASCII d'alarme (07) ;
              \d     la date au format « Jour_de_la_semaine Mois Quantième »
                     (par exemple : « Tue May 26 ») ;
              \D{format}
                     le format est passé à strftime(3) et le résultat est inséré
                     dans la chaîne de l'invite ; un format vide implique une
                     représentation du temps spécifique aux paramètres
                     linguistiques régionaux. Les accolades sont nécessaires ;
              \e     un caractère de protection ASCII (033) ;
              \h     le nom de la machine, jusqu'au premier point « . » ;
              \H     le nom de la machine ;
              \j     le nombre de tâches actuellement gérées par
                     l'interpréteur ;
              \l     le nom de base du nom de périphérique de terminal de
                     l'interpréteur ;
              \n     changement de ligne ;
              \r     retour chariot (« carriage return ») ;
              \s     le nom de l'interpréteur, c'est-à-dire le nom de base de $0
                     (la portion suivant la dernière barre oblique) ;
              \t     l'heure actuelle au format HH:MM:SS sur 24 heures ;
              \T     l'heure actuelle au format HH:MM:SS sur 12 heures ;
              \@     l'heure actuelle au format HH:MM sur 12 heures ;
              \A     l'heure actuelle au format HH:MM sur 24 heures ;
              \u     le nom de l'utilisateur ;
              \v     la version de bash (par exemple, 2.00) ;
              \V     le numéro de version complet (avec niveau de correctifs) de
                     bash, (par exemple, 2.00.0) ;
              \w     le répertoire de travail actuel, avec $HOME abrégé en tilde
                     « ~ » (utilise la valeur de la variable PROMPT_DIRTRIM) ;
              \W     le nom de base du répertoire de travail actuel, avec $HOME
                     abrégé en tilde (« ~ ») ;
              \!     le numéro d'historique de la commande ;
              \#     le numéro de la commande ;
              \$     # si l'UID effectif est 0, $ sinon ;
              \nnn   le caractère de code octal nnn ;
              \\     une contre-oblique ;
              \[     débute une suite de caractères non imprimables, qui peuvent
                     être utilisés pour inclure une suite de caractères de
                     contrôle du terminal dans l'interpréteur ;
              \]     finit une suite 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 file d'historique qui peut contenir des commandes relues
       depuis cette liste (consultez HISTORIQUE ci-dessous), alors que le numéro
       de commande est simplement une position dans la suite de commandes
       exécutées depuis le début de la session d'interpréteur actuelle. Après
       que la chaîne ait été décodée, elle est soumise au développement des
       paramètres, à la substitution de commande, au développement arithmétique,
       au découpage des mots et à la suppression des protections, selon la
       valeur de l'option d'interpréteur promptvars (consultez la description de
       shopt dans COMMANDES INTERNES DE L'INTERPRÉTEUR ci-dessous). Cela peut
       avoir des effets non désirés si des portions protégées de la chaîne
       apparaissent à l'intérieur de la substitution de commande ou contiennent
       des caractères spéciaux pour le développement de mots.

READLINE
       C'est la bibliothèque qui gère la lecture des saisies lors des sessions
       interactives de l'interpréteur, à moins que l'option --noediting ne soit
       indiquée à l'appel de l'interpréteur. Par défaut les commandes d'édition
       de ligne sont similaires à celles d'Emacs. Une interface d'édition de
       ligne dans le style vi est aussi disponible. Pour arrêter l'édition de
       ligne après le démarrage de l'interpréteur, utiliser l'option +o emacs ou
       +o vi de la commande interne set (consultez COMMANDES INTERNES DE
       L'INTERPRÉTEUR ci-dessous).

   Notation readline
       Dans ce paragraphe on utilisera la notation « à la Emacs » pour indiquer
       les frappes 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, c'est-à-dire presser la touche d'Échappement
       puis la touche x. Cela fait de ESC le préfixe méta. La combinaison M-C-x
       signifie ESC-Contrôle-x ou encore presser la touche d'Échappement puis
       maintenir la touche Contrôle enfoncée tout en pressant la touche x.)

       Les commandes readline peuvent recevoir des arguments numériques, qui
       fonctionnent en règle générale comme compteurs de répétitions. Parfois,
       cependant, c'est le signe de l'argument qui est significatif.
       L'utilisation d'un argument négatif pour une commande agissant dans un
       sens donné (par exemple kill-line) conduit cette commande à agir dans la
       direction opposée. Les commandes dont le comportement avec les arguments
       diffère de cela sont indiquées ci-dessous.

       Lorsqu'une commande est indiquée comme détruisant du texte, le texte
       effacé est en fait sauvegardé pour une éventuelle récupération ultérieure
       (« yanking »). Il est conservé dans un tampon circulaire (« kill ring »).
       Les suppressions successives conduisent à l'accumulation du texte en un
       seul bloc qui peut être récupéré en une fois. Les commandes non
       destructives séparent les blocs de textes dans le tampon circulaire.

   Initialisation de readline
       Readline est personnalisé en plaçant des commandes dans un fichier
       d'initialisation (le fichier inputrc). Le nom de ce fichier est pris dans
       la variable de l'interpréteur INPUTRC. Si cette variable est inexistante,
       le nom par défaut est ~/.inputrc. Si ce fichier n'existe pas ou s'il ne
       peut pas être lu, le dernier fichier par défaut est /etc/inputrc.
       Lorsqu'un programme utilisant la bibliothèque readline démarre, le
       fichier d'initialisation est lu et les raccourcis clavier et les
       variables sont mis en place. Il n'y a que quelques constructions
       élémentaires possibles dans le fichier d'initialisation de readline. Les
       lignes blanches sont ignorées. Les lignes commençant par # sont des
       commentaires. Les lignes commençant par $ indiquent des constructions
       conditionnelles. Les autres lignes indiquent des raccourcis clavier et
       des paramétrages de variables.

       Les raccourcis clavier par défaut peuvent être modifiés par un fichier
       inputrc. D'autres programmes qui utilisent cette bibliothèque peuvent
       ajouter leurs propres commandes et raccourcis.

       Par exemple, en plaçant

              M-Control-u: universal-argument
       ou
              C-Meta-u: universal-argument
       dans le fichier inputrc, on associera la suite de touches 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'associer à une touche
       une chaîne de caractères qui sera insérée lorsque la touche est pressée
       (une macro).

   Raccourcis clavier readline
       La syntaxe pour contrôler les raccourcis clavier dans le fichier inputrc
       est simple. Tout ce qui est nécessaire est le nom de la commande ou le
       texte d'une macro et la suite de touches à laquelle il faut l'associer.
       Les noms de touches peuvent être indiqués de l'une des deux façons :
       comme un nom de touche symbolique, éventuellement précédé des préfixes
       Meta- ou Control- ou sous forme d'une suite de touches.

       En utilisant la forme touche:nom_de_fonction ou macro, touche est le nom
       de la touche en anglais. Par exemple :

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

       Dans l'exemple ci-dessus, C-u est associé à la fonction
       universal-argument, M-DEL à la fonction backward-kill-word et C-o à
       l'exécution de la macro exprimée dans la partie gauche (c'est-à-dire,
       insérer le texte ``> output'' sur la ligne).

       Avec la seconde forme, "touches":nom_de_fonction ou macro, touches
       diffère de touche ci-dessus en ce que les chaînes notant une suite
       complète de touches peuvent être indiquées en plaçant la suite entre
       guillemets doubles. Certaines suites de touches d'échappement dans le
       style GNU Emacs peuvent être utilisées, comme dans l'exemple suivant,
       mais les noms de caractères symboliques ne sont pas reconnus.

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

       Dans cet exemple, C-u est à nouveau associé à la fonction
       universal-argument, C-x C-r à la fonction re-read-init-file et ESC [ 1 1
       ~ à l'insertion du texte ``Function Key 1''.

       Le jeu complet des suites de caractères de protection du style GNU Emacs
       est :
              \C-    préfixe Contrôle ;
              \M-    préfixe Méta ;
              \e     caractère de protection ;
              \\     contre-oblique ;
              \"     un guillemet " littéral ;
              \'     un guillemet ' littéral.

       En plus des suites de caractères de protection dans le style GNU Emacs,
       un second jeu de suites de caractères de protection par contre-obliques
       est disponible :
              \a     alerte (alarme) ;
              \b     effacement arrière (« backspace ») ;
              \d     effacement ;
              \f     saut de page (« form feed ») ;
              \n     changement de ligne ;
              \r     retour chariot (« carriage return ») ;
              \t     tabulation horizontale ;
              \v     tabulation verticale ;
              \nnn   le caractère 8 bits dont la valeur octale est nnn (un à
                     trois chiffres) ;
              \xHH   le caractère 8 bits dont la valeur hexadécimale est HH (un
                     ou deux chiffres hexadécimaux) ;

       Lorsqu'on saisit le texte d'une macro, il faut utiliser des guillemets
       simples ou doubles pour indiquer la définition de la macro. Les textes
       non protégés sont considérés comme des noms de fonctions. Dans le corps
       de la macro, les protections par contre-oblique décrites ci-dessus sont
       développées. La contre-oblique protégera tout autre caractère dans le
       texte de la macro, y compris " et '.

       Bash permet d'afficher ou de modifier les raccourcis clavier readline
       avec la commande interne bind. On peut basculer d'un mode d'édition à
       l'autre en mode interactif en utilisant l'option -o de la commande
       interne set (consultez COMMANDES INTERNES DE L'INTERPRÉTEUR ci-dessous).

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

              set nom_de_variable valeur
       ou utilisant la commande interne bind (consultez COMMANDES INTERNES DE
       L'INTERPRÉTEUR ci-dessous).

       Sauf indication contraire, les variables de readline prennent les valeurs
       On ou Off (la casse étant sans importance). Les noms de variables non
       reconnues sont ignorés. Lorsqu'une valeur de variable est lue, les
       variables vides ou de valeur NULL, « on » (insensible à la casse) et
       « 1 » sont équivalentes à On. Toutes les autres valeurs sont équivalentes
       à Off. Les variables et leurs valeurs par défaut, sont :

       bell-style (audible)
              Cette variable commande readline lorsqu'il faut déclencher
              l'alarme du terminal. Si configurée à none, readline n'émet jamais
              d'alarme. Si configurée à visible, readline utilise une alarme
              visuelle s'il y en a une disponible. Si configurée à audible,
              readline essaie de faire sonner l'alarme du terminal.
       bind-tty-special-chars (On)
              Si configurée à On, readline tente d'associer les caractères de
              contrôle traités spécialement par le pilote de terminal du noyau à
              leurs équivalents readline.
       blink-matching-paren (Off)
              Si configurée à On, readline tente de déplacer brièvement le
              curseur vers une parenthèse ouvrante lors de l'insertion d'une
              parenthèse fermante.
       colored-completion-prefix (Off)
              Si configurée à On, lors du listage des complètements, readline
              affiche le préfixe commun du jeu des complètements possibles en
              utilisant une couleur différente. Les définitions de couleur sont
              prises selon la valeur de la variable d’environnement LS_COLORS.
       colored-stats (Off)
              Si configurée à On, readline affiche les complètements possibles
              en utilisant des couleurs différentes pour indiquer leur type de
              fichier. Les définitions de couleur sont prises dans la valeur de
              la variable d’environnement LS_COLORS.
       comment-begin (« # »)
              Cette chaîne est insérée quand la commande readline insert-comment
              est exécutée. Cette commande est associée à M-# en mode Emacs et à
              # en mode de commande vi.
       completion-display-width (-1)
              Le nombre de colonnes d'écran utilisées pour afficher de possibles
              correspondances lors de la réalisation du complètement. La valeur
              est ignorée si elle est inférieure à 0 ou supérieure à la largeur
              de l'écran du terminal. Une valeur de 0 fera que les
              correspondances seront affichées une par ligne. La valeur par
              défaut est -1.
       completion-ignore-case (Off)
              Si configurée à On, readline effectue les correspondances et
              complètements de noms de fichiers sans tenir compte de la casse.
       completion-map-case (Off)
              Si configurée à On et completion-ignore-case activée, readline
              traite les traits d'union (-) et les tirets bas (_) comme
              équivalents lorsqu'elle réalise une recherche de correspondance et
              un complètement de nom de fichier insensibles à la casse.
       completion-prefix-display-length (0)
              La longueur, en caractères, du préfixe commun d'une liste de
              complètements possibles affiché sans modification. Si configurée
              en valeur positive, les préfixes communs plus longs que cette
              valeur sont remplacés par une ellipse lors de l'affichage des
              complètements possibles.
       completion-query-items (100)
              Cela détermine quand l'utilisateur est interrogé pour voir le
              nombre de complètements possibles produits par la commande
              possible-completions. Elle peut être configurée à toute valeur
              entière positive. Si le nombre de complètements possibles est
              supérieur ou égal à la valeur de cette variable, readline
              demandera à l'utilisateur s'il veut ou non les voir ; sinon, ils
              sont simplement affichés sur le terminal.
       convert-meta (On)
              Si configurée à On, readline transformera les caractères avec leur
              huitième bit réglé à une suite de caractères ASCII en supprimant
              le huitième bit et en préfixant un caractère de protection (en
              fait, en utilisant le caractère de protection comme préfixe méta).
              La configuration par défaut est On, mais readline la fixe à Off si
              le paramètre linguistique régional contient des caractères 8 bits.
       disable-completion (Off)
              Si configurée à On, readline empêchera le complètement des mots.
              Les caractères de complètement seront insérés sur la ligne comme
              s'ils avaient été associés à self-insert.
       echo-control-characters (On)
              Si configurée à On, sur les systèmes d'exploitation le permettant,
              readline affiche un caractère correspondant à un signal provenant
              du clavier.
       editing-mode (emacs)
              Commande si readline doit démarrer avec des raccourcis clavier
              similaires à Emacs ou à vi. editing-mode peut être positionné soit
              à emacs, soit à vi.
       emacs-mode-string (@)
              Si la variable show-mode-in-prompt est activée, cette chaîne est
              affichée immédiatement avant la dernière ligne de la première
              invite quand le mode édition d'Emacs est activé. La valeur est
              développée comme un raccourci clavier, donc le jeu standard de
              préfixes meta- ou Control- et de séquences de protections par
              contre-oblique est disponible. Utiliser les caractères de
              protection \1 et \2 pour ouvrir et fermer les séquences de
              caractères non imprimables, ce qui peut être utilisé pour inclure
              une suite de caractères de contrôle du terminal dans la chaîne de
              mode.
       enable-bracketed-paste (On)
              Quand configurée à On, readline configurera le terminal de manière
              à ce qu'il puisse insérer chaque collage dans le tampon d'édition
              comme une chaîne de caractères unique, plutôt que de traiter
              chaque caractère comme si il avait été lu du clavier. Cela peut
              empêcher que les caractères collés ne soient interprétés comme des
              commandes d'édition.
       enable-keypad (Off)
              Quand configurée à On, readline essayera d'activer le pavé
              numérique de l'application une fois appelée. Sur certains
              systèmes, c'est nécessaire pour utiliser les flèches.
       enable-meta-key (On)
              Quand configurée à On, readline essayera d'activer toutes les
              touches de modificateur Méta que le terminal peut prendre en
              charge une fois appelé. Sur de nombreux terminaux, la touche Méta
              est utilisée pour saisir des caractères sur huit bits.
       expand-tilde (Off)
              Si configurée à On, le développement du tilde est effectué lorsque
              readline tente un complètement de commandes.
       history-preserve-point (Off)
              Si configurée à On, le programme d'historique tente de placer le
              curseur au même endroit sur chaque ligne d'historique récupérée
              avec previous-history ou next-history.
       history-size (unset)
              Configure le nombre maximal d'éléments sauvegardés dans la file de
              l'historique. Si configuré à zéro, tous les éléments sont effacés
              et aucun nouvel élément n’est sauvegardé. Si configuré à une
              valeur strictement négative, le nombre d'éléments de la file
              d’historique n'est pas limité. Par défaut, le nombre d’éléments
              est configuré à la valeur de la variable HISTSIZE de
              l'interpréteur. En cas de tentative de régler history-size à une
              valeur non numérique, le nombre maximal d'éléments est configuré
              à 5OO.
       horizontal-scroll-mode (Off)
              Quand configurée à On, readline utilisera une seule ligne
              d'affichage et fera défiler la saisie horizontalement sur une
              seule ligne d'écran quand elle devient plus longue que la largeur
              de l'écran, plutôt que de faire un retour à la ligne. Ce réglage
              est activé automatiquement pour les terminaux de hauteur 1.
       input-meta (Off)
              Si configurée à On, readline acceptera des saisies sur huit bits
              (autrement dit il ne supprimera pas le huitième bit), quel que
              soit le terminal utilisé. Le nom meta-flag est un synonyme pour
              cette variable. La configuration par défaut est Off, mais readline
              la fixe à On si le paramètre linguistique régional contient des
              caractères 8 bits.
       isearch-terminators (« C-[C-J »)
              La chaîne de caractères qui doit terminer une recherche
              incrémentale sans que le caractère ne soit exécuté comme une
              commande. Si cette variable n'a pas reçu de valeur, les caractères
              ESC et C-J termineront une recherche incrémentale.
       keymap (emacs)
              Configure le jeu de raccourcis readline actuel. L'ensemble des
              noms corrects de jeux de raccourcis est emacs, emacs-standard,
              emacs-meta, emacs-ctlx, vi, vi-command et vi-insert. vi est
              équivalent à vi-command ; emacs est équivalent à emacs-standard.
              La valeur par défaut est emacs ; la valeur de editing-mode modifie
              aussi le jeu de raccourcis par défaut.
       keyseq-timeout (500)
              Indique le temps que readline attendra un caractère lors de la
              lecture d’une suite de touches ambiguë (c’est-à-dire qui peut
              former une suite de touches complète en utilisant l’entrée lue
              jusqu’à présent, ou accepter une entrée supplémentaire pour
              compléter une suite de touches plus longue). Si aucune entrée
              n’est reçue pendant le temps d’attente, readline utilisera la
              suite la plus courte, mais complète. La valeur est indiquée en
              milliseconde, donc une valeur de 1000 signifie que readline
              attendra pendant une seconde une entrée supplémentaire. Si cette
              variable est configurée à une valeur inférieure ou égale à zéro,
              ou à une valeur non numérique, readline attendra la saisie d’une
              autre touche pour décider de la suite de touches à compléter.
       mark-directories (On)
              Si configurée à On, une barre oblique est ajoutée aux noms de
              répertoires.
       mark-modified-lines (Off)
              Si configurée à On, les lignes d'historique qui ont été modifiées
              seront précédées à l'affichage d'un astérisque (*).
       mark-symlinked-directories (Off)
              Si configurée à On, une barre oblique est ajoutée aux noms
              complétés si ce sont des liens symboliques vers des répertoires
              (selon la valeur de mark-directories).
       match-hidden-files (On)
              Cette variable, quand elle est configurée à On, conduit readline à
              faire correspondre des fichiers dont le nom commence par un « . »
              (fichiers cachés) lors du complètement de noms de fichiers. Si
              configurée à Off, le « . » du début doit être fourni par
              l'utilisateur dans le nom de fichier à compléter.
       menu-complete-display-prefix (Off)
              Si configurée à On, le complètement de menu affiche le préfixe
              commun à la liste de complètements possibles (qui peut être vide)
              avant de tourner dans la liste.
       output-meta (Off)
              Si configurée à On, readline affichera directement les caractères
              ayant leur huitième bit défini plutôt que d'utiliser une suite de
              caractères de protection avec préfixe méta. La configuration par
              défaut est Off, mais readline la fixe à On si le paramètre
              linguistique régional contient des caractères 8 bits.
       page-completions (On)
              Si configurée à On, readline utilise un afficheur de texte interne
              du type more pour afficher les complètements possibles sur un seul
              plein écran.
       print-completions-horizontally (Off)
              Si configurée à On, readline affichera les complètements
              correspondants triés horizontalement dans l'ordre alphabétique
              plutôt que verticalement.
       revert-all-at-newline (Off)
              Si configurée à On, readline annulera toutes les modifications des
              lignes d'historique avant de s'arrêter quand accept-line est
              exécuté. Par défaut les lignes d'historique peuvent être modifiées
              et conservent les listes d'annulation individuelles au fur et à
              mesure des appels à readline.
       show-all-if-ambiguous (Off)
              Cela modifie le comportement par défaut des fonctions de
              complètement. Si configurée à On, les mots qui ont plus d'un
              complètement possibles conduisent à l'affichage immédiat des
              correspondances plutôt qu'à l'émission d'une alarme.
       show-all-if-unmodified (Off)
              Cela modifie le comportement par défaut des fonctions de
              complètement de façon similaire à show-all-if-ambiguous. Si
              configurée à On, les mots qui ont plus d'un complètement possible
              sans aucun complètement partiel possible (les complètements
              possibles ne partagent pas de préfixe commun) conduisent à
              l'affichage immédiat des correspondances plutôt qu'à l'émission
              d'une alarme.
       show-mode-in-prompt (Off)
              Si configurée à On, ajoute une chaîne au début de l’invite
              indiquant le mode d’édition : Emacs, commande Vi ou insertion Vi.
              L'utilisateur peut configurer la chaîne de mode (par exemple,
              emacs-mode-string).
       skip-completed-text (Off)
              Si configurée à On, modifie le comportement par défaut du
              complètement lors de l'insertion d'une unique correspondance dans
              la ligne. Elle n'est utilisée que lors d'un complètement effectué
              au milieu d'un mot. Si elle est activée, readline n'insère pas de
              caractères de complètement correspondant à des caractères situés
              après le curseur dans le mot en train d'être complété, ainsi les
              parties du mots situées après le curseur ne sont pas dupliquées.
       vi-cmd-mode-string ((cmd))
              Si la variable show-mode-in-prompt est activée, cette chaîne est
              affichée immédiatement avant la dernière ligne de la première
              invite quand le mode d'édition vi est activé et en mode commande.
              La valeur est développée comme un raccourci clavier, donc le jeu
              standard de préfixes meta- ou Control- et de séquences de
              protections par contre-oblique est disponible. Utiliser les
              caractères de protection \1 et \2 pour ouvrir et fermer les
              séquences de caractères non imprimables, ce qui peut être utilisé
              pour inclure une suite de caractères de contrôle du terminal dans
              la chaîne de mode.
       vi-ins-mode-string ((ins))
              Si la variable show-mode-in-prompt est activée, cette chaîne est
              affichée immédiatement avant la dernière ligne de la première
              invite quand le mode d'édition vi est activé et en mode insertion.
              La valeur est développée comme un raccourci clavier, donc le jeu
              standard de préfixes meta- ou Control- et de séquences de
              protections par contre-oblique est disponible. Utiliser les
              caractères de protection \1 et \2 pour ouvrir et fermer les
              séquences de caractères non imprimables, ce qui peut être utilisé
              pour inclure une suite de caractères de contrôle du terminal dans
              la chaîne de mode.
       visible-stats (Off)
              Si configurée à On, un caractère indiquant le type de fichier,
              comme signalé par stat(2) est ajouté aux noms de fichiers en
              affichant les complètements possibles.

   Constructions conditionnelles de readline
       Readline implémente un mécanisme inspiré des fonctionnalités de
       compilation conditionnelle du préprocesseur C qui permet d'effectuer le
       paramétrage des raccourcis clavier et des variables selon les résultats
       de tests. Il y a quatre directives d'analyse utilisées.

       $if    La structure $if permet de choisir les raccourcis selon le mode
              d'édition, le terminal utilisé ou l'application utilisant
              readline. Le texte du test, après n’importe quel opérateur de
              comparaison, va jusqu'à la fin de la ligne ; sauf notation
              contraire, aucun caractère n'est nécessaire pour le délimiter.

              mode   La forme mode= de la directive $if est utilisée pour
                     vérifier si readline est en mode emacs ou vi. Cela peut
                     être utilisé conjointement à la commande set keymap, par
                     exemple pour ne configurer les raccourcis des jeux de
                     raccourcis emacs-standard et emacs-ctlx que si readline
                     démarre en mode emacs.

              term   La forme term= peut être utilisée pour ajouter des
                     raccourcis clavier spécifiques au terminal, comme associer
                     des suites de touches produites par des touches de fonction
                     du terminal. Le mot à droite du signe = est comparé à la
                     fois au nom complet du terminal et à la portion de nom du
                     terminal qui précède le premier signe -. Cela permet, par
                     exemple, de faire correspondre sun avec à la fois sun et
                     sun-cmd.

              version
                     Le test de version peut être utilisé pour effectuer des
                     comparaisons avec des versions particulières de readline.
                     La version est développée selon la version actuelle de
                     readline. L'ensemble d'opérateurs de comparaison inclut =,
                     (et ==), !=, <=, >=, < et >. Le numéro de version fourni à
                     droite de l'opérateur consiste en un numéro de version
                     majeure, un point décimal facultatif et un numéro de
                     version mineure facultatif (par exemple, 7.1). Si la
                     version mineure est omise, on considère que c'est 0.
                     L'opérateur peut être séparé de la chaîne version et de
                     l'argument du numéro de version par une espace.

              application
                     La structure application est utilisée pour inclure des
                     paramétrages spécifiques à chaque application. Chaque
                     programme utilisant la bibliothèque readline configure un
                     nom d'application et un fichier d'initialisation peut
                     tester une valeur particulière. Ce peut être utilisé pour
                     associer des suites de touches à des fonctions utiles pour
                     un certain programme. Par exemple, les commandes suivantes
                     ajoutent une suite de touches qui protège le mot actuel ou
                     précédant dans bash :

                     $if Bash
                     # Protéger le mot actuel ou le précédant
                     "\C-xq": "\eb\"\ef\""
                     $endif

              variable
                     La structure variable fournit des tests d'égalité simples
                     pour les variables et les valeurs de readline. Les
                     opérateurs de comparaison permis sont =, ==, et !=. Le nom
                     de la variable doit être séparé de l'opérateur par une
                     espace ; l'opérateur peut être séparé de la valeur à droite
                     par une espace. Les variables de chaîne ainsi que les
                     variables booléennes peuvent être testées. Les variables
                     booléennes doivent être comparées aux valeurs on et off.

       $endif Cette commande, comme on l'a vu dans l'exemple ci-dessus, termine
              une commande $if.

       $else  Permet d'ajouter des commandes qui seront exécutées si un $if
              échoue.

       $include
              Cette directive prend un seul nom de fichier comme argument et y
              lit les commandes et les raccourcis. Par exemple, la directive
              suivante lirait le fichier /etc/inputrc :

              $include  /etc/inputrc

   Recherche
       Readline fournit des commandes de recherche au sein de l'historique de
       commandes (consultez HISTORIQUE ci-dessous) des lignes contenant une
       chaîne donnée. Il y a deux modes de recherche : incrémental et non
       incrémental.

       Les recherches incrémentales commencent avant même que l'utilisateur
       n'ait terminé de saisir la chaîne recherchée. À chaque caractère saisi,
       readline affiche l'élément suivant de l'historique qui correspond à la
       chaîne déjà entrée. Une recherche incrémentale nécessite seulement le
       nombre de caractères indispensable pour retrouver l'élément d'historique
       désiré. Les caractères se trouvant dans la variable isearch-terminators
       servent à terminer une recherche incrémentale. Si aucune valeur n'a été
       affectée à cette variable, les caractères Échappement (« Escape ») et
       Contrôle-J terminent une recherche incrémentale. Contrôle-G permet
       d'interrompre une recherche incrémentale et de restaurer la ligne
       originale. Lorsque la recherche est finie, l'élément d'historique
       contenant la chaîne désirée devient la ligne actuelle.

       Pour trouver les autres éléments correspondant dans la file d'historique,
       saisissez selon Contrôle-S ou Contrôle-R. Cela recherchera en avant ou en
       arrière dans l'historique l'élément suivant correspondant à la chaîne
       saisie jusque-là. Toute autre suite de touches associée à une commande
       readline interrompra la recherche et exécutera la commande. Par exemple,
       un changement de ligne interrompra la recherche et acceptera la ligne,
       exécutant ainsi la commande de la file d'historique.

       Readline se souvient de la dernière chaîne de recherche incrémentale. Si
       deux Contrôle-R sont tapés sans caractère pour définir une nouvelle
       recherche de chaîne, toute chaîne mémorisée sera utilisée.

       Les recherches non incrémentales lisent la chaîne désirée en entier avant
       de démarrer la recherche de correspondance dans la liste d'historique. La
       chaîne peut être saisie par l'utilisateur ou faire partie du contenu de
       la ligne actuelle.

   Noms des commandes readline
       Ce qui suit est une liste des noms de commandes et les suites de touches
       auxquelles elles sont associées par défaut. Les noms de commandes sans
       suite de touche les accompagnant ne sont pas associées par défaut. Dans
       les descriptions suivantes, le curseur (« point ») se rapporte à la
       position actuelle du curseur et la marque se rapporte à une position de
       curseur sauvegardée par la commande set-mark. Le texte entre le curseur
       et la marque est désigné comme la zone.

   Commandes de déplacement
       beginning-of-line (C-a)
              Reculer au début de la ligne actuelle.
       end-of-line (C-e)
              Avancer à 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ériques (lettres et chiffres).
       backward-word (M-b)
              Reculer jusqu'au début du mot actuel ou du précédent. Les mots
              sont composés de caractères alphanumériques (lettres et chiffres).
       shell-forward-word
              Avancer jusqu'à la fin du mot suivant. Les mots sont séparés par
              des métacaractères non protégés de l'interpréteur.
       shell-backward-word
              Reculer jusqu'au début du mot actuel ou du précédent. Les mots
              sont séparés par des métacaractères non protégés de
              l'interpréteur.
       previous-screen-line
              Tenter de déplacer le curseur vers la même colonne physique de
              l'écran sur la ligne physique précédente de l'écran. Cela n'aura
              pas l'effet désiré si la ligne actuelle de readline n'accepte pas
              sur d'une ligne physique ou si le but n'est pas supérieur à la
              longueur de l'invite plus la largeur de l'écran.
       next-screen-line
              Tenter de déplacer le curseur vers la même colonne de l'écran
              physique sur la ligne suivante de l'écran physique. Cela n'aura
              pas l'effet désiré si la ligne actuelle de readline n'accepte pas
              plus d'une ligne physique ou si la longueur de la ligne actuelle
              de readline n'est pas supérieure à la longueur de l'invite plus la
              largeur de l'écran.
       clear-display (M-C-l)
              Effacer l'écran et, si possible, le tampon de défilement du
              terminal, puis rafraîchir la ligne actuelle, en laissant la ligne
              actuelle au sommet de l'écran.
       clear-screen (C-l)
              Effacer l'écran, puis rafraîchir la ligne actuelle, en laissant la
              ligne actuelle au sommet de l'écran. S'il y a un argument,
              rafraîchir la ligne actuelle sans effacer l'écran.
       redraw-current-line
              Rafraîchir la ligne actuelle.

   Commandes de manipulation de l'historique
       accept-line (changement de ligne, retour chariot)
              Valider la ligne, sans se soucier de l'emplacement du curseur. Si
              la ligne n'est pas vide, l'ajouter à la file d'historique, sous
              contrôle de la variable HISTCONTROL. Si cette ligne est une ligne
              d'historique modifiée, restaurer cette dernière.
       previous-history (C-p)
              Récupérer la commande précédente de la file d'historique, en
              remontant dans la file.
       next-history (C-n)
              Récupérer la commande suivante dans la file d'historique, en
              descendant dans la file.
       beginning-of-history (M-<)
              Récupérer la première ligne de l'historique.
       end-of-history (M->)
              Retourner à la fin de l'historique de saisie, c'est-à-dire à la
              ligne en cours de saisie.
       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
              pour une chaîne fournie par l'utilisateur.
       non-incremental-forward-search-history (M-n)
              Rechercher une chaîne en avant dans l'historique, utiliser une
              recherche non incrémentale pour une chaîne fournie par
              l'utilisateur.
       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. C'est une
              recherche non incrémentale.
       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. C'est une
              recherche non incrémentale.
       history-substring-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. La chaîne
              recherchée peut trouver une correspondance n'importe où dans une
              ligne de l'historique. C'est une recherche non incrémentale.
       history-substring-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. La chaîne
              recherchée peut trouver une correspondance n'importe où dans une
              ligne de l'historique. C'est une recherche non incrémentale.
       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 n-ième mot de la
              commande précédente (les mots sont numérotés à partir de 0). Un
              argument négatif insère le n-ième mot en partant de la fin de la
              commande précédente. Une fois que l'argument n est traité,
              l'argument est extrait comme si le développement d'historique
              « !n » avait été indiqué.
       yank-last-arg (M-., M-_)
              Insérer le dernier argument de la commande précédente (le dernier
              mot de l'élément précédent de la file d'historique). Avec un
              argument numérique, se comporte exactement comme yank-nth-arg. Les
              appels successifs à yank-last-arg remontent dans la file
              d'historique en insérant le dernier mot (ou le mot indiqué par
              l'argument du premier appel) de chaque ligne tour à tour. Tous les
              arguments numériques fournis à ces appels successifs déterminent
              la direction de déplacement dans l'historique. Un argument négatif
              modifie la direction dans l'historique (en avant ou en arrière).
              Les outils de développement d'historique sont utilisés pour
              extraire le dernier mot, comme si le développement d'historique
              « !$ » avait été indiqué.
       shell-expand-line (M-C-e)
              Développer, comme le fait l'interpréteur, la ligne actuelle. Cela
              effectue le développement des alias et d'historique, ainsi que
              tous les développements de mot de l'interpréteur. Consultez
              ci-dessous DÉVELOPPEMENT DE L'HISTORIQUE, pour une description
              détaillée du développement de l'historique.
       history-expand-line (M-^)
              Effectuer le développement d'historique sur la ligne actuelle.
              Consultez ci-dessous DÉVELOPPEMENT DE L'HISTORIQUE, pour une
              description détaillée.
       magic-space
              Effectuer le développement de l'historique sur la ligne actuelle
              et insérer une espace. Consultez ci-dessous DÉVELOPPEMENT DE
              L'HISTORIQUE, pour une description détaillée.
       alias-expand-line
              Effectuer le développement des alias sur la ligne actuelle.
              Consultez ALIAS ci-dessus pour une description des développements
              d'alias.
       history-and-alias-expand-line
              Effectuer le développement de l'historique et des alias sur la
              ligne actuelle.
       insert-last-argument (M-., M-_)
              Un synonyme de yank-last-arg.
       operate-and-get-next (C-o)
              Valider la ligne actuelle pour exécution et récupérer de
              l'historique la ligne suivante liée à la ligne actuelle pour
              édition. Si un argument numérique est fourni, il spécifie l'entrée
              de l'historique à utiliser à la place de la ligne actuelle.
       edit-and-execute-command (C-x C-e)
              Appeler un éditeur sur la ligne de commande actuelle et exécuter
              le résultat comme une commande d'interpréteur. Bash tente
              d'appeler, dans cet ordre, $VISUAL, $EDITOR et emacs comme
              éditeur.

   Commande d'édition de texte
       end-of-file (généralement C-d)
              Le caractère indiquant la fin de ligne, comme défini, par exemple,
              par ``stty''.  Si ce caractère est lu alors qu’aucun caractère
              n’est sur la ligne, et que le curseur est au début de la ligne,
              readline l’interprète comme le fin de l’entrée et renvoie EOF.
       delete-char (C-d)
              Effacer le caractère sous le curseur. Si cette fonction est
              associée au même caractère que le caractère EOF du terminal, comme
              c’est souvent le cas avec C-d, consultez les effets dans le
              paragraphe précédent.
       backward-delete-char (Effacement ou « Rubout »)
              Effacer le caractère avant le curseur. Lorsque un argument
              numérique est indiqué, le texte effacé est sauvegardé dans le
              tampon circulaire.
       forward-backward-delete-char
              Effacer le caractère sous le curseur, sauf s'il est en fin de
              ligne, auquel cas le caractère avant le curseur est effacé.
       quoted-insert (C-q, C-v)
              Ajouter littéralement sur la ligne le caractère saisi suivant.
              Cela 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)
              Échanger les caractères se trouvant devant et sous le curseur. Le
              curseur est avancé d'un caractère. À la fin d'une ligne, les
              caractères échangés sont les deux précédents. Les arguments
              négatifs n'ont aucun effet.
       transpose-words (M-t)
              Déplace le mot avant le curseur au-delà du mot après le curseur et
              déplace aussi le curseur sur ce mot. Si le curseur est à la fin de
              la ligne, cela échange les deux derniers mots de la ligne.
       upcase-word (M-u)
              Transformer le mot actuel (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 actuel (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 actuel (ou du suivant). Avec
              un argument négatif, agir sur le mot précédent mais ne pas
              déplacer le curseur.
       overwrite-mode
              Basculer en mode d'écrasement. Avec un argument numérique
              explicite strictement positif, bascule en mode d'écrasement. Avec
              un argument numérique explicite négatif ou nul, bascule en mode
              d'insertion. Cette commande n'affecte que le mode emacs ; le mode
              vi écrase de façon différente. Chaque appel à readline() démarre
              en mode d'insertion. En mode d'écrasement, les caractères associés
              à self-insert remplacent le texte sous le curseur plutôt que de
              déplacer le texte vers la droite. Les caractères associés à
              backward-delete-char remplacent le caractère avant le curseur par
              une espace. Par défaut, cette commande n'est pas associée.

   Effacement et récupération
       kill-line (C-k)
              Effacer le texte depuis la position du curseur jusqu'à la fin de
              la ligne.
       backward-kill-line (C-x Effacement)
              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 la position du
              curseur. Le texte est sauvegardé dans le tampon circulaire.
       kill-whole-line
              Effacer toute la ligne sans tenir compte de la position du
              curseur.
       kill-word (M-d)
              Effacer le texte entre le curseur et la fin du mot actuel ou, si
              entre des mots, jusqu'à la fin du mot suivant. Les limites des
              mots sont identiques à celles utilisées par forward-word.
       backward-kill-word (M-Effacement)
              Effacer le mot sous le curseur. Les limites de mots sont
              identiques à celles utilisées par backward-word.
       shell-kill-word
              Effacer le texte entre le curseur et la fin du mot actuel ou, si
              entre des mots, jusqu'à la fin du mot suivant. Les limites des
              mots sont identiques à celles utilisées par shell-forward-word.
       shell-backward-kill-word
              Effacer le mot sous le curseur. Les limites de mots sont
              identiques à celles utilisées par shell-backward-word.
       unix-word-rubout (C-w)
              Effacer le mot sous le curseur, en utilisant une espace blanche
              comme limite de mot. Le texte effacé est sauvegardé dans le tampon
              circulaire.
       unix-filename-rubout
              Effacer le mot sous le curseur, en utilisant l'espace blanche et
              la barre oblique comme limites de mot. Le texte supprimé est
              sauvegardé dans le tampon circulaire.
       delete-horizontal-space (M-\)
              Effacer toutes les espaces blanches et les tabulations autour du
              curseur.
       kill-region
              Effacer le texte de la zone actuelle.
       copy-region-as-kill
              Copier le texte de la zone vers le tampon circulaire.
       copy-backward-word
              Copier le mot précédant le curseur dans le tampon circulaire. Les
              limites de mots sont identiques à celles de backward-word.
       copy-forward-word
              Copier le mot suivant le curseur dans le tampon circulaire. Les
              limites de mots sont identiques à celles de forward-word.
       yank (C-y)
              Récupérer le texte au sommet du tampon circulaire à la position du
              curseur dans le tampon.
       yank-pop (M-y)
              Exécuter une rotation du tampon circulaire et récupérer le texte
              situé à son nouveau sommet. Cela ne fonctionne qu'après yank ou
              yank-pop.

   Arguments numériques
       digit-argument (M-0, M-1, ..., M--)
              Ajouter ce chiffre à l'argument en cours de rédaction ou créer un
              nouvel argument. M-- crée un argument négatif.
       universal-argument
              Il s'agit d'une autre façon d'indiquer un argument. Si cette
              commande est suivie d'un ou plusieurs chiffres facultativement
              précédés d'un signe moins, ces chiffres définissent l'argument. Si
              la commande est suivie de chiffres, une nouvelle exécution de
              universal-argument termine l'argument numérique, mais est ignorée
              dans les autres cas. Par exception, si cette commande est suivie
              immédiatement par un caractère qui n'est ni un chiffre ni le signe
              moins, le compteur d'arguments de la commande suivante est
              multiplié par 4. Le compteur d'arguments est initialement à un,
              donc la première exécution de cette commande amène le compteur
              d'arguments à quatre, une seconde fois porte le compteur
              d'arguments à seize et ainsi de suite.

   Complètement
       complete (TAB)
              Essayer d'effectuer un complètement du texte situé avant le
              curseur. Bash effectue le complètement en considérant tour à tour
              le texte comme une variable (s'il commence par $), un nom
              d'utilisateur (s'il commence par ~), un nom de machine (s'il
              commence par @) ou une commande (y compris les alias et les
              fonctions). Si aucun ne correspond, un complètement de nom de
              fichier est essayé.
       possible-completions (M-?)
              Afficher les complètements possibles pour le texte situé avant le
              curseur.
       insert-completions (M-*)
              Insérer avant le curseur l'ensemble des complètements qui auraient
              été produits par possible-completions.
       menu-complete
              Analogue à complete, mais en remplaçant le mot à compléter par une
              seule correspondance de la liste des complètements possibles. Des
              exécutions répétées de menu-complete parcourent la liste des
              complètements possibles, en insérant chaque correspondance tour à
              tour. À la fin de la liste des complètements, une alarme est émise
              (selon la configuration de bell-style) et le texte original est
              restauré. Un argument de n déplace de n positions dans la liste
              des correspondances. Un argument négatif peut être utilisé pour
              revenir en arrière dans la liste. Cette commande est destinée à
              être associée à la touche TAB, mais ne l'est pas par défaut.
       menu-complete-backward
              Identique à menu-complete, mais se déplace en arrière dans la
              liste des complètements possibles, comme si un argument négatif
              avait été passé à menu-complete. Cette commande n'est associée à
              aucune touche par défaut.
       delete-char-or-list
              Effacer le caractère sous le curseur sauf au début ou en fin de
              ligne (comme delete-char). En fin de ligne, se comporte comme
              possible-completions. Cette commande n'est associée à aucune
              touche par défaut.
       complete-filename (M-/)
              Essayer le complètement des noms de fichiers sur le texte situé
              avant le curseur.
       possible-filename-completions (C-x /)
              Afficher les complètements possibles du texte situé avant le
              curseur, traité comme un nom de fichier.
       complete-username (M-~)
              Essayer le complètement sur le texte situé avant le curseur, en le
              traitant comme un nom d'utilisateur.
       possible-username-completions (C-x ~)
              Afficher les complètements possibles du texte situé avant le
              curseur, en le traitant comme un nom d'utilisateur.
       complete-variable (M-$)
              Essayer le complètement sur le texte situé avant le curseur, en le
              traitant comme une variable de l'interpréteur.
       possible-variable-completions (C-x $)
              Afficher les complètements possibles du texte situé avant le
              curseur, en le traitant comme une variable de l'interpréteur.
       complete-hostname (M-@)
              Essayer le complètement sur le texte situé avant le curseur, en le
              traitant comme un nom de machine.
       possible-hostname-completions (C-x @)
              Afficher les complètements possibles du texte situé avant le
              curseur, en le traitant comme un nom de machine.
       complete-command (M-!)
              Essayer le complètement sur le texte situé avant le curseur, en le
              traitant comme un nom de commande. Le complètement des commandes
              essaie de faire correspondre le texte, dans cet ordre, aux alias,
              mots réservés, fonctions de l'interpréteur, commandes internes de
              l'interpréteur et finalement les noms de fichiers exécutables.
       possible-command-completions (C-x !)
              Afficher les complètements possibles du texte situé avant le
              curseur, en le traitant comme un nom de commande.
       dynamic-complete-history (M-TAB)
              Essayer le complètement du texte situé avant le curseur, en le
              comparant aux lignes de la file d'historique lui correspondant
              pour les complètements possibles.
       dabbrev-expand
              Essayer le menu de complètement du texte situé avant le curseur,
              en le comparant aux lignes de la file d'historique lui
              correspondant pour les complètements possibles.
       complete-into-braces (M-{)
              Effectuer un complètement en noms de fichiers et insérer la liste
              des complètements possibles entre accolades afin que la liste soit
              exploitable par l'interpréteur (consultez Développement des
              accolades ci-dessus).

   Macros clavier
       start-kbd-macro (C-x ()
              Démarrer la mémorisation dans la macro en cours des caractères
              tapés.
       end-kbd-macro (C-x ))
              Arrêter la mémorisation dans la macro en cours des caractères
              saisis et conserver la définition.
       call-last-kbd-macro (C-x e)
              Réexécuter la dernière macro définie, en agissant comme si les
              caractères contenus dans cette macro étaient saisis au clavier.
       print-last-kbd-macro ()
              Afficher la dernière macro de clavier définie, mise en forme de
              façon à être incorporée dans un fichier inputrc.

   Divers
       re-read-init-file (C-x C-r)
              Lire le contenu du fichier inputrc et prendre en compte tous
              raccourcis ou affectations de variables qui s'y trouvent.
       abort (C-g)
              Abandonner l'édition en cours et émettre une alarme de terminal
              (selon la configuration de la variable bell-style).
       do-lowercase-version (M-A, M-B, M-x, ...)
              Si le caractère x précédé de Méta est en majuscule, exécuter la
              commande qui est associée aux caractères minuscules
              correspondants. Le comportement est non défini si x est déjà en
              minuscule.
       prefix-meta (ESC)
              Considérer le prochain caractère saisi comme un Méta.  ESC f est
              équivalent à Meta-f.
       undo (C-_, C-x C-u)
              Fonction d'annulation incrémentale, chaque ligne étant mémorisée
              séparément.
       revert-line (M-r)
              Annuler toutes les modifications sur cette ligne. C’est équivalent
              à répéter undo suffisamment de fois pour ramener la ligne à son
              état initial.
       tilde-expand (M-&)
              Effectuer le développement du tilde sur le mot actuel.
       set-mark (C-@, M-<space>)
              Placer la marque à la position actuelle du curseur. Si un argument
              numérique est fourni, la marque est posée à la position
              correspondante.
       exchange-point-and-mark (C-x C-x)
              Échanger le curseur et la marque. La position actuelle du curseur
              est configurée à la position sauvegardée précédemment et
              l'ancienne position du curseur est mémorisée comme la marque.
       character-search (C-])
              Un caractère est lu et le curseur déplacé à l'occurrence suivante
              de ce caractère. Un argument négatif recherche les occurrences
              précédentes.
       character-search-backward (M-C-])
              Un caractère est lu et le curseur déplacé à l'occurrence
              précédente de ce caractère. Un argument négatif recherche les
              occurrences suivantes.
       skip-csi-sequence
              Lire suffisamment de caractères pour englober une suite
              multitouche comme celles définies pour des touches comme Début et
              Fin. De telles suites commencent par un indicateur de suite de
              contrôle (« control sequence indicator » ou CSI), habituellement
              ESC-[.  Si cette suite est associée à "\[", les touches qui
              produisent de telles suites n'auront pas d'effet à moins d'être
              explicitement associées à une commande readline, au lieu d'insérer
              des caractères parasites dans le tampon d'édition. N'est associée
              à aucune touche par défaut, mais est souvent associée à ESC-[.
       insert-comment (M-#)
              Sans argument numérique, la valeur de la variable comment-begin de
              readline est insérée au début de la ligne actuelle. Si un argument
              numérique est fourni, cette commande agit comme une bascule : si
              les caractères du début de ligne ne correspondent pas à la valeur
              de comment-begin, la valeur est insérée, sinon, les caractères de
              comment-begin sont effacés du début de la ligne. Dans les deux
              cas, la ligne est acceptée comme si un changement de ligne avait
              été saisi. La valeur par défaut de comment-begin conduit cette
              commande à transformer la ligne actuelle de l'interpréteur en
              commentaire. Si un argument numérique conduit à l'effacement du
              caractère de commentaire, la ligne sera exécutée par
              l'interpréteur.
       glob-complete-word (M-g)
              Le mot avant le curseur est traité comme un motif pour un
              développement de chemin, avec un astérisque implicitement ajouté.
              Ce motif est utilisé pour produire une liste de noms de fichiers
              correspondants pour de possibles complètements.
       glob-expand-word (C-x *)
              Le mot précédant le curseur est considéré comme un motif de
              développement de chemin et la liste des fichiers correspondants
              est insérée à sa place. Si un argument numérique est fourni, un
              astérisque est ajouté avant le développement du chemin.
       glob-list-expansions (C-x g)
              La liste des développements qui auraient été produits par
              glob-expand-word est affichée et la ligne est rafraîchie. Si un
              argument numérique est fourni, un astérisque est ajouté devant le
              développement du chemin.
       dump-functions
              Afficher toutes les fonctions et leurs raccourcis clavier sur le
              flux de sortie de readline. Si un argument numérique est fourni,
              la sortie est mise en forme de façon à être incorporée dans un
              fichier inputrc.
       dump-variables
              Afficher toutes les variables readline modifiables et leurs
              valeurs sur le flux de sortie de readline. Si un argument
              numérique est fourni, la sortie est mise en forme de façon à être
              incorporée dans un fichier inputrc.
       dump-macros
              Afficher toutes les suites de touches readline associées à des
              macros et les chaînes auxquelles elles correspondent. Si un
              argument numérique est fourni, la sortie est mise en forme de
              façon à être incorporée dans un fichier inputrc.
       display-shell-version (C-x C-v)
              Afficher des informations sur la version actuelle de bash.

   Complètement programmable
       Lorsqu'un complètement de mot est tenté pour un argument d'une commande
       pour laquelle une spécification de complètement a été définie en
       utilisant la commande interne complete (consultez COMMANDES INTERNES DE
       L'INTERPRÉTEUR ci-dessous), les outils de complètement programmables sont
       appelés.

       En premier lieu, le nom de la commande est identifié. Si le mot de
       commande est vide (complètement essayé en début de ligne vide), toutes
       les spécifications de complètement définies par l'option -E de complete
       sont utilisées. Si une spécification de complètement a été définie pour
       cette commande, elle est utilisée pour produire la liste des
       complètements possibles pour le mot. Si le mot de commande est un chemin
       d'accès complet, on cherche en premier lieu une spécification de
       complètement pour le chemin d'accès complet. Si aucune spécification de
       complètement n'est trouvée pour le chemin d'accès complet, une tentative
       est effectuée pour trouver une spécification de complètement pour la
       partie située après la barre oblique finale. Si ces recherches ne donnent
       aucun résultat sous forme de spécification de complètement, toutes les
       spécifications de complètement définies par l'option -D de complete sont
       utilisées par défaut. S'il n'existe pas de spécification de complètement
       par défaut, bash tente un développement d'alias sur le mot de commande en
       dernier ressort et tente de trouver une spécification de complètement
       pour le mot de commande à partir de n'importe quel développement ayant
       réussi.

       Une fois qu'une spécification de complètement a été trouvée, elle est
       utilisée pour produire la liste des mots correspondants. Si aucune
       spécification de complètement n'est trouvée, le complètement par défaut
       de bash, tel que décrit ci-dessus dans Complètement est effectué.

       Tout d'abord, les actions définies par la spécification de complètement
       sont utilisées. Seules les correspondances préfixées par le mot à
       compléter sont renvoyées. Lorsque l'option -f ou -d sont utilisées pour
       le complètement des noms de fichier ou de répertoire, la variable
       d'interpréteur FIGNORE est utilisée pour filtrer les correspondances.

       Tous les complètements indiqués par le motif de développement de chemin
       de l'option -G sont ensuite produits. Il n'est pas nécessaire que les
       mots produits par le motif correspondent au mot à compléter. La variable
       de l'interpréteur GLOBIGNORE n'est pas utilisée pour filtrer les
       correspondances, mais la variable FIGNORE est utilisée.

       Ensuite, la chaîne indiquée comme argument à l'option -W est prise en
       compte. Cette chaîne est tout d'abord découpée en utilisant les
       caractères de la variable spéciale IFS comme délimiteurs. Les protections
       de l'interpréteur sont prises en compte. Chaque mot est ensuite développé
       en utilisant les développements d'accolades, du tilde, des paramètres et
       des variables, de même que la substitution de commande et le
       développement arithmétique comme décrit ci-dessus dans DÉVELOPPEMENTS.
       Les résultats sont découpés en utilisant les règles décrites ci-dessus
       dans Découpage en mots. Les résultats du développement sont comparés au
       mot à compléter en considérant ce dernier comme préfixe et les mots
       correspondants deviennent les complètements possibles.

       Après la création de ces correspondances, toute fonction de
       l'interpréteur ou commande indiquée avec les options -F et -C est
       appelée. Lorsque la commande ou la fonction est appelée, les variables
       COMP_LINE, COMP_POINT, COMP_LINKEY, et COMP_POINTYPE se voient affectées
       de valeurs comme décrit ci-dessus dans Variables de l'interpréteur. Si
       une fonction de l'interpréteur est appelée, les variables COMP_WORDS et
       COMP_CWORD sont également créées. Lorsqu'une fonction ou une commande est
       appelée, le premier argument ($1) est le nom de la commande dont les
       arguments doivent être complétés, le deuxième argument ($2) est le mot à
       compléter et le troisième argument ($3) est le mot précédant celui devant
       être complété sur la ligne de commande actuelle. Aucun filtrage des
       complètements produits pour le mot à compléter n'est effectué ; la
       fonction ou la commande a toute liberté dans la production des
       correspondances.

       Toute fonction indiquée avec -F est appelée en premier. La fonction peut
       utiliser tous les outils de l'interpréteur, incluant la commande interne
       compgen décrite ci-dessous, pour produire les correspondances. Elle doit
       mettre les complètements possibles dans la variable tableau COMPREPLY, un
       par élément de tableau.

       Ensuite, toute commande indiquée avec l'option -C est appelée dans un
       environnement équivalent à la substitution de commande. Elle devrait
       afficher une liste des complètements possibles, un par ligne, sur la
       sortie standard. Si nécessaire, une contre-oblique peut être utilisée
       pour protéger un caractère de changement de ligne.

       Après la création de tous les complètements possibles, tout filtre,
       indiqué avec l'option -X, est appliqué à la liste. Ce filtre est un motif
       comme dans le développement des chemins ; un & dans le motif est remplacé
       par le texte du mot en cours de complètement. Un & littéral peut être
       protégé par une contre-oblique ; la contre-oblique est supprimée avant la
       tentative de mise en correspondance. Tout complètement qui correspond au
       motif sera supprimé de la liste. Un ! au début du motif provoque la
       négation de ce motif ; dans ce cas, tout complètement ne correspondant
       pas au motif sera supprimé de la liste. Si l'option d'interpréteur
       nocasematch est activée, la mise en correspondance est effectuée sans
       tenir compte de la casse des caractères alphabétiques.

       Finalement, tous préfixe et suffixe indiqués avec les options -P et -S
       sont ajoutés à chacun des éléments de la liste de complètement et le
       résultat est renvoyé au programme de complètement de readline comme étant
       la liste des complètements possibles.

       Si les opérations précédemment appliquées ne produisent aucune
       correspondance et si l'option -o dirnames a été fournie à complete
       lorsque la spécification de complètement a été définie, le complètement
       des noms de répertoire est tenté.

       Si l'option -o plusdirs a été fournie à complete lors de la définition de
       la spécification de complètement, le complètement des noms de répertoires
       est tenté et toute correspondance est ajoutée aux résultats des autres
       actions.

       Par défaut, si une spécification de complètement est trouvée, tout ce
       qu'elle produit est renvoyé au programme de complètement comme un jeu
       complet des complètements possibles. Les complètements par défaut de bash
       ne sont pas tentés et le complètement de fichiers par défaut de readline
       est désactivé. Si l'option -o bashdefault a été fournie à complete lors
       de la définition de la spécification de complètement, les complètements
       par défaut de bash sont tentés si la spécification de complètement ne
       produit aucune correspondance. Si l'option -o default a été fournie à
       complete lors de la définition de la spécification de complètement, le
       complètement par défaut de readline sera effectué si la spécification de
       complètement (et, si tentés, les complètements par défaut de bash) ne
       produit aucune correspondance.

       Lorsqu'une spécification de complètement indique qu'un complètement de
       nom de répertoire est souhaité, les fonctions de complètement
       programmable forcent readline à ajouter une barre oblique pour compléter
       les noms qui sont des liens symboliques vers des répertoires, selon la
       valeur de la variable mark-directories de readline, indépendamment du
       paramétrage de la variable mark-symlinked-directories de readline.

       La modification dynamique des complètements est également possible. C'est
       particulièrement utile combiné avec un complètement par défaut indiqué à
       l'aide de complete -D. Les fonctions de l'interpréteur exécutés comme
       gestionnaires de complètement permettent d'annoncer que le complètement
       devrait être réessayé en renvoyant un état final de 124. Si une fonction
       de l'interpréteur renvoie 124, et modifie la spécification de
       complètement associée à la commande sur laquelle le complètement est
       essayé (fournie comme premier argument quand la fonction est exécutée),
       le complètement programmable recommence depuis le début, en essayant de
       trouver une nouvelle spécification de complètement pour cette commande.
       Un jeu de complètements peut ainsi être construit dynamiquement lorsque
       le complètement est essayé, plutôt que d'être chargé entièrement au
       début.

       Par exemple, en supposant l'existence d'une bibliothèque de
       spécifications de complètement, chacune conservée dans un fichier
       correspondant au nom de la commande, la fonction de complètement par
       défaut suivante chargerait les complètements de façon dynamique :

       _completion_loader()
       {
            . "/etc/bash_completion.d/$1.sh" >/dev/null 2>&1 && return 124
       }
       complete -D -F _completion_loader -o bashdefault -o default


HISTORIQUE
       Quand l'option -o history de la commande interne set est activée,
       l'interpréteur donne accès à un historique des commandes, c'est-à-dire la
       liste des commandes précédemment utilisées. La valeur de la variable
       HISTSIZE est utilisée comme nombre de commandes à sauvegarder dans la
       file d'historique. Le texte des HISTSIZE dernières commandes (par défaut
       500) est sauvegardé. L'interpréteur conserve chaque commande dans la file
       d'historique avant le développement des paramètres et des variables
       (consultez DÉVELOPPEMENTS ci-dessus) mais après avoir effectué le
       développement de l'historique, selon les valeurs des variables de
       l'interpréteur HISTIGNORE 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). Le
       fichier désigné par la valeur de HISTFILE est tronqué si nécessaire, pour
       ne pas contenir plus de lignes que le nombre précisé par HISTFILESIZE. Si
       HISTFILESIZE est détruite, ou définie à NULL, une valeur non numérique ou
       une valeur numérique strictement inférieure à zéro, le fichier
       d’historique n’est pas tronqué. Quand le fichier d'historique est lu, les
       lignes commençant par le caractère de commentaire d'historique suivi
       immédiatement par un chiffre sont considérées comme des horodatages de la
       ligne d'historique précédente. Ces horodatages sont facultativement
       affichés en fonction de la valeur de la variable HISTTIMEFORMAT.
       Lorsqu'un interpréteur avec historique activé se termine, les HISTSIZE
       dernières lignes de la file d'historique sont copiées dans le fichier
       HISTFILE. Si l'option d'interpréteur histappend est activée (consultez la
       description de shopt dans COMMANDES INTERNES DE L'INTERPRÉTEUR
       ci-dessous), les lignes sont ajoutées au fichier d'historique, sinon le
       fichier est écrasé. Si HISTFILE est inexistante ou si le fichier
       d'historique n'est pas accessible en écriture, l'historique n'est pas
       sauvegardé. Si la variable HISTTIMEFORMAT est configurée, les horodatages
       sont écrits dans le fichier d'historique, repérés par le caractère de
       commentaire d'historique, afin d'être conservés au fur et à mesure des
       sessions de l'interpréteur. Le caractère de commentaire d'historique est
       utilisé pour distinguer l'horodatage des autres lignes de l'historique.
       Après la sauvegarde de l'historique, le fichier d'historique est tronqué
       pour ne pas contenir plus de HISTFILESIZE lignes. Si HISTFILESIZE est
       détruite, ou définie à NULL, une valeur non numérique ou une valeur
       numérique inférieure à zéro, le fichier d’historique n’est pas tronqué.

       La commande interne fc (consultez COMMANDES INTERNES DE L'INTERPRÉTEUR
       ci-dessous) permet d'afficher, d'éditer ou de réexécuter une partie de la
       file d'historique. La commande interne history permet d'afficher la file
       d'historique et de manipuler le fichier d'historique. Quelque soit le
       mode d'édition en ligne de commande, des commandes de recherche donnent
       accès à la file d'historique.

       L'interpréteur permet de configurer quelles commandes seront sauvegardées
       dans la file d'historique. Les variables HISTCONTROL et HISTIGNORE
       peuvent être configurées pour conduire l'interpréteur à ne sauvegarder
       qu'un sous-ensemble des commandes saisies. L'option d'interpréteur
       cmdhist, si activée, conduit l'interpréteur à essayer de sauvegarder
       chaque ligne d'une commande multiligne dans le même élément de
       l'historique, en ajoutant des points-virgules si nécessaire pour
       préserver l'exactitude de la syntaxe. L'option d'interpréteur lithist
       conduit l'interpréteur à sauvegarder les commandes avec des changements
       de ligne incorporés plutôt que des points-virgules. Consultez ci-dessous
       la description de la commande interne shopt dans COMMANDES INTERNES DE
       L'INTERPRÉTEUR pour des détails sur la création et la destruction des
       options d'interpréteur.

DÉVELOPPEMENT DE L'HISTORIQUE
       L'interpréteur propose des possibilités de développement de l'historique
       qui sont semblables à celles de csh. Ce paragraphe décrit quelles
       syntaxes sont disponibles. Cette fonctionnalité est activée par défaut
       dans les interpréteurs interactifs et peut être désactivée en utilisant
       l'option +H de la commande interne set (consultez COMMANDES INTERNES DE
       L'INTERPRÉTEUR ci-dessous). Les interpréteurs non interactifs
       n'effectuent pas de développement d'historique par défaut.

       Le développement de l'historique permet d'insérer des mots de la file
       d'historique dans le flux de saisie, facilitant la répétition de
       commandes, l'insertion des arguments d'une ligne antérieure dans la
       saisie en cours ou la correction rapide d'erreurs dans les commandes
       précédentes.

       Le développement de l'historique est effectué immédiatement après la
       lecture d'une ligne complète, avant que l'interpréteur ne la décompose en
       mots. Il est effectué sur chaque ligne individuellement sans prendre en
       compte une protection sur les lignes précédentes. Il se déroule en deux
       parties. La première consiste à déterminer la ligne de la file
       d'historique à utiliser pour les substitutions, la seconde permet de
       sélectionner les parties de la ligne à inclure dans la ligne actuelle. La
       ligne sélectionnée dans l'historique est l'événement et les parties de
       cette ligne à réutiliser sont des mots. Plusieurs modificateurs
       permettent de manipuler les mots sélectionnés. La ligne est découpée en
       mots de la même façon que lors de la lecture d'une saisie, ainsi
       plusieurs mots séparés par des métacaractères et encadrés par des
       guillemets sont considérés comme un unique mot. Le développement de
       l'historique est introduit par l'apparition du caractère de
       développement, qui est ! par défaut. Seules la contre-oblique (\) et les
       guillemets simples permettent de protéger le caractère de développement
       de l'historique, mais le caractère de développement de l'historique est
       aussi traité comme protégé s'il précède immédiatement le guillemet double
       fermant dans une chaîne entre guillemets doubles.

       Plusieurs caractères empêchent le développement de l'historique s'ils se
       trouvent immédiatement après le caractère de développement de
       l'historique, même s'il n'est pas protégé : espace, tabulation,
       changement de ligne, retour chariot et =. Si l'option d'interpréteur
       extglob est activée, ( empêchera aussi le développement.

       Plusieurs options d'interpréteur, configurables avec la commande interne
       shopt, permettent d'ajuster le comportement du développement de
       l'historique. Si l'option d'interpréteur histverify est activée
       (consultez la description de la commande interne shopt ci-dessous) et si
       readline est utilisée, les substitutions d'historique ne sont pas
       transmises tout de suite à l'analyseur de l'interpréteur. À la place, la
       ligne développée est rechargée dans le tampon d'édition de readline pour
       permettre des modifications ultérieures. Si readline est utilisée et si
       l'option histreedit est activée, une substitution d'historique qui échoue
       est rechargée dans la mémoire tampon de readline pour correction.
       L'option -p de la commande interne history peut servir à examiner ce
       qu'une substitution donnera avant de l'employer réellement. L'option -s
       de la commande interne history permet d'ajouter des commandes à la fin de
       la file d'historique sans les avoir effectivement exécutées, afin
       qu'elles soient disponibles pour des rappels ultérieurs.

       L'interpréteur offre le contrôle des divers caractères utilisés par le
       mécanisme de développement de l'historique (consultez la description de
       histchars ci-dessus dans Variables de l'interpréteur). L'interpréteur
       utilise le caractère de commentaire d'historique pour repérer
       l'horodatage lors de l'écriture du fichier d'historique.

   Indicateur d'événement
       Un indicateur d'événement est une référence à un élément ligne de
       commande dans la file d'historique. Sauf s'il s'agit d'une référence
       absolue, les événements sont relatifs à la position actuelle dans la file
       d'historique.

       !      Débute une substitution d'historique, sauf s'il est suivi par un
              blanc, changement de ligne, retour chariot, = ou ( (lorsque
              l'option d'interpréteur extglob est activée en utilisant la
              commande interne shopt).
       !n     Se rapporte à la ligne de commande n.
       !-n    Se rapporte à la commande actuelle moins n.
       !!     Se rapporte à la commande précédente. C'est un synonyme de
              « !-1 ».
       !chaîne
              Se rapporte à la commande la plus récente précédant la position
              actuelle dans la liste d'historique commençant par chaîne.
       !?chaîne[?]
              Se rapporte à la commande la plus récente précédant la position
              actuelle dans la liste d'historique contenant chaîne. Le ? final
              peut être omis si chaîne est immédiatement suivie d'un changement
              de ligne. Si chaîne est absente, la chaîne de la dernière
              recherche est utilisée ; c'est une erreur s'il n'y a pas de chaîne
              de recherche précédente.
       ^chaîne_1^chaîne_2^
              Substitution rapide. Répéter la commande précédente en remplaçant
              chaîne_1 par chaîne_2. Équivalent à « !!:s^chaîne_1^chaîne_2^ »
              (consultez Modificateurs ci-dessous).
       !#     La ligne entière tapée jusqu'à présent.

   Indicateurs de mots
       Ces indicateurs servent à sélectionner les mots désirés dans un
       événement. 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
       noté 0 (zéro). Les mots sont insérés dans la ligne actuelle, séparés par
       des espaces.

       0 (zéro)
              Le zéroième mot. Pour l'interpréteur, c'est le nom de la commande.
       n      Le n-ième mot.
       ^      Le premier argument, c'est-à-dire le mot 1.
       $      Le dernier mot. C’est généralement le dernier argument, mais qui
              sera développé en zéroième mot s’il n’y a qu’un seul mot sur la
              ligne.
       %      Le premier mot correspondant à la recherche « ?chaîne? » la plus
              récente, si la chaîne de recherche débute par un caractère qui
              fait partie d'un mot.
       x-y    Un intervalle de mots, « -y » permet d'abréger « 0-y ».
       *      Tous les mots sauf le zéroième. C'est un synonyme pour « 1-$ ». Il
              n'est pas erroné d'utiliser * s'il n'y a qu'un mot dans
              l'événement ; la chaîne vide est renvoyée dans ce cas.
       x*     Abréviation de x-$.
       x-     Abréviation de x-$ comme x*, mais sans le dernier mot. Si x est
              absent, la valeur par défaut est 0.

       Si un indicateur de mot est fourni sans indication d'événement, la
       dernière commande est utilisée.

   Modificateurs
       Après un indicateur de mot facultatif, une suite d'un ou plusieurs des
       modificateurs suivants peut apparaître, chacun précédé par un « : ». Cela
       modifie ou corrige le ou les mots sélectionnés à partir de l’événement de
       l'historique.

       h      Éliminer la fin du chemin d'accès, en ne gardant que le début.
       t      Supprimer tout le début d'un chemin d'accès, en ne gardant que la
              fin.
       r      Supprimer un suffixe final de la forme .xxx, en ne gardant que le
              nom de base.
       e      Supprimer tout sauf le suffixe final.
       p      Afficher la nouvelle commande sans l'exécuter.
       q      Protéger les mots substitués, pour éviter des substitutions
              futures.
       x      Protéger les mots substitués comme avec q, mais avec séparation
              des mots aux blancs et changements de ligne. Les modificateurs q
              et x s'excluent mutuellement ; le dernier fourni est utilisé.
       s/ancien/nouveau/
              Remplacer par nouveau la première occurrence de ancien sur la
              ligne d'événement. Tout caractère peut être utilisé comme
              délimiteur à 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 avec une seule
              contre-oblique. Si & apparaît dans nouveau, il est remplacé par
              ancien. Une seule contre-oblique protégera le &. Si ancien est
              NULL, il est configuré au dernier ancien substitué ou si aucune
              substitution n'a eu lieu précédemment, à la dernière chaîne dans
              une recherche !?chaîne[?]. Si nouveau est NULL, chaque
              correspondance à ancien est supprimée.
       &      Répéter la substitution précédente.
       g      Appliquer les modifications sur toute la ligne d'événements. C'est
              utilisé conjointement à « :s » (par exemple
              « :gs/ancien/nouveau/ ») ou « :& ». Si utilisé avec « :s », tout
              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énements. Un a peut être utilisé en tant que synonyme de
              g.
       G      Appliquer une fois le modificateur « s » ou « & » suivant à tous
              les mots de la ligne d'événement.

COMMANDES INTERNES DE L'INTERPRÉTEUR
       Sauf indication contraire, chaque commande interne décrite dans ce
       paragraphe comme acceptant des options précédées par - accepte également
       la notation -- pour signaler la fin des options. Les commandes internes
       :, true, false et test/[ n'acceptent aucune option et ne traitent pas --
       particulièrement. Les commandes internes exit, logout, return, break,
       continue, let et shift acceptent et traitent les arguments commençant par
       - sans avoir besoin de --. Les autres commandes internes qui acceptent
       les arguments mais qui ne sont pas déclarés explicitement comme acceptant
       des options considèrent les arguments commençant par - comme des options
       non valides, donc -- est obligatoire pour éviter cette interprétation.
       : [arguments]
              Sans effet ; cette commande ne fait rien d'autre que développer
              les arguments et effectuer toute redirection indiquée. L'état
              renvoyé est 0.

        .  fichier [arguments]
       source fichier [arguments]
              Lire et exécuter les commandes du fichier dans l'environnement de
              l'interpréteur actuel, puis renvoyer l'état final de la dernière
              commande exécutée depuis fichier. Si le nom du fichier ne contient
              pas de barre oblique, les chemins d'accès contenus dans PATH sont
              parcourus pour rechercher le répertoire contenant le fichier.
              Lorsqu'il est recherché dans PATH le fichier n'a pas besoin d'être
              exécutable. Lorsque bash n'est pas en mode POSIX, le répertoire de
              travail actuel est finalement examiné si aucun fichier n'est
              trouvé dans PATH. Si l'option sourcepath de la commande interne
              shopt est désactivée, le PATH n'est pas parcouru. Si des arguments
              sont fournis, ils sont transmis dans les paramètres positionnels
              lorsque le fichier est exécuté. Sinon les paramètres positionnels
              ne sont pas modifiés. Si l'option -T est activée, source hérite de
              toutes les captures de DEBUG ; si elle ne l'est pas, toutes les
              chaînes de capture de DEBUG sont sauvegardées et restaurées autour
              de l'appel à source, et source détruit les captures de DEBUG lors
              de son exécution. Si -T n'existe pas et si le fichier venant de la
              source modifie la capture de DEBUG, la nouvelle valeur est
              conservée quand source se termine. L'état renvoyé est l'état de la
              dernière commande terminée au sein du script (0 si aucune commande
              n'a été exécutée) et faux si le fichier n'est pas trouvé ou ne
              peut être lu.

       alias [-p] [nom[=valeur] ...]
              La commande alias sans argument ou avec l'option -p affiche sur la
              sortie standard la liste des alias actuellement définis, sous la
              forme nom=valeur. Lorsque des arguments sont fournis, un alias est
              créé pour chaque nom auquel on a donné une valeur. Une espace
              finale dans une valeur conduira à la recherche d'alias dans le mot
              suivant lors du développement de l'alias. Pour tous les noms sans
              valeur fournie dans la liste d'arguments, le nom et la valeur de
              l'alias sont affichés. La commande alias renvoie vrai, à moins
              qu'un nom n'ait été indiqué pour lequel aucun alias n'a été
              défini.

       bg [tâche ...]
              Reprendre en arrière-plan chaque tâche suspendue, comme si elle
              avait été lancée avec &. Si aucune tâche n'est précisée, la notion
              d'interpréteur de tâche actuelle est utilisée. bg tâche renvoie 0
              sauf si le contrôle des tâches est désactivé, ou, quand le
              contrôle des tâches est activé, si une tâche précisée n'a pas été
              trouvée ou a été lancée sans contrôle de tâches.

       bind [-m jeu_de_raccourcis] [-lpsvPSVX]
       bind [-m jeu_de_raccourcis] [-q fonction] [-u fonction] [-r
       suite_de_touches]
       bind [-m jeu_de_raccourcis] -f fichier
       bind [-m jeu_de_raccourcis] -x
       suite_de_touches:commande_de_l'interpréteur
       bind [-m jeu_de_raccourcis] suite_de_touches:nom_de_fonction
       bind [-m jeu_de_raccourcis] suite_de_touches:commande_readline
              Afficher les associations de touches readline actuelles et les
              raccourcis de fonctions, associer une suite de touches à une
              fonction ou une macro readline ou créer une variable readline.
              Chaque argument qui n'est pas une option est une commande comme
              elle devrait apparaître dans .inputrc, mais chaque raccourci ou
              commande doit être fourni comme un argument indépendant ; par
              exemple « "\C-x\C-r": re-read-init-file ». Les options, si
              fournies, ont les significations suivantes :
              -m jeu_de_raccourcis
                     Utiliser le jeu_de_raccourcis comme jeu de raccourcis
                     devant être concerné par les raccourcis ultérieurs. Les
                     noms de jeu_de_raccourcis possibles sont emacs,
                     emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move,
                     vi-command et vi-insert. vi est équivalent à vi-command
                     (vi-move est aussi un synonyme) ; emacs est équivalent à
                     emacs-standard.
              -l     Afficher la liste des noms de toutes les fonctions
                     readline.
              -p     Afficher les noms des fonctions readline et leurs
                     raccourcis de façon à pouvoir les relire.
              -P     Afficher les noms des fonctions readline et leurs
                     raccourcis.
              -s     Afficher les suites de touches readline associées aux
                     macros et les chaînes correspondantes, de façon à pouvoir
                     les relire.
              -S     Afficher les suites de touches readline associées aux
                     macros et les chaînes correspondantes.
              -v     Afficher les noms des variables readline et leurs valeurs
                     de façon à pouvoir les relire.
              -V     Afficher les noms des variables readline et leurs valeurs.
              -f fichier
                     Lire les raccourcis clavier dans fichier.
              -q fonction
                     Rechercher les touches permettant d'appeler la fonction
                     indiquée.
              -u fonction
                     Dissocier toutes les touches associées à fonction.
              -r suite_de_touches
                     Supprimer tout raccourci actuel pour la suite_de_touches.
              -x suite_de_touches:commande_de_l'interpréteur
                     Conduire la commande_de_l'interpréteur à être exécutée
                     chaque fois que la suite_de_touches est saisie. Quand la
                     commande_de_l'interpréteur est exécutée, l'interpréteur
                     configure la variable READLINE_LINE au contenu du tampon de
                     ligne de readline et les variables READLINE_POINT et
                     READLINE_MARK à la position actuelle du curseur d'insertion
                     et du point d'insertion sauvegardé (la marque)
                     respectivement. Si la commande exécutée modifie les valeurs
                     de READLINE_LINE, READLINE_POINT ou READLINE_MARK, ces
                     nouvelles valeurs seront prises en considération dans
                     l'état d'édition.
              -X     Afficher toutes les suites de touches associées aux
                     commandes de l’interpréteur et aux commandes associées pour
                     pouvoir être réutilisées en entrée.

              La valeur renvoyée est 0, à moins qu'une option inconnue ne soit
              indiquée ou qu'une erreur ne se soit produite.

       break [n]
              Sortir d'une boucle for, while, until ou select. Si n est indiqué,
              sortir de n niveaux de boucles. n doit être ≥ 1. Si n est
              supérieur au nombre de boucles imbriquées, sortir de toutes les
              boucles. La valeur renvoyée est 0, à moins que n ne soit pas
              supérieur ou égal à 1.

       builtin commande_interne [arguments]
              Exécuter la commande interne de l'interpréteur indiquée, en lui
              passant les arguments, puis renvoyer son état final. C'est utile
              lorsqu'une fonction est définie avec le même nom qu'une commande
              interne, et que cette commande est appelée depuis l'intérieur de
              la fonction. La commande interne cd est souvent redéfinie de cette
              façon. L'état renvoyé est faux si la commande_interne n'est pas
              une commande interne de l'interpréteur.

       caller [expr]
              Renvoyer le contexte de tout appel de sous-programme actif (une
              fonction de l'interpréteur ou un script lancé avec les commandes
              internes . ou source). Sans expr, caller affiche le numéro de
              ligne et le nom de fichier du sous-programme actuel. Si un entier
              positif est fourni comme expr, caller affiche le numéro de ligne,
              le nom du sous-programme et le nom de fichier source correspondant
              à la position dans la pile d'appels d'exécution actuelle. Cette
              information supplémentaire peut être utilisée, par exemple, pour
              afficher une trace de la pile. La trame actuelle est la trame 0.
              La valeur renvoyée est 0, à moins que l'interpréteur ne soit pas
              en train d'exécuter un sous-programme ou que expr ne corresponde
              pas à une position correcte dans la pile d'appels.

       cd [-L|[-P [-e]] [-@]] [rép]
              Remplacer le répertoire de travail actuel par rép. Si rép n’est
              pas fourni, la valeur de la variable d’interpréteur HOME est la
              valeur par défaut. Tous les arguments supplémentaires suivant rép
              sont ignorés. La variable CDPATH définit des chemins de recherche
              pour trouver le répertoire contenant rép : tous les noms de
              répertoire contenus dans CDPATH sont parcourus à la recherche de
              rép. Les répertoires possibles y sont fournis dans une liste
              séparés par des deux-points « : ». Un nom de répertoire NULL dans
              CDPATH est équivalent au répertoire actuel, c'est-à-dire « . ». Si
              rép commence par une barre oblique (/), alors CDPATH n'est pas
              utilisé. L'option -P force cd à n'employer que la structure de
              répertoires physiques en résolvant les liens symboliques en
              traversant rép et avant de traiter les instances de .. dans rép
              (consultez aussi l'option -P de la commande interne set) ;
              l'option -L force à suivre les liens symboliques en résolvant les
              liens symboliques après le traitement des instances de .. dans
              rép. Si .. apparaît dans dir, il est traité en supprimant le
              composant de chemin précédant directement rép, jusqu’à une barre
              oblique ou le début de rép. Si l'option -e est fournie avec -P, et
              que le répertoire de travail actuel ne peut pas être déterminé
              avec succès après un changement de répertoire avec succès, cd
              renverra un état d'échec. Sur les systèmes qui le permettent,
              l’option -@ présente les attributs étendus associés à un fichier
              comme à un répertoire. Un argument - est converti en $OLDPWD avant
              d’essayer un changement de répertoire. Si un nom de répertoire non
              vide de CDPATH est utilisé ou si - est le premier argument et si
              le changement de répertoire réussit, le chemin absolu du nouveau
              répertoire de travail est écrit sur la sortie standard. La valeur
              renvoyée est vrai si le changement de répertoire a réussi, faux
              sinon.

       command [-pVv] commande [arguments ...]
              Exécuter la commande avec les arguments indiqués, mais en
              supprimant le processus habituel de recherche des commandes.
              Seules les commandes internes ou les commandes trouvées dans PATH
              seront exécutées. Si l'option -p est indiquée, la recherche de la
              commande est effectuée en utilisant une valeur par défaut pour
              PATH garantissant de trouver tous les utilitaires standards. Si
              l'option -V ou -v est fournie, une description de la commande est
              affichée. L'option -v conduit à n'afficher qu'un seul mot
              indiquant la commande ou le nom de fichier utilisé pour appeler la
              commande. L'option -V fournit une description plus prolixe. Si
              l'option -V ou -v est fournie, l'état final est 0 si la commande a
              été trouvée et 1 sinon. Si aucune option n'est fournie et si une
              erreur s'est produite ou si la commande ne peut être trouvée,
              l'état final est 127. Sinon, l'état final de la command interne
              est l'état final de commande.

       compgen [option] [mot]
              Produire les correspondances des complètements possibles pour mot
              selon les options, qui peuvent être toute option acceptée par la
              commande interne complete à l'exception de -p et -r et écrit le
              résultat sur la sortie standard. Lorsqu'on utilise les options -F
              ou -C, les diverses variables de l'interpréteur créées par les
              outils de complètement programmables, lorsque disponibles,
              n'auront pas de valeurs utilisables.

              Les correspondances seront produites de la même façon que si le
              programme de complètement programmable les avait produites
              directement à partir d'une spécification de complètement avec les
              mêmes attributs. Si mot est indiqué, seuls les complètements qui
              correspondent à mot sont affichés.

              La valeur renvoyée est vrai, sauf si une option incorrecte a été
              fournie ou si aucune correspondance n'a été produite.

       complete [-abcdefgjksuv] [-o option-complètement] [-DEI] [-A action] [-G
       globpat] [-W liste_de_mots]
              [-F fonction] [-C commande] [-X motif_filtre] [-P préfixe] [-S
              suffixe] nom [nom ...]
       complete -pr [-DEI] [nom ...]
              Indiquer la façon de compléter les arguments de chaque nom. Si
              l'option -p est fournie ou si aucune option n'est fournie, les
              spécifications de complètement existantes sont affichées de telle
              façon qu'elles puissent être réutilisées comme entrée. L'option -r
              retire une spécification de complètement à chaque nom fourni ou,
              si aucun nom n'est fourni, toutes les spécifications de
              complètement. L'option -D indique que les options restantes et les
              actions devraient s'appliquer au complètement de commande par
              « défaut », c'est-à-dire le complètement essayé sur une commande
              pour laquelle aucun complètement n'a été préalablement défini.
              L'option -E indique que les options restantes et les actions
              devraient s'appliquer au complètement de commande « vide »,
              c'est-à-dire le complètement essayé sur une ligne vide. L'option
              -I indique que les options restantes et les actions devraient
              s'appliquer au complètement du premier mot de non affectation de
              la ligne ou après un délimiteur de commande ; ou |, ce qui est
              habituellement le complètement d'un nom de commande. Si plusieurs
              options sont fournies, l'option -D prend la préséance sur -E et
              les deux prennent la préséance sur -I. Si une des -options -D, -E
              ou -I est fournie, tous les autres arguments de nom sont ignorés ;
              ces complètements ne s'appliquent qu'au cas précisé par l'option.

              Le processus d'application de ces spécifications de complètement,
              lorsqu'un complètement de mot est tenté, est décrit ci-dessus dans
              Complètement programmable.

              Les autres options, si indiquées, ont les significations
              suivantes. Les arguments des options -G, -W et -X (et, si
              nécessaire, les options -P et -S) devraient être protégées pour
              éviter leur développement avant que la commande interne complete
              ne soit appelée.
              -o option-complètement
                      L'option-complètement commande plusieurs aspects du
                      comportement des spécifications de complètement au-delà de
                      la simple production de complètement. option-complètement
                      peut être l'une des suivantes :
                      bashdefault
                              Effectuer le reste des complètements par défaut de
                              bash si la spécification de complètement ne
                              produit aucune correspondance.
                      default Utiliser le complètement de nom de fichier par
                              défaut de readline si la spécification de
                              complètement ne produit aucune correspondance.
                      dirnames
                              Effectuer le complètement de nom de répertoire si
                              la spécification de complètement ne produit aucune
                              correspondance.
                      filenames
                              Indiquer à readline que la spécification de
                              complètement produit des noms de fichiers, ainsi
                              il peut effectuer tout traitement spécifique aux
                              noms de fichiers (comme ajouter une barre oblique
                              aux noms de répertoires, protéger les caractères
                              spéciaux ou supprimer les espaces de fin de
                              ligne). Destinée à être utilisée avec les
                              fonctions de l'interpréteur.
                      noquote Indiquer à readline de protéger les mots complétés
                              s’il s’agit de noms de fichier (la protection des
                              noms de fichier est par défaut).
                      nosort  Indiquer à readline de ne pas trier par ordre
                              alphabétique la liste des complètements possibles.
                      nospace Indiquer à readline de ne pas ajouter une espace
                              (comportement par défaut) aux mots complétés en
                              fin de ligne.
                      plusdirs
                              Après création de toutes les correspondances
                              définies par la spécification de complètement, une
                              tentative de complètement de nom de répertoire est
                              effectuée et toutes les correspondances sont
                              ajoutées aux résultats des autres actions.
              -A action
                      L'action peut être l'une des suivantes pour produire une
                      liste des complètements possibles :
                      alias   Noms d'alias. Peut également être indiquée avec
                              -a.
                      arrayvar
                              Noms de variable de type tableau.
                      binding Noms de raccourci clavier readline.
                      builtin Noms de commandes internes de l'interpréteur. Peut
                              également être indiquée avec -b.
                      command Noms de commande. Peut également être indiquée
                              avec -c.
                      directory
                              Noms de répertoire. Peut également être indiquée
                              avec -d.
                      disabled
                              Noms de commandes internes de l'interpréteur
                              désactivées.
                      enabled Noms de commandes internes de l'interpréteur
                              activées.
                      export  Noms de variables de l'interpréteur exportées.
                              Peut également être indiquée avec -e.
                      file    Noms de fichier. Peut également être indiquée avec
                              -f.
                      function
                              Noms de fonctions de l'interpréteur.
                      group   Noms de groupe. Peut également être indiquée avec
                              -g.
                      helptopic
                              Sujets de l'aide acceptés par la commande interne
                              help.
                      hostname
                              Noms de machine tels qu'ils sont extraits du
                              fichier indiqué par la variable de l'interpréteur
                              HOSTFILE.
                      job     Noms de tâche si le contrôle des tâches est actif.
                              Peut également être indiquée avec -j.
                      keyword Mots réservés de l'interpréteur. Peut également
                              être indiquée avec -k.
                      running Noms de tâches en cours d'exécution si le contrôle
                              des tâches est actif.
                      service Noms de service. Peut également être indiquée avec
                              -s.
                      setopt  Arguments corrects de l'option -o de la commande
                              interne set.
                      shopt   Noms des options d'interpréteur acceptées par la
                              commande interne shopt.
                      signal  Noms de signaux.
                      stopped Noms de tâches suspendues si le contrôle des
                              tâches est actif.
                      user    Noms d'utilisateur. Peut également être indiquée
                              avec -u.
                      variable
                              Noms de toutes les variables de l'interpréteur.
                              Peut également être indiquée avec -v.
              -C commande
                      La commande est exécutée dans un environnement de
                      sous-interpréteur et sa sortie est utilisée comme
                      complètements possibles.
              -F fonction
                      La fonction de l'interpréteur est exécutée dans
                      l'interpréteur actuel. Lorsqu'une fonction est exécutée,
                      le premier argument ($1) est le nom de la commande dont
                      les arguments doivent être complétés, le deuxième argument
                      ($2) est le mot à compléter et le troisième argument ($3)
                      est le mot précédant celui devant être complété sur la
                      ligne de commande actuelle. Lorsqu'elle finit, les
                      complètements possibles sont récupérés à partir de la
                      valeur de la variable de type tableau COMPREPLY.
              -G globpat
                      Le motif de développement des chemins globpat est
                      développé pour produire les complètements possibles.
              -P préfixe
                      préfixe est ajouté au début de chaque complètement
                      possible après application de toutes les autres options.
              -S suffixe
                      suffixe est ajouté à chaque complètement possible après
                      application de toutes les autres options.
              -W liste_de_mots
                      La liste_de_mots est découpée en utilisant les caractères
                      de la variable spéciale IFS comme délimiteurs et chaque
                      mot résultant est développé. Les protections de
                      l'interpréteur sont prises en compte à l'intérieur de la
                      liste_de_mots, afin de fournir un mécanisme pour que les
                      mots puissent contenir des métacaractères ou des
                      caractères de l'interpréteur dans la valeur de IFS. Les
                      complètements possibles sont les éléments de la liste
                      résultante qui correspondent au mot en cours de
                      complètement.
              -X motif_filtre
                      motif_filtre est un motif utilisé pour le développement
                      des chemins. Il est appliqué à la liste des complètements
                      possibles produite par les options et arguments précédents
                      et chaque complètement correspondant à motif_filtre est
                      supprimé de la liste. Un ! au début du motif_filtre
                      inverse le motif ; dans ce cas, tout complètement qui ne
                      correspond pas à motif_filtre est supprimé.

              La valeur renvoyée est vrai, sauf si une option incorrecte a été
              fournie, si une option comme -p ou -r a été fournie sans un nom
              d'argument, si une tentative a été faite pour supprimer une
              spécification de complètement pour un nom pour lequel il n'existe
              pas de spécification, ou si une erreur est survenue lors de
              l'ajout d'une spécification de complètement.

       compopt [-o option] [-DEI] [+o option] [nom]
              Modifier les options de complètement pour chaque nom en fonction
              des options, ou pour le complètement en cours d'exécution si aucun
              nom n'est fourni. Si aucune option n'est donnée, afficher les
              options de complètement pour chaque nom ou pour le complètement
              actuel. Les valeurs d’options possibles sont celles décrites
              ci-dessus pour la commande interne complete. L'option -D indique
              que les options restantes devraient s'appliquer à la commande de
              complètement par « défaut » ; c'est-à-dire le complètement essayé
              sur une commande pour laquelle aucun complètement n'a été
              préalablement défini. L'option -E indique que les options fournies
              devraient s'appliquer au complètement de commande « vide » ;
              c'est-à-dire le complètement essayé sur une ligne vide. L'option I
              indique que les options fournies restantes devraient s'appliquer
              au complètement du premier mot de non affectation de la ligne ou
              après un délimiteur de commande ; ou |, ce qui est habituellement
              le complètement d'un nom de commande.

              La valeur renvoyée est vrai, à moins qu'une option incorrecte ait
              été fournie, qu'une tentative ait été faite pour modifier les
              options pour un nom pour lequel il n'existe pas de spécification
              de complètement, ou bien qu'une erreur de sortie soit survenue.

       continue [n]
              Reprendre l'exécution à l'itération suivante d'une boucle for,
              while, until ou encore select. 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 (la boucle « au sommet »). La valeur
              renvoyée est 0, à moins que n ne soit supérieur ou égal à 1.

       declare [-aAfFgiIlnrtux] [-p] [nom[=valeur] ...]
       typeset [-aAfFgiIlnrtux] [-p] [nom[=valeur] ...]
              Déclarer des variables ou leur fournir des attributs. Si aucun nom
              n'est indiqué, afficher les valeurs des variables. L'option -p
              affichera les attributs et les valeurs de chaque nom. Quand -p est
              utilisée avec des arguments nom, les options supplémentaires, à
              part -f et -F, sont ignorées. Quand -p est fourni sans argument
              nom, les attributs et valeurs de toutes les variables ayant des
              attributs indiqués par les options additionnelles seront affichés.
              Si aucune autre option n'est fournie avec -p, declare affichera
              les attributs et valeurs de toutes les variables de
              l'interpréteur. L'option -f limite l'affichage aux fonctions de
              l'interpréteur. L'option -F empêche l'affichage des définitions de
              fonctions : seuls le nom de la fonction et ses attributs sont
              affichés. Si l'option d'interpréteur extdebug est activée en
              utilisant shopt, le nom du fichier source et le numéro de ligne où
              chaque nom est défini sont aussi affichés. L'option -F implique
              -f. L'option -g force la création ou la modification de variables
              avec une portée globale, même si declare est exécutée dans une
              fonction de l'interpréteur. Elle est ignorée dans tous les autres
              cas. L'option -I fait que les variables locales héritent des
              attributs (sauf de l'attribut nameref) et prennent la valeur de
              n'importe quelle variable existante du même nom dans son
              environnement. S'il n'y a pas de variable existante, la variable
              locale est détruite dans un premier temps. Les options suivantes
              permettent de restreindre l'affichage aux variables dotées de
              certains attributs ou de configurer les attributs des variables :
              -a     Chaque nom est une variable de type tableau indicé
                     (consultez Tableaux ci-dessus).
              -A     Chaque nom est une variable de type tableau associatif
                     (consultez Tableaux ci-dessus).
              -f     Utiliser seulement les noms de fonctions.
              -i     La variable est traitée comme un entier ; l'évaluation
                     arithmétique (consultez ÉVALUATION ARITHMÉTIQUE ci-dessus)
                     est effectuée lorsqu'une valeur est affectée à la variable.
              -l     Quand cette variable contient une valeur, toutes les
                     majuscules seront converties en minuscules. L'attribut
                     majuscule est désactivé.
              -n     Donner à chaque nom l’attribut nameref, le rendant une
                     référence de nom vers une autre variable. Cette autre
                     variable est définie par la valeur de nom. Toutes les
                     références, les affectations et les modifications
                     d'attribut de nom, à part celles qui utilisent ou modifient
                     l’attribut -n lui-même, sont réalisées sur la variable
                     référencée par la valeur de nom. L’attribut -nameref ne
                     peut pas être appliqué aux variables de type tableau.
              -r     Rendre les noms accessibles en lecture seule. Plus aucune
                     valeur ne pourra leur être affectée et ils ne pourront plus
                     être détruits.
              -t     Donner à chaque nom l'attribut trace. Les fonctions tracées
                     héritent des captures de DEBUG et RETURN de l'interpréteur
                     appelant. L'attribut trace n'a pas de signification
                     spéciale pour les variables.
              -u     Quand cette variable contient une valeur, toutes les
                     minuscules seront converties en majuscules. L'attribut
                     minuscule est désactivé.
              -x     Marquer les noms pour qu'ils soit exportés dans
                     l'environnement des commandes ultérieures.

              En utilisant « + » à la place de « - », l'attribut correspondant
              est désactivé, à l'exception que +a et +A ne peuvent pas être
              utilisés pour détruire une variable tableau et que +r n'enlèvera
              pas l'attribut lecture seule. Quand ils sont utilisés dans une
              fonction, declare et typeset rendent local chaque nom, comme avec
              la commande local sauf si l'option -g est fournie. Si un nom de
              variable est suivi par =valeur, la valeur de cette variable est
              configurée à valeur. Lors de l’utilisation de -a ou -A et de la
              syntaxe d’affectation composée pour créer des variables de type
              tableau, les attributs supplémentaires sont sans effet jusqu’aux
              affectations suivantes. La valeur renvoyée est 0, sauf si une
              option incorrecte est rencontrée, une tentative est faite de
              définir une fonction en utilisant ``-f foo=bar'', une tentative
              est faite d'affecter une valeur à une variable en lecture seule,
              une tentative est faite d'affecter une valeur à une variable
              tableau sans employer la syntaxe d'affectation composée (consultez
              Tableaux ci-dessus), un des noms n'est pas un nom correct pour une
              variable de l'interpréteur, une tentative est faite de supprimer
              l'attribut lecture seule d'une variable en lecture seule, une
              tentative est faite de supprimer l'attribut tableau d'une variable
              tableau, ou qu'une tentative est faite avec -f d'afficher une
              fonction inexistante.

       dirs [-clpv] [+n] [-n]
              Sans option, afficher la liste des répertoires actuellement
              mémorisés. L'affichage par défaut est réalisé sur une seule ligne,
              les noms de répertoires étant séparés par des espaces. Les
              répertoires sont ajoutés à la liste avec la commande pushd et
              supprimés avec la commande popd. Le répertoire courant est
              toujours le premier répertoire de la pile.
              -c     Effacer la liste des répertoires en les supprimant tous.
              -l     Produire une liste en utilisant les chemins complets ; le
                     format d'affichage par défaut utilise le tilde pour
                     représenter le répertoire d'accueil.
              -p     Afficher la pile des répertoires avec un élément par ligne.
              -v     Afficher la pile des répertoires avec un élément par ligne,
                     en préfixant chaque entrée avec son numéro d'indice dans la
                     pile.
              +n     Afficher le n-ième élément de la liste fournie par dirs,
                     lorsqu'appelé sans options, en comptant à partir de la
                     gauche en commençant à zéro.
              -n     Afficher le n-ième élément de la liste fournie par dirs,
                     lorsqu'appelé sans options, en comptant à partir de la
                     droite en commençant à zéro.

              La valeur renvoyée est 0, sauf si une option incorrecte a été
              fournie ou si l'indice n dépasse la longueur de la pile des
              répertoires.

       disown [-ar] [-h] [tâche ... | pid ... ]
              Sans options, supprimer chaque tâche de la table des tâches
              actives. Si aucune tâche n'est précisée et qu’aucune des options
              -a ou -r n'est fournie, la tâche actuelle est utilisée. Si
              l'option -h est indiquée, aucune tâche n'est supprimée de la
              table, mais chaque tâche est marquée pour que le signal SIGHUP ne
              lui soit pas envoyé si l'interpréteur reçoit un signal SIGHUP. Si
              aucune tâche n'est fournie, l'option -a signifie la suppression ou
              le marquage de toutes les tâches ; l'option -r sans l'argument
              tâche restreint les opérations aux tâches en cours d'exécution. La
              valeur renvoyée est 0, sauf si tâche n'indique pas une tâche
              correcte.

       echo [-neE] [arguments ...]
              Afficher les arguments, séparés par des espaces, suivis par un
              saut de ligne. La valeur renvoyée est 0 sauf en cas d’erreur. Si
              -n est indiqué, le changement de ligne final est supprimé. Si
              l'option -e est indiquée, l'interprétation des caractères de
              protection suivants par une contre-oblique est activée. L'option
              -E désactive l'interprétation de ces caractères de protection,
              même sur les systèmes où ils sont interprétés par défaut. L'option
              d'interpréteur xpg_echo peut être utilisée dynamiquement pour
              déterminer si echo développe ou non par défaut ces caractères de
              protection. echo n'interprète pas -- comme signifiant la fin des
              options. echo reconnaît les suites de caractères de protection
              suivants :
              \a     alerte (alarme) ;
              \b     effacement arrière (« backspace ») ;
              \c     supprime tout affichage suivant ;
              \e
              \E     caractère de protection ;
              \f     saut de page (« form feed ») ;
              \n     saut de ligne (« new line ») ;
              \r     retour chariot (« carriage return ») ;
              \t     tabulation horizontale ;
              \v     tabulation verticale ;
              \\     contre-oblique ;
              \0nnn  le caractère 8 bits dont la valeur en octal est nnn (zéro à
                     trois chiffres octaux) ;
              \xHH   le caractère 8 bits dont la valeur hexadécimale est HH (un
                     ou deux chiffres hexadécimaux) ;
              \uHHHH le caractère Unicode (ISO/IEC 10646) dont la valeur
                     hexadécimale est HHHH (un à quatre chiffres hexadécimaux) ;
              \UHHHHHHHH
                     le caractère Unicode (ISO/IEC 10646) dont la valeur
                     hexadécimale est HHHHHHHH (un à huit chiffres
                     hexadécimaux) ;

       enable [-a] [-dnps] [-f fichier] [nom ...]
              Activer ou désactiver les commandes internes de l'interpréteur.
              Désactiver une commande interne permet d'exécuter une commande
              disque ayant le même nom qu'une commande interne de
              l'interpréteur, sans avoir à indiquer un chemin d'accès complet,
              même quand l'interpréteur recherche normalement les commandes
              internes avant les commandes du disque. Si -n est utilisé, chaque
              nom indiqué est désactivé, sinon ils sont activés. Par exemple,
              pour utiliser le programme binaire test qui se trouve dans PATH
              plutôt que la commande interne, utilisez ``enable -n test''.
              L'option -f demande de charger la nouvelle commande interne avec
              le nom indiqué depuis le fichier objet partagé sur les systèmes
              qui le permettent. L'option -d permet de supprimer une commande
              interne chargée précédemment avec -f. Si aucun argument nom n'est
              indiqué ou si l'option -p est fournie, une liste des commandes
              internes de l'interpréteur est affichée. Sans autre option, la
              liste est celle des commandes internes actives de l'interpréteur.
              Si -n est fournie, seules les commandes désactivées sont
              affichées. Si -a est fournie, la liste de toutes les commandes est
              affichée, avec une indication des activations et désactivations.
              Si -s est fournie, la sortie est limitée aux commandes internes
              spéciales POSIX. La valeur renvoyée est 0, sauf si nom n'est pas
              une commande interne ou qu'il y a une erreur au chargement d'une
              nouvelle commande interne d'un objet partagé.

       eval [arguments ...]
              Les arguments sont lus et regroupés en une seule commande simple.
              Cette commande est alors lue et exécutée par l'interpréteur et son
              état final est renvoyé comme valeur de la commande eval. S'il n'y
              a pas d'arguments ou uniquement des arguments NULL, eval renvoie
              0.

       exec [-cl] [-a nom] [commande [arguments]]
              Si une commande est indiquée, elle remplace l'interpréteur. Aucun
              nouveau processus n'est créé. Les arguments deviennent ceux de la
              commande. Si l'option -l est fournie, l'interpréteur place un
              tiret en guise de zéroième argument fourni à la commande. C'est ce
              que fait login(1). L'option -c conduit à l'exécution de la
              commande avec un environnement vide. Si l'option -a est fournie,
              l'interpréteur transmet le nom comme zéroième argument. Si la
              commande ne peut être exécutée pour une raison quelconque, un
              interpréteur non interactif termine, sauf si l'option de
              l'interpréteur execfail est activée. Dans ce cas, une erreur est
              renvoyée. Un interpréteur interactif renvoie une erreur si le
              fichier ne peut pas être exécuté. Un sous-interpréteur termine
              sans conditions si exec échoue. Si aucune commande n'est indiquée,
              les éventuelles redirections sont mises en place dans
              l'interpréteur actuel et l'état renvoyé est 0. S'il y a une erreur
              de redirection, l'état renvoyé est 1.

       exit [n]
              Termine l'interpréteur avec un état de n. Si n est omis, l'état
              final est celui de la dernière commande exécutée. Une capture sur
              EXIT est exécutée avant que l'interpréteur ne se termine.

       export [-fn] [nom[=mot]] ...
       export -p
              Les noms fournis sont marqués pour être exportés automatiquement
              dans l'environnement des commandes exécutées par la suite. Si
              l'option -f est indiquée, les noms se rapportent à des fonctions.
              Si aucun nom n'est donné ou si l'option -p est fournie, une liste
              de noms de toutes les variables exportées est affichée. L'option
              -n conduit à supprimer l'attribut d'exportation de toutes les
              variables nommées. Si un nom de variable est suivi par =mot, la
              valeur de la variable est configurée à mot. export renvoie un état
              final de 0, sauf si une option incorrecte est rencontrée, si un
              des noms n'est pas un nom correct de variable de l'interpréteur,
              ou si l'option -f est fournie avec un nom qui n'est pas une
              fonction.

       fc [-e éditeur] [-lnr] [première] [dernière]
       fc -s [motif=nouveau] [commande]
              La première forme sélectionne un intervalle de commandes de la
              première à la dernière dans la file d’historique et l’affiche ou
              l’édite pour les réexécuter. La première et la dernière peuvent
              être indiquées sous forme de chaînes (pour trouver la dernière
              commande commençant par cette chaîne) ou sous forme numérique (un
              indice dans la file d'historique où un nombre négatif est utilisé
              comme décalage par rapport au numéro de la commande actuelle). Sur
              la liste, une première ou une dernière de valeur 0 est équivalente
              à -1, et -0 est équivalent à la commande actuelle (habituellement
              la commande fc) ; autrement, 0 est équivalent à -1 et -0 n'est pas
              valable. Si la dernière n'est pas indiquée, elle est configurée à
              la commande actuelle si l'on veut afficher la liste (ainsi ``fc -l
              -10'' affiche les 10 dernières commandes) et à l'identique de la
              première sinon. Si la première n'est pas indiquée, elle est
              configurée à la commande précédente pour une édition et à -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. Si l'option -l est
              indiquée, les commandes sont affichées sur la sortie standard.
              Sinon, l'éditeur indiqué est appelé avec un fichier contenant les
              commandes sélectionnées. Si aucun éditeur n'est indiqué, on
              utilise la valeur de la variable FCEDIT et la valeur de EDITOR si
              FCEDIT n'existe pas. Si aucune variable n'existe, vi est utilisé.
              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. commande est
              interprétée de la même façon que première ci-dessus. Un alias
              utile pour cela 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 incorrecte est trouvée ou si première ou
              dernière indiquent des lignes d'historique hors d'atteinte. Si
              l'option -e est fournie, la valeur renvoyée 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, l'état renvoyé est celui de la commande réexécutée, sauf si
              commande n'indique pas une ligne correcte de l'historique, auquel
              cas fc renvoie un échec.

       fg [tâche]
              Reprendre la tâche au premier plan qui devient la tâche actuelle.
              Si aucune tâche n'est précisée, l'interpréteur utilise la notion
              de tâche actuelle. La valeur renvoyée est celle de la commande
              placée au premier plan ou un échec si le contrôle des tâches est
              désactivé ou, lorsque le contrôle des tâches est activé, si la
              tâche n'indique pas une tâche correcte ou si la tâche indique une
              tâche lancée sans contrôle des tâches.

       getopts chaîne_d_options nom [arguments ...]
              getopts est utilisé par les scripts d'interpréteur pour analyser
              les paramètres positionnels. La chaîne_d_options contient
              l'ensemble des caractères d'options à reconnaître ; si un
              caractère est suivi par un deux-points, l'option est censée avoir
              un argument, qui devrait en être séparé par une espace. Les
              caractères deux-points et le point d'interrogation ne peuvent pas
              être utilisés comme caractères d'option. À chaque appel, getopts
              place l'option suivante dans la variable de l'interpréteur dont le
              nom est fourni, en la créant si elle n'existe pas et l'indice de
              l'argument suivant à traiter dans la variable OPTIND.  OPTIND est
              initialisée à 1 à chaque appel d'un interpréteur ou d'un script.
              Quand une option nécessite un argument, getopts place cet argument
              dans la variable OPTARG. L'interpréteur ne réinitialise pas OPTIND
              automatiquement, il faut le faire manuellement entre des appels
              multiples à getopts au sein du même appel d'interpréteur si un
              nouveau jeu de paramètres doit être utilisé.

              Lorsque la fin des options est atteinte, getopts termine avec une
              valeur renvoyée strictement supérieure à zéro.  OPTIND est
              positionné à l'indice du premier argument obligatoire et un point
              d'interrogation (?) est placé dans la variable nom.

              getopts analyse en principe les paramètres positionnels, mais si
              plus d'arguments sont indiqués comme valeur d'arguments, getopts
              analysera ces derniers à la place.

              getopts peut signaler des erreurs de deux façons. Si le premier
              caractère de la chaîne_d_options est un deux-points, les erreurs
              sont signalées de façon silencieuse. Lors d'un fonctionnement
              normal, des messages de diagnostic sont affichés si une option est
              incorrecte ou s'il manque un argument d'option. Si la variable
              OPTERR est configurée à 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
              deux-points.

              Si une option incorrecte est rencontrée, getopts place 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. Si getopts fonctionne en mode silencieux, le
              caractère d'option est placé dans OPTARG et aucun message de
              diagnostic n'est affiché.

              Lorsqu'un argument d'option nécessaire est absent et si getopts
              n'est pas silencieux, un point d'interrogation (?) est placé dans
              la variable nom, OPTARG est détruite et un message de diagnostic
              est affiché. Si getopts est silencieux, un deux-points (:) est
              placé dans la variable nom et OPTARG est positionné à l'option
              monocaractère trouvée.

              getopts renvoie vrai si une option, indiquée ou non, est trouvée.
              Il renvoie faux si la fin des options est atteinte ou si une
              erreur se produit.

       hash [-lr] [-p fichier] [-dt] [nom]
              Chaque fois que hash est invoquée, le chemin d'accès complet de la
              commande nom est déterminé en examinant les répertoires de $PATH,
              et mémorisé. Tous les chemins précédemment mémorisés sont
              supprimés. Si l'option -p est fournie, aucune recherche de chemin
              d'accès n'est effectuée et le fichier est utilisé comme chemin
              d'accès complet pour la commande. L'option -r conduit
              l'interpréteur à oublier tous les emplacements mémorisés. L'option
              -d conduit l'interpréteur à oublier tous les emplacements
              mémorisés de chaque nom. Si l'option -t est fournie, le chemin
              d'accès complet de chaque nom correspondant est affiché. Si
              plusieurs arguments nom sont fournis avec -t, le nom est affiché
              avant chaque chemin d'accès complet associé. L'option -l conduit à
              afficher la sortie dans un format réutilisable en entrée. Si aucun
              argument n'est indiqué ou si seulement -l est fournie, des
              informations sur les commandes mémorisées sont affichées. La
              valeur renvoyée est vrai, sauf si nom n'est pas trouvé ou si une
              option incorrecte est fournie.

       help [-dms] [motif]
              Afficher des informations d'aide au sujet des commandes internes.
              Si un motif est indiqué, help fournit de l'aide sur toutes les
              commandes internes correspondant à ce motif, sinon, une liste des
              commandes internes et des structures de contrôle de l'interpréteur
              est affichée.
              -d     Afficher une courte description de chaque motif.
              -m     Afficher la description de chaque motif dans un format du
                     type pages de manuel.
              -s     Afficher seulement un court synopsis d'utilisation de
                     chaque motif.

              L'état renvoyé est 0, sauf si aucune commande ne correspond au
              motif.

       history [n]
       history -c
       history -d nombre
       history -d début-fin
       history -anrw [fichier]
       history -p argument [argument ...]
       history -s argument [argument ...]
              Sans options, afficher la liste des commandes de la file
              d'historique, avec les numéros de ligne. Les lignes marquées avec
              un * ont été modifiées. Un argument n permet de n'afficher que les
              n dernières lignes. Si la variable de l'interpréteur
              HISTTIMEFORMAT existe et n'est pas NULL, elle est utilisée comme
              chaîne de format pour strftime(3) afin d'afficher l'horodatage
              associé à chaque élément de l'historique. Aucun blanc ne sépare
              l'horodatage ainsi mis en forme de la ligne d'historique. Si un
              argument fichier est fourni, il est utilisé comme nom de fichier
              d'historique ; sinon la valeur de HISTFILE est utilisée. Les
              options, si fournies, ont les significations suivantes :
              -c     Effacer la file de l'historique en supprimant tous les
                     éléments.
              -d nombre
                     Supprimer l'entrée d'historique à la position nombre. Si
                     nombre estnégatif, il est interprété comme relatif à un
                     nombre plus grand que celui de la dernière position de
                     l'historique, ainsi les indices négatifs comptent à rebours
                     depuis la fin de l'historique et un indice -1 fait
                     référence à la commande history -d actuelle.
              -d début-fin
                     Supprimer les entrées d'historique entre les positions
                     début et fin inclus. Les valeurs positives et négatives
                     pour début et fin sont interprétées comme décrites
                     ci-dessus.
              -a     Ajouter les « nouvelles » lignes d'historique. Ce sont
                     celles créées depuis le début de la session actuelle de
                     bash, mais pas déjà ajoutées dans le fichier d'historique.
              -n     Lire dans le fichier d'historique les lignes non encore
                     lues et les ajouter à la file d'historique actuelle. Il
                     s'agit des lignes qui ont été ajoutées dans le fichier
                     d'historique depuis le début de la session bash.
              -r     Lire le contenu du fichier et l'ajouter à l’historique
                     actuel.
              -w     Écrire la liste actuelle d’historique dans le fichier
                     d’historique, en écrasant le contenu précédent.
              -p     Effectuer la substitution d'historique sur les arguments
                     suivants et afficher le résultat sur la sortie standard. Ne
                     pas mémoriser les résultats dans la file d'historique.
                     Chaque argument doit être protégé pour désactiver le
                     développement normal de l'historique.
              -s     Conserver les arguments dans la file d'historique comme un
                     unique élément. La dernière commande de la file
                     d'historique est supprimée avant que les arguments ne
                     soient ajoutés.

              Si la variable HISTTIMEFORMAT existe, les informations
              d'horodatage associées à chaque élément de l'historique sont
              écrites dans le fichier d'historique, repérés par le caractère de
              commentaire d'historique. Quand le fichier d'historique est lu,
              les lignes commençant par le caractère de commentaire d'historique
              suivi immédiatement par un chiffre sont considérés comme des
              horodatages de la ligne d'historique précédente. La valeur
              renvoyée est 0, sauf si une option incorrecte est fournie, si une
              erreur se produit durant la lecture ou l'écriture du fichier, si
              un nombre incorrect est fourni comme argument à -d ou si le
              développement de l'historique fourni en argument à -p échoue.

       jobs [-lnprs] [ tâche ... ]
       jobs -x commande [ arguments ... ]
              La première forme affiche la liste des tâches actives. Les options
              ont les significations suivantes :
              -l     Afficher les PID, en plus des informations normales.
              -n     Afficher uniquement des informations sur les tâches dont
                     l'état a changé depuis la dernière notification de leur
                     état à l'utilisateur.
              -p     Afficher uniquement le PID du meneur du groupe de processus
                     de la tâche.
              -r     N’afficher que les tâches en cours d'exécution.
              -s     N’afficher que les tâches suspendues.

              Si une tâche est indiquée, l'affichage est restreint aux
              informations relatives à cette tâche. L'état renvoyé est 0, sauf
              si une option incorrecte est rencontrée ou si une tâche incorrecte
              est fournie.

              Si l'option -x est fournie, jobs remplace toute tâche trouvée dans
              la commande ou dans ses arguments avec les Process Group ID
              correspondant, puis il exécute la commande en lui transmettant les
              arguments et en renvoyant son état final.

       kill [-s signal | -n num-signal | -signal] [pid | tâche] ...
       kill -l|-L [signal | état_final]
              Envoyer le signal indiqué par signal ou num-signal aux processus
              indiqués par pid ou par tâche. signal est soit sous la forme de
              nom de signal (indifférent à la casse), comme SIGKILL (avec ou
              sans le préfixe SIG), soit sous forme numérique ; num-signal est
              un numéro de signal. Si signal est absent, SIGTERM est supposé par
              défaut. Un argument -l provoque l'affichage de la liste des noms
              de signaux. Si des arguments sont fournis quand -l est indiqué,
              les noms des signaux correspondant aux arguments sont affichés et
              l'état renvoyé est 0. L'argument état_final de l'option -l est un
              nombre indiquant soit un numéro de signal, soit l'état final d'un
              processus terminé par un signal. L'option -L est équivalente de
              -l. kill renvoie vrai si au moins un signal a été envoyé avec
              succès ou faux si une erreur s'est produite ou si une option
              incorrecte a été rencontrée.

       let argument [argument ...]
              Chaque argument est une expression arithmétique à évaluer
              (consultez ÉVALUATION ARITHMÉTIQUE ci-dessus). Si l'évaluation du
              dernier argument donne 0, let renvoie 1 ; sinon 0 est renvoyé.

       local [option] [nom[=valeur] ...] - ]
              Pour chaque argument, une variable locale nom est créée et la
              valeur lui est affectée. L'option peut être n'importe quelle
              option acceptée par declare. Quand local est utilisé dans une
              fonction, la variable nom possède une portée visible restreinte à
              cette fonction et ses enfants. Si nom est -, les options de
              l'interpréteur sont réglées à locales pour la fonction dans
              laquelle local est invoquée : les options de l'interpréteur,
              modifiées en utilisant la commande interne set dans la fonction,
              sont restaurées à leur valeur originale quand la fonction redonne
              la main. La restauration est effectuée comme si une série de
              commandes set avaient été exécutées pour restaurer les valeurs qui
              étaient en place avant la fonction. Sans opérandes, local affiche
              la liste des variables locales sur la sortie standard. Une
              utilisation de local hors des fonctions est erronée. La valeur
              renvoyée est 0, sauf si local est utilisé hors d'une fonction, si
              un nom incorrect est fourni ou si nom est une variable en lecture
              seule.

       logout Terminer un interpréteur de connexion.

       mapfile [-d délimiteur] [-n nombre] [-O origine] [-s nombre] [-t] [-u df]
       [-C rappel] [-c quantum] [tableau]
       readarray [-d délimiteur] [-n nombre] [-O origine] [-s nombre] [-t] [-u
       df] [-C rappel] [-c quantum] [tableau]
              Lire les lignes depuis l'entrée standard dans la variable de type
              tableau indicé tableau, ou depuis le descripteur de fichier df si
              l'option -u est fournie. La variable MAPFILE est le tableau par
              défaut. Les options, si fournies, ont les significations
              suivantes :
              -d     Le premier caractère de délimiteur est utilisé pour
                     terminer la ligne de saisie, plutôt qu'un changement de
                     ligne. Si délimiteur est une chaîne vide, mapfile termine
                     une ligne quand il lit un caractère NUL.
              -n     Copier au plus nombre lignes. Si nombre est 0, toutes les
                     lignes sont copiées.
              -O     Commencer l'affectation de tableau à l'indice origine.
                     L'indice par défaut est 0.
              -s     Supprimer les nombre premières lignes lues.
              -t     Éliminer un délimiteur final (par défaut changement de
                     ligne ) de chaque ligne lue.
              -u     Lire les lignes à partir du descripteur de fichier df
                     plutôt que depuis l'entrée standard.
              -C     Évaluer rappel à chaque fois que quantum lignes sont lues.
                     L'option -c précise le quantum.
              -c     Préciser le nombre de lignes entre chaque appel à rappel.

              Si -C est précisé sans -c, le quantum par défaut est 5000. Quand
              rappel est évalué, l'indice du prochain élément de tableau à
              affecter et la ligne à affecter à cet élément sont fournis en
              arguments supplémentaires. rappel est évalué après la lecture de
              la ligne, mais avant l'affectation de l'élément de tableau.

              Si aucune origine explicite n'est fournie, mapfile effacera
              tableau avant de lui affecter des valeurs.

              mapfile termine avec succès sauf si une option ou un de ses
              arguments n'est pas valable, ou si tableau n'est pas valable,
              n'est pas un tableau indicé ou si son affectation est impossible.

       popd [-n] [+n] [-n]
              Enlever 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. Les
              arguments, si fournis, ont les significations suivantes :
              -n     Empêcher le changement normal de répertoire lors de la
                     suppression d'un répertoire de la pile. Seule la pile est
                     manipulée.
              +n     Supprimer le n-ième élément de la liste affichée par dirs,
                     en comptant depuis la gauche à partir de zéro. Par
                     exemple : ``popd +0'' enlève le premier répertoire, ``popd
                     +1'' le second.
              -n     Supprimer le n-ième élément de la liste affichée par dirs,
                     en comptant depuis la droite à partir de zéro. Par
                     exemple : ``popd -0'' supprime le dernier répertoire et
                     ``popd -1'' l'avant-dernier.

              Si la commande popd réussit, un dirs est effectué et l'état
              renvoyé est 0. popd renvoie faux si une option incorrecte est
              trouvée, si la pile de répertoires est vide, si le répertoire
              indiqué est absent de la pile ou si le changement de répertoire a
              échoué.

       printf [-v var] format [arguments]
              Écrire les arguments mis en forme sur la sortie standard sous le
              contrôle du format. L'option -v conduit à affecter la sortie à la
              variable var plutôt que de l'afficher sur la sortie standard.

              Ce format est une chaîne de caractères contenant trois types
              d'objets : les caractères normaux, qui sont simplement copiés sur
              la sortie standard, les caractères de protection qui sont
              convertis puis copiés sur la sortie standard et les spécifications
              de format, qui conduisent chacun à l'affichage des arguments
              successifs. En plus des spécifications de format standard de
              printf(1), printf interprète les extensions suivantes :
              %b     conduit printf à développer les suites de caractères de
                     protection dans l'argument correspondant de la même manière
                     que echo -e.
              %q     conduit printf à afficher l'argument correspondant dans un
                     format réutilisable en entrée de l'interpréteur ;
              %(formatdate)T
                     conduit printf à afficher la chaîne date-heure résultant de
                     l'utilisation de formatdate en tant que chaîne de format
                     pour strftime(3). L'argument correspondant est un entier
                     représentant le temps en seconde écoulé depuis epoch. Deux
                     valeurs particulières d'argument peuvent être utilisées :
                     -1 représente l'heure actuelle et -2 l'heure à laquelle
                     l'interpréteur a été invoqué. Si aucun argument n’est
                     indiqué, la conversion se comporte comme si -1 avait été
                     fourni. C’est une exception au comportement habituel de
                     printf.

              Les directives %b, %q et %T utilisent toutes les arguments de
              largeur et de précision de champ à partir de la spécification de
              format et écrivent autant d'octets que l'argument développé (ou
              utilisent autant d'espace qu'un champ pour cet argument) qui
              contient habituellement plus de caractères que l'original.

              Les arguments des spécificateurs de format qui ne sont pas des
              chaînes sont traités comme des constantes C, sauf qu'un signe plus
              ou moins est permis au début, et que, si le premier caractère est
              un guillemet simple ou double, la valeur est la valeur ASCII du
              caractère suivant.

              Le format est réutilisé si nécessaire pour englober tous les
              arguments. Si le format demande plus d'arguments que fournis, les
              spécifications supplémentaires se comportent comme si une valeur
              zéro ou une chaîne NULL, suivant le besoin, avaient été fournies.
              La valeur renvoyée est zéro en cas de succès, différente de zéro
              en cas d'échec.

       pushd [-n] [+n] [-n]
       pushd [-n] [rép]
              Ajouter un répertoire au sommet de la pile des répertoires ou
              effectuer une rotation dans la pile, en ramenant le répertoire
              actuel au sommet. Sans argument, la commande pushd échange les
              deux répertoires au sommet et renvoie 0, sauf si la pile est vide.
              Les arguments, si fournis, ont les significations suivantes :
              -n     Empêcher le changement normal de répertoire lors d'une
                     rotation ou d'un ajout de répertoires dans la pile. Ainsi,
                     seule la pile est manipulée.
              +n     Effectuer une rotation dans la pile, de façon à amener au
                     sommet le n-ième répertoire (de la liste affichée par dirs,
                     en comptant depuis la gauche à partir de zéro).
              -n     Effectuer une rotation dans la pile, de façon à amener au
                     sommet le n-ième répertoire (de la liste affichée par dirs,
                     en comptant depuis la gauche à partir de zéro).
              rép    Ajouter le répertoire rép au sommet de la pile de
                     répertoires et en faire le nouveau répertoire de travail
                     comme s’il avait été fourni en argument de la commande
                     interne cd.

              Si la commande pushd réussit, un dirs est aussi effectué. Avec la
              première forme, pushd renvoie 0 sauf si le déplacement vers rép
              échoue. Avec la seconde forme, pushd renvoie 0, sauf si la pile
              est vide, si un élément inexistant dans la pile est indiqué ou si
              le changement de répertoire vers le nouveau répertoire indiqué
              échoue.

       pwd [-LP]
              Afficher le chemin d'accès absolu au répertoire de travail actuel.
              Le chemin ne contiendra pas de liens symboliques si l'option -P
              est fournie, ou si l'option -o physical de la commande interne set
              est activée. Si l'option -L est utilisée, le chemin affiché peut
              contenir des liens symboliques. L'état renvoyé est 0, sauf si une
              erreur s'est produite lors de la lecture du nom du répertoire
              actuel ou si une option incorrecte est fournie.

       read [-ers] [-a tableau] [-d délimiteur] [-i texte] [-n nb_car] [-N
       nb_car] [-p invite] [-t délai] [-u df] [nom ...]
              Une ligne est lue depuis l'entrée standard ou à partir du
              descripteur de fichier df fourni en argument à l'option -u,
              découpée en mots comme décrit ci-dessus dans Découpage en mots,
              puis le premier mot de cette ligne est affecté au premier nom, le
              second mot au second nom, et ainsi de suite. S'il y a plus de mots
              que de noms, les mots restants et leurs séparateurs intercalaires
              sont affectés au dernier nom. S'il y a moins de mots lus dans le
              flux d'entrée que de variables, des valeurs vides sont affectées à
              celles restantes. Les caractères contenus dans la variable IFS
              sont utilisés pour découper la ligne en mots en utilisant les
              mêmes règles que celles utilisées par l’interpréteur pour le
              développement (décrites précédemment dans Découpage en mots). Le
              caractère contre-oblique (\) permet de supprimer toute
              signification spéciale pour le caractère suivant et autorise la
              continuation de ligne. Les options, si fournies, ont les
              significations suivantes :
              -a tableau
                     Les mots sont affectés aux indices successifs d'une
                     variable tableau de nom tableau, en commençant à 0. tableau
                     est détruit avant que de nouvelles valeurs ne soient
                     affectées. Les autres arguments nom sont ignorés.
              -d délimiteur
                     Le premier caractère de délimiteur est utilisé pour
                     terminer la ligne de saisie, plutôt qu'un changement de
                     ligne. Si délimiteur est la chaîne vide, read termine une
                     ligne quand il lit un caractère NUL.
              -e     Si l'entrée standard provient d'un terminal, la
                     bibliothèque readline (consultez READLINE ci-dessus) est
                     utilisée pour obtenir la ligne. Readline utilise les
                     configurations d'édition en cours (ou par défaut, si
                     l'édition de ligne n'était pas préalablement active), mais
                     utilise le complètement de nom de fichier par défaut de
                     readline.
              -i texte
                     Si readline est utilisée pour lire la ligne, texte est
                     placé dans le tampon d'édition avant le début de l'édition.
              -n nb_car
                     read s'arrête après avoir lu nb_car caractères plutôt que
                     d'attendre une ligne complète en entrée, mais un délimiteur
                     est respecté si moins de nb_car caractères ont été lus
                     avant le délimiteur.
              -N nb_car
                     read s'arrête après avoir lu exactement nb_car caractères
                     plutôt que d'attendre une ligne complète en entrée, sauf si
                     une fin de fichier (EOF) est rencontrée ou si read dépasse
                     son délai de réponse. Les délimiteurs rencontrés en entrée
                     ne sont pas traités spécialement et n'entraînent pas la fin
                     de read avant que nb_car caractères n'aient été lus. Le
                     résultat pas découpé selon les caractères dans IFS ; le but
                     est que la variable soit exactement des caractères lus (à
                     l'exception du caractère contre-oblique ; consultez
                     ci-dessous l'option -r).
              -p invite
                     Afficher invite sur la sortie d'erreur standard, sans
                     caractère final de changement de ligne, avant d'essayer de
                     lire toute nouvelle saisie. L'invite est affichée seulement
                     si l'entrée vient d'un terminal.
              -r     La contre-oblique n'agit pas comme un caractère de
                     protection. La contre-oblique est considérée comme faisant
                     partie de la ligne. En particulier, une contre-oblique
                     suivie d'un changement de ligne ne peut pas être considérée
                     comme une continuation de ligne.
              -s     Mode silencieux. Si une entrée arrive à partir d'un
                     terminal, les caractères ne sont pas affichés.
              -t délai
                     Conduire read à expirer et renvoyer un échec si une ligne
                     complète en entrée (ou un nombre indiqué de caractères) n'a
                     pas été lue dans le délai en seconde. délai est un nombre
                     décimal avec éventuellement des chiffres après la virgule
                     (NdT : point en l'occurrence). Cette option n'est effective
                     que si read lit l'entrée à partir d'un terminal, d'un tube,
                     ou depuis un autre fichier spécial ; elle n'a aucun effet
                     lors de la lecture d'un fichier normal. Si read expire,
                     read sauvegarde toute entrée partielle lue dans la variable
                     nom indiquée. Si délai est nul, read se termine
                     immédiatement, sans essayer de lire des données. L’état de
                     sortie est 0 si une entrée est disponible pour le
                     descripteur de fichier indiqué, non nulle sinon. L'état
                     final est supérieur à 128 si le délai est dépassé.
              -u df  Lire l'entrée à partir du descripteur de fichier df.

              Si aucun nom n'est fourni, la ligne lue, sans autre modification
              que le retrait du délimiteur de fin, est affectée à la variable
              REPLY. Le code renvoyé est zéro, sauf si une fin de fichier (EOF)
              est rencontrée, si read dépasse son délai de réponse (auquel cas
              le code renvoyé est plus grand que 128), en cas d’erreur
              d’affectation (comme une affectation de variable à une variable en
              lecture seule) ou si un descripteur de fichier incorrect est
              fourni en argument de -u.

       readonly [-aAf] [-p] [nom[=mot] ...]
              Les noms indiqués reçoivent un attribut lecture seule ; les
              valeurs de ces noms ne pourront plus être modifiées par des
              affectations ultérieures. Si l'option -f est fournie, les
              fonctions correspondant à ces noms sont marquées en conséquence.
              L'option -a restreint l'action aux variables tableaux indicés ;
              l'option -A restreint l'action aux variables tableaux associatifs.
              Si les deux options sont fournies, -A est prioritaire. Si aucun
              argument nom n'est indiqué ou si l'option -p est fournie, une
              liste de tous les noms en lecture seule est affichée. Les autres
              options peuvent être utilisées pour restreindre l'affichage à un
              sous-ensemble de l'ensemble des noms en lecture seule. L'option -p
              conduit à afficher la sortie dans un format susceptible d'être
              réutilisé en entrée. Si le nom d'une variable est suivi par =mot,
              la variable est configurée à mot. L'état renvoyé est 0, sauf si
              une option incorrecte a été rencontrée, si l'un des noms n'est pas
              un nom correct de variable de l'interpréteur ou si l'option -f est
              fournie avec un nom qui n'est pas une fonction.

       return [n]
              Forcer une fonction à arrêter son exécution et à renvoyer la
              valeur indiquée par n dans son contexte d'appel. Si n est omis, la
              valeur de retour renvoyée est celle de la dernière commande
              exécutée dans le corps de la fonction. Si return est exécuté par
              un gestionnaire de capture, la dernière commande utilisée pour
              déterminer l'état est la dernière commande exécutée avant le
              gestionnaire de capture. Si return est exécutée durant une capture
              de DEBUG, la dernière commande utilisée pour déterminer l'état est
              la dernière commande exécutée par le gestionnaire de capture avant
              que return soit invoquée. Si return est utilisée hors d'une
              fonction, mais pendant l'exécution d'un script par la commande .
              (source), elle conduit à l'arrêt de l'exécution du script par
              l'interpréteur et renvoie comme état final du script soit n, soit
              l'état final de la dernière commande exécutée dans le script. Si n
              est fourni, la valeur de retour est ses 8 bits de poids faible. La
              valeur de retour est non nulle si un argument non numérique est
              fourni à return, ou si elle est utilisée hors d'une fonction ou
              pas lors de l'exécution d'un script par . ou source. Toute
              commande associée à la capture de RETURN est exécutée avant la
              reprise de l'exécution après la fonction ou le script.

       set [--abefhkmnptuvxBCEHPT] [-o nom_d_option] [argument ...]
       set [+abefhkmnptuvxBCEHPT] [+o nom_d_option] [argument ...]
              Sans options, le nom et la valeur de toutes les variables de
              l'interpréteur sont affichés dans un format susceptible d'être
              réutilisé en entrée pour créer ou réinitialiser les variables
              actuelles. Les variables en lecture seule ne peuvent pas être
              réinitialisées. En mode POSIX, seules les variables de
              l'interpréteur sont affichées. La sortie est triée en fonction des
              paramètres linguistiques régionaux actuels. Lorsque des options
              sont indiquées, elles créent ou détruisent des attributs de
              l'interpréteur. Tous les arguments restant après traitement des
              options sont considérés comme des valeurs pour les paramètres
              positionnels et sont affectés, dans l'ordre, à : $1, $2, ... $n.
              Les options, si indiquées, ont les significations suivantes :
              -a      Donner l'attribut export aux variables et fonctions créées
                      ou modifiées et les marquer pour qu'elles soient exportées
                      dans l'environnement des commandes exécutées
                      ultérieurement.
              -b      Signaler l'état des tâches terminées en arrière-plan
                      immédiatement, plutôt que d'attendre l'affichage de la
                      prochaine invite de base. N'est effectif que si le
                      contrôle des tâches est activé.
              -e      Se terminer immédiatement si un pipeline (qui peut être
                      réduit à une unique commande simple), une liste ou une
                      commande composée (consultez GRAMMAIRE DE L'INTERPRÉTEUR
                      ci-dessus) se termine avec un état différent de zéro.
                      L'interpréteur ne se termine pas si la commande qui échoue
                      fait partie d'une liste de commandes immédiatement suivie
                      par un mot clef while ou until, d'un test suivant les mots
                      réservés if ou elif, d'une commande exécutée dans une
                      liste && ou || sauf si la commande est située après le
                      dernier && ou ||, d'une commande de pipeline à l'exception
                      de la dernière, ou si la valeur renvoyée par la commande
                      est inversée par !. Si une commande composée autre qu’un
                      sous-interpréteur renvoie un état non nul parce qu’une
                      commande échoue alors que -e était ignoré, l’interpréteur
                      ne se termine pas. Une capture sur ERR, si existante, est
                      exécutée avant que l'interpréteur ne se termine. Cette
                      option s'applique à l'environnement de l'interpréteur
                      ainsi qu'à l'environnement de chaque sous-interpréteur
                      individuellement (consultez ENVIRONNEMENT D'EXÉCUTION DES
                      COMMANDES ci-dessus), et peut conduire des
                      sous-interpréteurs à se terminer avant d'y avoir exécuté
                      toutes les commandes.

                      Si une commande composée ou une fonction de l’interpréteur
                      s’exécutent dans un contexte où -e est ignoré, aucune des
                      commandes exécutées dans une commande composée ou dans un
                      corps de fonction ne sera affectée par le réglage -e, même
                      si -e est défini et qu’une commande renvoie un état
                      d’échec. Si une commande composée ou une fonction de
                      l’interpréteur définissent -e pendant son exécution dans
                      un contexte où -e est ignoré, ce réglage n’aura aucun
                      effet avant la fin de la commande composée ou de la
                      commande contenant l’appel de fonction.
              -f      Désactiver le développement des chemins.
              -h      Mémoriser l'emplacement des commandes lors de leur
                      exécution. Activée par défaut.
              -k      Tous les arguments sous la forme d'affectations sont
                      placés dans l'environnement d'une commande, et non pas
                      seulement ceux qui précèdent le nom de la commande.
              -m      Mode supervision. Le contrôle des tâches est activé. Cette
                      option est activée par défaut pour les interpréteurs
                      interactifs sur les systèmes qui le permettent (consultez
                      CONTRÔLE DES TÂCHES ci-dessus). Tous les processus sont
                      exécutés dans un groupe de processus séparé. Quand une
                      tâche en arrière-plan se termine, l’interpréteur affiche
                      une ligne contenant son état final.
              -n      Lecture de commandes sans exécution. Cela peut être
                      utilisé pour rechercher les erreurs de syntaxe dans un
                      script. Cette option est ignorée par les interpréteurs
                      interactifs.
              -o nom_d_option
                      Le nom_d_option est l'un des suivants :
                      allexport
                              Identique à -a.
                      braceexpand
                              Identique à -B.
                      emacs   Utiliser une interface d'édition des lignes de
                              commande « à la Emacs ». C'est le comportement
                              activé par défaut quand l'interpréteur est
                              interactif, sauf si l'interpréteur est démarré
                              avec l'option --noediting. L'interface d'édition
                              utilisée par read -e est modifiée également.
                      errexit Identique à -e.
                      errtrace
                              Identique à -E.
                      functrace
                              Identique à -T.
                      hashall Identique à -h.
                      histexpand
                              Identique à -H.
                      history Activer l'historique des commandes, comme décrit
                              ci-dessus dans HISTORY. Cette option est activée
                              par défaut dans les interpréteurs interactifs.
                      ignoreeof
                              Identique à l'exécution de la commande
                              d'interpréteur ``IGNOREEOF=10'' (consultez
                              Variables de l'interpréteur ci-dessus).
                      keyword Identique à -k.
                      monitor Identique à -m.
                      noclobber
                              Identique à -C.
                      noexec  Identique à -n.
                      noglob  Identique à -f.
                      nolog   Actuellement ignorée.
                      notify  Identique à -b.
                      nounset Identique à -u.
                      onecmd  Identique à -t.
                      physical
                              Identique à -P.
                      pipefail
                              Si existante, la valeur renvoyée par un pipeline
                              est la valeur de la dernière commande (la plus à
                              droite) à terminer avec un état final différent de
                              zéro ou zéro si toutes les commandes du pipeline
                              terminent avec succès. Désactivée par défaut.
                      posix   Aligner le comportement de bash sur la norme (mode
                              POSIX), en ce qui concerne les options dont
                              l'action par défaut diffère de la norme POSIX. La
                              section VOIR AUSSI ci-dessous référence un
                              document précisant la façon dont le mode POSIX
                              affecte le comportement de bash.
                      privileged
                              Identique à -p.
                      verbose Identique à -v.
                      vi      Utiliser une interface d'édition des lignes de
                              commande « à la vi ». L'interface d'édition
                              utilisée par read -e est modifiée également.
                      xtrace  Identique à -x.
                      Si -o est fournie sans nom_d_option, les valeurs actuelles
                      des options sont affichées. Si +o est fournie sans
                      nom_d_option, la série de commandes set permettant de
                      recréer la configuration actuelle d'options est affichée
                      sur la sortie standard.
              -p      Basculer en mode privilégié. Dans ce mode, les fichiers
                      $ENV et $BASH_ENV ne sont pas traités, les fonctions de
                      l'interpréteur ne sont pas héritées de l'environnement, et
                      les variables SHELLOPTS, BASHOPTS, CDPATH, et GLOBIGNORE,
                      si présentes dans l'environnement, sont ignorées. Si
                      l'interpréteur démarre avec un UID (ou respectivement un
                      GID) effectif différent de son UID (GID) réel et si
                      l'option -p n'est pas fournie, ce comportement est
                      appliqué et l'UID (GID) effectif est positionné à l'UID
                      (GID) réel. Si l'option -p est fournie au démarrage, l'UID
                      (GID) effectif n'est pas modifié. Désactiver cette option
                      conduit à la configuration des UID et GID effectifs à la
                      valeur des UID et GID réels.
              -t      Terminer après lecture et exécution d'une commande.
              -u      Considérer les variables inexistantes et les paramètres
                      différents des paramètres spéciaux « @ » et « * » comme
                      des erreurs lors du développement des paramètres. Si un
                      développement de variable inexistante ou de paramètre est
                      tenté, l'interpréteur affiche un message d'erreur et, s'il
                      n'est pas interactif, termine avec un état différent de
                      zéro.
              -v      Afficher les lignes en entrée de l'interpréteur
                      lorsqu'elles sont lues.
              -x      Après le développement de chaque commande simple, commande
                      for, commande case, commande select ou commande for
                      arithmétique, afficher la valeur développée de PS4, suivie
                      de la commande et ses arguments développés ou la liste de
                      mots associés.
              -B      L'interpréteur effectue le développement des accolades
                      (consultez Développement des accolades ci-dessus). Activée
                      par défaut.
              -C      Si configurée, bash n'écrasera pas un fichier existant
                      avec les opérateurs >, >& et <>. Ce comportement peut être
                      surpassé lors de la création d'un fichier de sortie en
                      utilisant l'opérateur de redirection >| à la place de >.
              -E      Si configurée, toute capture sur ERR est héritée par les
                      fonctions d'interpréteur, les substitutions de commandes
                      et les commandes exécutées dans un sous-interpréteur. La
                      capture de ERR n'est normalement pas héritée dans de tels
                      cas.
              -H      Activer le style ! de substitution d'historique. C'est le
                      comportement par défaut lorsque l'interpréteur est
                      interactif.
              -P      Si configurée, l'interpréteur ne résout pas les liens
                      symboliques en exécutant des commandes comme cd qui
                      modifient le répertoire de travail. Il utilise à la place
                      le répertoire physique. Par défaut bash suit la chaîne
                      logique des répertoires lors des commandes qui modifient
                      le répertoire actuel.
              -T      Si configurée, toutes les captures de DEBUG et RETURN sont
                      héritées par les fonctions de l'interpréteur, les
                      substitutions de commande et les commandes exécutées dans
                      un sous-interpréteur. Les captures de DEBUG et RETURN ne
                      sont normalement pas héritées dans de tels cas.
              --      Si aucun argument ne suit cette option, alors les
                      paramètres positionnels sont détruits. Sinon, les
                      paramètres positionnels sont configurés aux arguments,
                      même si certains d'entre eux commencent par un -.
              -       Marquer la fin des options, tous les arguments restants
                      sont alors affectés aux paramètres positionnels. Les
                      options -x et -v sont désactivées. 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 « - », les options
              sont désactivées. Les options peuvent également être fournies en
              argument lors de l'appel de l'interpréteur. Le jeu actuel des
              options peut être trouvé dans $-. La valeur renvoyée est toujours
              vrai, sauf si une option incorrecte est rencontré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 détruits. n doit être un entier positif inférieur ou
              égal à $#. Si n vaut 0, aucun paramètre n'est modifié. Si n est
              omis, on suppose qu'il vaut 1. Si n est supérieur à $#, les
              paramètres positionnels ne sont pas modifiés. L'état renvoyé est
              strictement positif si n est supérieur à $# ou strictement
              négatif, sinon 0 est renvoyé.

       shopt [-pqsu] [-o] [nom_opt ...]
              Basculer la valeur des réglages contrôlant le comportement de
              gestion des options de l'interpréteur. Les réglages peuvent soit
              être ceux ci-dessous, soit, si l’option -o est utilisée, ceux
              disponibles avec l’option -o de la commande interne set. Sans
              option ou avec l'option -p, une liste de toutes les options
              configurables est affichée, avec l'indication de l'état de chacune
              d'entre elles ; si des nom_opt sont fournis, la sortie est limitée
              à ces options. L'option -p conduit à un affichage de la sortie
              sous une forme susceptible d'être réutilisée en entrée. Les autres
              options ont les significations suivantes :
              -s     Activer (créer) chaque nom_opt.
              -u     Désactiver (détruire) chaque nom_opt.
              -q     Supprimer la sortie normale (mode silencieux) ; l'état
                     renvoyé indique si nom_opt est existante ou non. Si
                     plusieurs arguments nom_opt sont indiqués avec -q, l'état
                     renvoyé est zéro si tous les nom_opt sont activés ;
                     différent de zéro sinon.
              -o     Restreindre les valeurs de nom_opt à celles définies pour
                     l'option -o de la commande interne set.

              Si l'option -s ou -u est utilisée sans argument nom_opt, shopt
              affiche respectivement les options existantes ou non existantes.
              Sauf indication contraire, les options shopt sont désactivées
              (détruites) par défaut.

              L'état renvoyé lors d'un affichage des options est zéro si tous
              les nom_opt sont activés, différent de zéro sinon. Lors de la
              création ou de la destruction d'options, l'état renvoyé est zéro,
              à moins que nom_opt ne soit pas une option correcte
              d'interpréteur.

              La liste des options shopt est :

              assoc_expand_once
                      Si existante, l'interpréteur supprime les évaluation
                      multiples des indices de tableaux associatifs pendant
                      l'évaluation d'expressions arithmétiques, lors de
                      l'exécution de commandes internes qui peuvent affecter des
                      variables et lors de l'exécution de commandes internes qui
                      réalisent un déréférencement de tableau.
              autocd  Si existante, un nom de commande qui est le nom d'un
                      répertoire est exécuté comme s'il était l'argument de la
                      commande interne cd. Cette option n'est utilisée que par
                      les interpréteurs interactifs.
              cdable_vars
                      Si existante, un argument de la commande interne cd qui
                      n'est pas un répertoire est supposé être un nom de
                      variable dont la valeur est le répertoire visé.
              cdspell Si existante, les erreurs minimes de frappe dans un
                      composant du répertoire en argument de la commande cd
                      seront corrigées. Les erreurs corrigées sont les
                      inversions d'un caractère, un caractère manquant et un
                      caractère en trop. Si une correction est possible, le nom
                      de répertoire corrigé est affiché et la commande est
                      exécuté. Cette option n'est utilisée que par les
                      interpréteurs interactifs.
              checkhash
                      Si existante, bash vérifie si une commande trouvée dans la
                      table de hachage existe avant d'essayer de l'exécuter. Si
                      une commande hachée n'existe plus, une recherche normale
                      de chemin est effectuée.
              checkjobs
                      Si existante, bash affiche la liste des états de toutes
                      les tâches en cours et arrêtées avant de terminer un
                      interpréteur interactif. Si des tâches sont en cours, la
                      sortie est différée jusqu'à ce qu'une nouvelle sortie soit
                      tentée sans commande intermédiaire (consultez CONTRÔLE DES
                      TÂCHES ci-dessus). L'interpréteur repousse toujours la
                      sortie si des tâches sont arrêtées.
              checkwinsize
                      Si existante, bash vérifie la taille de la fenêtre après
                      chaque commande externe et, au besoin, met à jour les
                      valeurs des variables LINES et COLUMNS.
              cmdhist Si existante, bash essaie de sauvegarder les commandes
                      s'étendant sur plusieurs lignes en un seul élément
                      d'historique. Cela facilite l'édition ultérieure de
                      commandes multilignes. Cette option est activée par
                      défaut, mais n'a un effet que si l'historique des
                      commandes est activé, comme décrit ci-dessus dans HISTORY.
              compat31
              compat32
              compat40
              compat41
              compat42
              compat43
              compat44
                      Ces directives contrôlent les aspects du mode de
                      compatibilité de l'interpréteur (consultez MODE DE
                      COMPATIBILITÉ DE L'INTERPRÉTEUR ci-dessous).

              complete_fullquote
                      Si existante, bash protège tous les métacaractères de
                      l’interpréteur dans les noms de fichier et de répertoire
                      lors du complètement. Si non existante, bash supprime les
                      métacaractères comme les signes dollar du jeu de
                      caractères qui sera protégé dans les noms de fichiers
                      complétés quand ces métacaractères apparaissent dans des
                      références de variable d’interpréteur dans des mots à
                      compléter. Cela signifie que les signes dollar dans les
                      noms de variables qui se développent en répertoires ne
                      seront pas protégés ; cependant, tous les signes dollar
                      apparaissant dans les noms de fichier ne seront pas
                      protégés non plus. Ce n’est actif que si bash utilise des
                      contre-obliques pour protéger des noms de fichier
                      complétés. Cette variable est définie par défaut, ce qui
                      est le comportement de bash par défaut jusqu’à la
                      version 4.2.

              direxpand
                      Si existante, bash remplace les noms de répertoire par les
                      résultats de développement de mots lors du complètement
                      des noms de fichier. Cela modifie le contenu du tampon
                      d'édition de readline. Sinon, bash essaye de conserver ce
                      que l'utilisateur a tapé.

              dirspell
                      Si existante, bash essaie de corriger les erreurs de
                      frappe sur les noms de répertoire lors du complètement de
                      mot si le nom de répertoire initialement fourni n'existe
                      pas.

              dotglob Si existante, bash inclut les noms de fichiers commençant
                      par un « . » dans les résultats des développements de
                      chemins. Les noms de fichier « . » et « .. » doivent
                      toujours être toujours être mis en correspondance
                      explicitement, même si dotglob existe.

              execfail
                      Si existante, un interpréteur non interactif ne terminera
                      pas s'il ne peut exécuter un fichier indiqué en argument
                      de la commande interne exec. Un interpréteur interactif ne
                      termine pas si exec échoue.

              expand_aliases
                      Si existante, les alias sont développés comme décrit
                      ci-dessus, dans ALIAS. Cette option est activée par défaut
                      pour les interpréteurs interactifs.

              extdebug
                      Si elle existe à l'appel de l'interpréteur ou dans un
                      fichier de lancement de l'interpréteur, prend les
                      dispositions pour que le paramétrage du traçage soit
                      exécuté avant que l'interpréteur démarre, identique à
                      l'option --debugger. Si elle est posée après l'appel, le
                      comportement prévu pour l'utilisation du traçage est
                      activé :

                      1.     L'option -F de la commande interne declare affiche
                             le nom du fichier source et le numéro de ligne
                             correspondant à chaque nom de fonction fourni comme
                             argument.

                      2.     Si la commande lancée par la capture de DEBUG
                             renvoie une valeur différente de zéro, la commande
                             suivante est sautée et n'est pas exécutée.

                      3.     Si la commande lancée par la capture de DEBUG
                             renvoie la valeur 2 et si l'interpréteur s'exécute
                             dans un sous-programme (une fonction de
                             l'interpréteur ou un script exécuté par les
                             commandes internes . ou source), l'interpréteur
                             simule un appel à return.

                      4.     BASH_ARGC et BASH_ARGV sont mises à jour comme
                             expliqué dans leurs descriptions ci-dessus.

                      5.     Le traçage des fonctions est activé : la
                             substitution de commande, les fonctions de
                             l'interpréteur et les sous-interpréteurs appelés
                             avec ( command ) héritent des captures de DEBUG et
                             RETURN.

                      6.     Le traçage d'erreur est activé : la substitution de
                             commande, les fonctions de l'interpréteur et les
                             sous-interpréteurs appelés avec ( command )
                             héritent de la capture de ERR.

              extglob Si existante, les fonctionnalités étendues de mise en
                      correspondance décrites ci-dessus dans Développement des
                      chemins sont activées.

              extquote
                      Si existante, la protection par $'chaîne' et $"chaîne" est
                      effectuée à l'intérieur des développements de
                      ${paramètres} entre guillemets doubles. Cette option est
                      activée par défaut.

              failglob
                      Si existante, les motifs qui échouent à faire correspondre
                      les noms de fichiers pendant le développement des chemins
                      font qu'ils provoqueront une erreur de développement.

              force_fignore
                      Si existante, les suffixes indiqués par la variable de
                      l'interpréteur FIGNORE conduiront des mots à être ignorés
                      lors du complètement de mot, même si les mots ignorés sont
                      les seuls complètements possibles. Consultez VARIABLES DE
                      L'INTERPRÉTEUR ci-dessus pour une description de FIGNORE.
                      Cette option est activée par défaut.

              globasciiranges
                      Si existante, les expressions d’intervalle utilisées dans
                      les motifs de correspondance des expressions entre
                      crochets (consultez Motifs génériques ci-dessus) se
                      comportent comme avec les paramètres régionaux
                      traditionnels de C lors des comparaisons. Cela signifie
                      que l’ordre de collation des paramètres régionaux actuels
                      n’est pas pris en compte, donc b ne sera pas ordonné entre
                      A et B, et les caractères ASCII en majuscule et minuscule
                      seront fusionnés.

              globstar
                      Si existante, le motif ** utilisé dans un contexte de
                      développement des chemins correspondra à tous les fichiers
                      et zéro ou plusieurs répertoires et sous-répertoires. Si
                      le motif est suivi de /, seuls les répertoires et
                      sous-répertoires correspondent.

              gnu_errfmt
                      Si existante, les messages d'erreur de l'interpréteur
                      seront écrits dans le format standard GNU des messages
                      d'erreurs.

              histappend
                      Si existante, la file d'historique est ajoutée au fichier
                      désigné par la valeur de la variable HISTFILE lorsque
                      l'interpréteur termine, plutôt que d'écraser ce fichier.

              histreedit
                      Si existante et si readline est utilisée, un utilisateur
                      peut rééditer une substitution d'historique qui a échoué.

              histverify
                      Si existante et si readline est utilisée, le résultat de
                      la substitution d'historique n'est pas transmise
                      immédiatement à l'analyseur de l'interpréteur. À la place,
                      la ligne résultante est chargée dans le tampon d'édition
                      de readline, permettant des modifications ultérieures.

              hostcomplete
                      Si existante et si readline est utilisée, bash essayera
                      d'effectuer le complètement des noms de machines lorsqu'un
                      mot contient un @ (consultez Complètement dans READLINE
                      ci-dessus). Cette option est activée par défaut.

              huponexit
                      Si existante, bash enverra un signal SIGHUP à toutes les
                      tâches lorsqu'un interpréteur de connexion interactif
                      termine.

              inherit_errexit
                      Si existante, la substitution de commande hérite de la
                      valeur de l'option errexit, plutôt que de la détruire dans
                      l'environnement du sous-interpréteur. Cette option est
                      activée quand le mode POSIX est activé.

              interactive_comments
                      Si existante, un mot commençant par un # conduira ce mot
                      et tous les autres caractères restants de la ligne à être
                      ignorés dans un interpréteur interactif (consultez
                      COMMENTAIRES ci-dessus). Cette option est activée par
                      défaut.

              lastpipe
                      Si existante, et que le contrôle des tâches n'est pas
                      activé, l'interpréteur exécute la dernière commande d'un
                      pipeline non exécutée en arrière-plan dans l'environnement
                      d'interpréteur actuel.

              lithist Si existante et si l'option cmdhist est activée, les
                      commandes multilignes sont sauvegardées dans l'historique
                      avec des changements de ligne incorporés comme séparateurs
                      plutôt que des points-virgules là où c'est possible.

              localvar_inherit
                      Si existante, les variables locales héritent de la valeur
                      et des attributs d'une variable du même nom qui existe
                      avec une portée antérieure avant qu'une nouvelle valeur
                      soit assignée. L'attribut -nameref n'est pas hérité.

              localvar_unset
                      Si existante, appeler unset sur des variables locales dans
                      des portées de fonction antérieures les marque de telle
                      manière que des recherches ultérieures les trouve
                      désactivées jusqu'à ce la fonction renvoie. Ce
                      comportement est le même que de détruire les variables
                      locales avec la portée de la fonction actuelle.

              login_shell
                      L'interpréteur crée cette option s'il est démarré en tant
                      qu'interpréteur de connexion (consultez APPEL ci-dessus).
                      La valeur ne peut être modifiée.

              mailwarn
                      Si existante et s'il a été accédé à un fichier que bash
                      surveille pour les courriers depuis sa dernière
                      vérification, le message « Le courrier dans
                      fichier_de_courrier a été lu. » est affiché.

              no_empty_cmd_completion
                      Si existante et si readline est utilisée, bash n'essaiera
                      pas d'utiliser le PATH pour de possibles complètements
                      quand le complètement est tenté sur une ligne vide.

              nocaseglob
                      Si existante, bash fait correspondre les noms de fichiers
                      d'une façon insensible à la casse lors du développement
                      des chemins (consultez Développement des chemins
                      ci-dessus).

              nocasematch
                      Si existante, bash fait correspondre les motifs d'une
                      façon insensible à la casse lors de la mise en
                      correspondance pendant l'exécution des commandes
                      conditionnelles case ou [[, lorsqu'il procède à des
                      développements de motif de substitution de mot ou qu'il
                      filtre des complètement possibles dans le cadre d'un
                      complètement programmable.

              nullglob
                      Si existante, bash autorise les motifs ne correspondant à
                      aucun fichier (consultez Développement des chemins
                      ci-dessus) à se développer en une chaîne NULL plutôt qu'en
                      une valeur littérale.

              progcomp
                      Si existante, les outils de complètement programmables
                      (consultez Complètement programmable ci-dessus) sont
                      activés. Cette option est activée par défaut.

              progcomp_alias
                      Si existante et si le complètement programmable est
                      activé, bash traite un nom de commande qui n'a pas de
                      complètement comme un possible alias et tente un
                      développement d'alias. S'il possède un alias, bash tente
                      un complètement programmable en utilisant le nom de
                      commande résultant du développement d'alias.

              promptvars
                      Si existante, les chaînes d'invite sont sujettes au
                      développement des paramètres, à la substitution de
                      commande, au développement arithmétique et à la
                      suppression des protections après avoir été développées
                      comme décrit ci-dessus dans INVITES. Cette option est
                      activée par défaut.

              restricted_shell
                      L'interpréteur crée cette option s'il est démarré en mode
                      restreint (consultez INTERPRÉTEUR RESTREINT ci-dessous).
                      Cette valeur ne peut pas être changée. Elle n'est pas
                      réinitialisée lorsque les fichiers d’initialisation sont
                      exécutés, ce qui permet à ces fichiers de découvrir si un
                      interpréteur est restreint ou non.

              shift_verbose
                      Si existante, la commande interne shift affiche un message
                      d'erreur lorsque le nombre de décalages dépasse le nombre
                      de paramètres positionnels.

              sourcepath
                      Si existante, la commande interne source (.) utilise la
                      valeur de la variable PATH pour trouver le répertoire
                      contenant le fichier fourni en argument. Cette option est
                      activée par défaut.

              xpg_echo
                      Si existante, la commande interne echo développe par
                      défaut les suites de caractères de protection par
                      contre-oblique.

       suspend [-f]
              Suspendre l'exécution de l'interpréteur jusqu'à la réception d'un
              signal SIGCONT. Un interpréteur de connexion ne peut pas être
              suspendu ; l'option -f permet de surpasser ce comportement et
              force sa suspension. L'état renvoyé est 0, sauf si l'interpréteur
              est un interpréteur de connexion et que l'option -f est absente,
              ou si le contrôle des tâches n'est pas activé.

       test expr
       [ expr ]
              Renvoyer un état 0 (vrai) ou 1 (faux) suivant l'évaluation de la
              condition expr. Chaque opérateur et opérande doit être représenté
              par un argument distinct.  Expressions are composed of the
              primaries described above under CONDITIONS. test n'accepte aucune
              option, n'accepte pas non plus et ignore l'argument -- pour
              signifier la fin des options.

              Les conditions peuvent être combinées avec les opérateurs suivant,
              décrits par ordre de priorité décroissante. L'évaluation dépend du
              nombre d'arguments, voir ci-dessous. La priorité des opérateurs
              est utilisée quand il y a au moins cinq arguments.
              ! expr Vrai si expr est fausse.
              ( expr )
                     Renvoie la valeur de expr. Peut servir à surpasser la
                     priorité normale des opérateurs.
              expr1 -a expr2
                     Vrai si expr1 et expr2 sont toutes deux vraies.
              expr1 -o expr2
                     Vrai si expr1 ou expr2 est vraie.

              test et [ évaluent les conditions en fonction d'un jeu de règles
              dépendant du nombre d'arguments.

              0 argument
                     La condition est fausse.
              1 argument
                     La condition est vraie si et seulement si l'argument n'est
                     pas NULL.
              2 arguments
                     Si le premier argument est !, la condition est vraie si et
                     seulement si le second argument est NULL. Si le premier
                     argument est l'un des opérateurs conditionnel unaires
                     décrits ci-dessus dans CONDITIONS la condition est vraie si
                     le test unaire est vrai. Si le premier argument n'est pas
                     un opérateur conditionnel unaire correct, la condition est
                     fausse.
              3 arguments
                     Les conditions suivantes sont appliquées dans l'ordre de la
                     liste. Si le second argument est l'un des opérateurs
                     conditionnels binaires décrits ci-dessus dans CONDITIONS,
                     le résultat de la condition est le résultat du test binaire
                     utilisant le premier et le troisième argument en tant
                     qu'opérandes. Les opérateurs -a et -o sont considérés comme
                     des opérateurs binaires quand ils sont avec trois
                     arguments. Si le premier argument est !, la valeur est la
                     négation du test binaire utilisant les deuxième et
                     troisième arguments. Si le premier argument est exactement
                     ( et le troisième argument est exactement ), le résultat
                     est le test unaire du second argument. Sinon la condition
                     est fausse.
              4 arguments
                     Si le premier argument est !, le résultat est la négation
                     de la condition à trois arguments composée des arguments
                     restants. Sinon la condition est analysée et évaluée selon
                     les règles de priorité décrites ci-dessus.
              5 arguments ou plus
                     La condition est analysée et évaluée selon les règles de
                     priorité décrites ci-dessus.

              Lorsqu'ils sont utilisés avec test ou [, les opérateurs < et >
              ordonnent d'un point de vue lexicographique en utilisant l'ordre
              ASCII.

       times  Afficher les durées cumulées utilisateur et système pour
              l'interpréteur et les processus lancés par cet interpréteur.
              L'état renvoyé est 0.

       trap [-lp] [[argument] signal ...]
              La commande argument doit être lue et exécutée quand
              l'interpréteur reçoit au moins un signal. Si argument est absent
              (et qu'un seul signal est fourni) ou -, chaque signal indiqué est
              réinitialisé à sa position d'origine (la valeur qu'il avait lors
              de l'entrée dans l'interpréteur). Si argument est la chaîne NULL,
              chaque signal indiqué est ignoré par l'interpréteur et par les
              commandes qu'il appelle. Si argument n'est pas présent et que -p
              est fourni, les commandes capturées associées à chaque signal sont
              affichées. Si aucun argument n'est fourni, ou si seul -p est
              donné, trap affiche la liste des commandes associées à chaque
              signal. L'option -l conduit l'interpréteur à afficher une liste
              des noms de signal et leur numéro correspondant. Chaque signal est
              soit un nom de signal défini dans <signal.h>, soit un numéro de
              signal. Les noms de signal sont insensibles à la casse et le
              préfixe SIG est optionnel.

              Si un signal est EXIT (0), la commande argument est exécutée lors
              de la sortie de l'interpréteur. Si un signal est DEBUG, la
              commande argument est exécutée avant toute commande simple,
              commande for, commande case, commande select, toute commande for
              arithmétique, et avant que la première commande n'exécute une
              fonction de l'interpréteur (consultez GRAMMAIRE DE L'INTERPRÉTEUR
              ci-dessus). Reportez-vous à la description de l'option extdebug de
              la commande interne shopt pour obtenir des renseignements sur les
              effets de la capture DEBUG. Si un signal est RETURN, la commande
              argument est exécutée à chaque fois qu'une fonction de
              l'interpréteur, ou un script exécuté avec les commandes internes .
              ou source, termine son exécution.

              Si un signal est ERR, la commande argument est exécutée chaque
              fois qu'un pipeline (qui peut être réduit à une unique commande
              simple), une liste ou une commande composée, renvoie un état final
              différent de zéro, soumis aux conditions suivantes. La capture ERR
              n'est pas exécutée si la commande échouant fait partie d'une liste
              de commandes suivant immédiatement un mot clef while ou until,
              d'un test dans une construction if, d'une commande exécutée au
              sein d'une liste de && ou de || exceptée la commande suivant le
              dernier && ou ||, n’importe quelle commande d’un pipeline sauf la
              dernière, ou si la valeur renvoyée par la commande est inversée
              par !. Ce sont les mêmes conditions que celles observées par
              l'option errexit (-e).

              Les signaux ignorés en entrant dans l'interpréteur ne peuvent être
              capturés, réinitialisés ou listés. Les signaux capturés qui ne
              sont pas ignorés sont réinitialisés à leur valeur d'origine dans
              un sous-interpréteur ou un environnement de sous-interpréteur
              quand il est créé. L'état renvoyé est faux si un signal n'est pas
              valable, sinon trap renvoie vrai.

       type [-aftpP] nom [nom ...]
              Sans option, indiquer la façon d’interpréter chaque nom s’il est
              utilisé en nom de commande. Si l'attribut -t est utilisé, type
              affiche une des chaînes alias, keyword, function, builtin ou file
              selon que le nom est un alias, un mot clef réservé de
              l'interpréteur, une fonction, une commande interne ou un fichier
              sur le disque. Si le nom n'est pas trouvé, rien n'est affiché et
              un état final à faux est renvoyé. Si l'option -p est utilisée,
              type renvoie le nom du fichier qui sera exécuté si l'on tape le
              nom en guise de commande ou rien si ``type -t name'' ne renvoyait
              pas file. L'option -P force une recherche dans PATH pour chaque
              nom, même si ``type -t name'' ne renvoyait pas file. Si une
              commande est disponible dans la table de hachage, -p et -P
              affichent la valeur de cette table, qui n'est pas nécessairement
              le fichier apparaissant en premier dans PATH. Si l'option -a est
              appelée, type affiche tous les emplacements contenant un
              exécutable du nom indiqué. Cela inclut les alias et les fonctions,
              sauf si l'option -p est également présente. La table de hachage
              des commandes n'est pas consultée avec l'option -a. L'option -f
              supprime la fonction de l'interpréteur de consultation de table,
              comme avec la commande interne command. type renvoie vrai si tous
              les arguments sont trouvés et faux si aucun n'a été trouvé.

       ulimit [-HS] -a
       ulimit -HS] [-bcdefiklmnpqrstuvxPRT [limitation]]
              Fournir, sur les systèmes qui le permettent, un mécanisme de
              contrôle des ressources disponibles pour l'interpréteur et pour
              les processus qu'il lance. Les options -H et -S indiquent si la
              limitation est stricte (« hard ») ou flexible (« soft ») pour la
              ressource indiquée. Une limitation stricte ne peut pas être
              augmentée par un utilisateur non privilégié une fois qu'elle a été
              configurée ; une limitation flexible peut être augmentée jusqu'à
              la valeur de la limitation stricte correspondante. Si ni -H ni -S
              n'est indiqué, les limitations stricte et flexible sont toutes
              deux configurées. La valeur de la limitation peut être un nombre
              (utilisant les unités particulières de la ressource) ou l'une des
              valeurs spéciales hard, soft ou unlimited, qui signifient,
              respectivement, la limitation stricte actuelle, la limitation
              flexible actuelle et l'absence de limitation. Si la limitation est
              omise, la valeur actuelle de la limitation flexible pour la
              ressource est affichée, à moins que l'option -H soit indiquée.
              Quand plusieurs ressources sont indiquées, les noms des
              limitations et leurs unités, le cas échéant, sont affichés avant
              les valeurs. Les autres options sont interprétées comme suit :
              -a     Toutes les limitations actuelles sont signalées ; aucune
                     limitation n'est fixée
              -b     La taille maximale du tampon de socket
              -c     La taille maximale des fichiers core créés
              -d     La taille maximale du segment de données d'un processus
              -e     La priorité maximale d’ordonnancement (« nice »)
              -f     La taille maximale d'un fichier écrit par l'interpréteur et
                     ses enfants
              -i     Le nombre maximal de signaux en attente
              -k     Le nombre maximal de kqueue qui peuvent être alloués
              -l     La taille maximale qui peut être verrouillée en mémoire
              -m     La taille maximale de la partie résidente d'un processus
                     (« resident set size » ou RSS, la plupart des systèmes ne
                     respectent pas cette limite)
              -n     Le nombre maximal de descripteurs de fichiers ouverts (la
                     plupart des systèmes ne permettent pas de modifier cette
                     valeur)
              -p     La taille d'un tube en blocs de 512 octets (parfois
                     inexistante)
              -q     Le nombre maximal d'octets dans les files de messages POSIX
              -r     La priorité maximale d'ordonnancement temps-réel
              -s     La taille maximale de la pile
              -t     La durée maximale, en seconde, de temps processeur accordé
                     à un processus
              -u     Le nombre maximal de processus autorisés pour un seul
                     utilisateur
              -v     La quantité maximale de mémoire virtuelle disponible pour
                     l'interpréteur et, sur certains systèmes, pour ses enfants
              -x     Le nombre maximal de verrous de fichiers
              -P     Le nombre maximal de pseudo-terminaux
              -R     La durée maximale pendant laquelle un processus en temps
                     réel peut s'exécuter avant de bloquer, en microsecondes.
              -T     Le nombre maximal de processus légers (« threads »)

              Si une limitation est indiquée, et que l'option -a n’est pas
              donnée, limitation sera la nouvelle valeur pour la ressource
              indiquée. Si aucune option n'est indiquée alors -f est supposée.
              Les valeurs s'expriment par pas de 1024 octets, sauf pour -t qui
              est en seconde, -R qui est en microseconde, -p qui utilise comme
              unité le bloc de 512 octets ; pour -P, -T, -b, -k, -n et -u qui
              n'ont pas d'unité ; enfin, en mode POSIX, la valeur pour -c et -f
              s'exprime par pas de 512 octets. L'état renvoyé est 0, sauf si une
              option ou un argument incorrect ont été fournis ou si une erreur
              se produit en configurant la nouvelle limitation. En mode POSIX,
              des blocs de 512 octets sont utilisés pour les options -c et -f.

       umask [-p] [-S] [mode]
              Le masque de création de fichier de l'utilisateur est configuré à
              mode. 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 acceptés par chmod(1). Si mode est omis ou si
              l'option -S est fournie, la valeur actuelle du masque est
              affichée. L'option -S conduit à l'affichage du masque sous forme
              symbolique, l'affichage par défaut étant en octal. Si l'option -p
              est fournie et si le mode est omis, la sortie a lieu dans un
              format réutilisable en entrée. L'état renvoyé est 0 si le mode a
              pu être changé correctement ou si aucun argument mode n'a été
              fourni, et faux sinon.

       unalias [-a] [nom ...]
              Supprimer le nom de la liste des alias définis. Si l'option -a est
              fournie, toutes les définitions d'alias sont supprimées. La valeur
              renvoyée est vrai, sauf si un nom fourni n'est pas un alias
              défini.

       unset [-fv] [-n] [nom ...]
              Pour chaque nom indiqué, supprimer la variable ou la fonction
              correspondante. Si l'option -v est indiquée, chaque nom se
              rapporte à une variable de l'interpréteur, et cette variable est
              supprimée. Les variables en lecture seule ne peuvent pas être
              détruites. Si l'option -f est indiquée, chaque nom se rapporte à
              une fonction de l'interpréteur et la définition de la fonction est
              supprimée. Si l’option -n est fournie, et que nom est une variable
              avec l’attribut nameref, nom sera détruite plutôt que la variable
              qu’elle référence. -n n’a pas d’effet si l’option -f est fournie.
              Si aucune option n’est fournie, chaque nom fait référence à une
              variable ; si aucune variable de ce nom n’existe, toutes les
              fonctions de ce nom sont détruites. Toutes les variables et
              fonctions détruites sont supprimées de l'environnement transmis
              aux commandes ultérieures. Si l'une des variables BASH_ALIASES,
              BASH_ARGV0, BASH_CMDS, BASH_COMMAND, BASH_SUBSHELL, BASHPID,
              COMP_WORDBREAKS, DIRSTACK, EPOCHREALTIME, EPOCHSECONDS, FUNCNAME,
              GROUPS, HISTCMD, LINENO, RANDOM, SECONDS, ou SRANDOM est détruite,
              elle perd ses propriétés particulières, même si elle est recréée
              ultérieurement. L'état final est vrai sauf si un des noms est en
              lecture seule.

       wait [-fn] [-p nom_de_variable] [id ...]
              Attendre que tous les processus enfants indiqués s’exécutent et
              renvoient leur état final. Chaque id peut être un PID ou une
              spécification de tâche ; si une spécification de tâche est
              indiquée, la fin de tous les processus du pipeline de cette tâche
              sera attendue. Si id est omis, wait attend la fin de toutes les
              tâches exécutées en arrière-plan et la substitution du dernier
              processus exécuté, si l'id du processus est le même que $!, et le
              code de retour est zéro. Si l’option -n est fournie, wait attend
              qu'une seule tâche de la liste d'id ou, si aucun id n'est fourni,
              que toutes les tâches se terminent et renvoient leur état final.
              Si aucun des arguments fournis n'est un enfant de l'interpréteur,
              l'état renvoyé est 127. Si l'option -p est fournie,
              l'identificateur de processus ou de tâche de la tâche pour
              laquelle l'état final est renvoyé est affecté à la variable
              nom_de_variable nommée par l'argument de l'option. La variable
              sera détruite initialement, avant toute affectation. C'est utile
              seulement lorsque l'option -n est fournie. Fournir l'option -f,
              quand le contrôle des tâches est activé, force wait à attendre que
              id se termine avant de renvoyer son état, plutôt que de renvoyer
              son état quand il change. Si id indique un processus ou une tâche
              inexistants, l'état renvoyé est 127. Sinon, l'état renvoyé est
              l'état final du dernier processus, ou tâche, attendu.

MODE DE COMPATIBILITÉ DE L'INTERPRÉTEUR
       Bash-4.0 a introduit le concept de « niveau de compatibilité de
       l'interpréteur » spécifié comme un ensemble d'options de la commande
       interne shopt (compat31, compat32, compat40, compat41, etc.). Il ne peut
       y avoir qu'un seul niveau de compatibilité en cours – les options
       s'excluent mutuellement. Le niveau de compatibilité est destiné à
       permettre aux utilisateurs de choisir un comportement d'une version
       antérieure qui est incompatible avec les versions plus récentes lors des
       migrations de scripts pour utiliser les fonctionnalités et les
       comportements actuels. C'est censé être une solution temporaire.

       Cette section ne mentionne pas les comportements standards d'une version
       particulière (par exemple, la configuration à compat32 signifie que la
       protection de la partie droite de l'opérateur de correspondance d'une
       expression rationnelle protège les caractères spéciaux d'expression
       rationnelle dans le mot, ce qui est le comportement par défaut dans
       bash-3.2 et les versions suivantes).

       Si l'utilisateur active, par exemple, compat32, cela peut affecter le
       comportement des autres niveaux de compatibilité jusqu'à, et y compris,
       le niveau de compatibilité en cours. L'idée est que chaque niveau de
       compatibilité contrôle les comportements qui ont changé dans cette
       version de bash, mais ces comportements peuvent avoir été présents dans
       des versions précédentes. Par exemple, la modification pour utiliser les
       comparaisons basées sur les paramètres linguistiques régionaux avec la
       commande [[ a été introduite dans bash-4.1 et les versions précédentes
       utilisaient des comparaisons basées sur ASCII, aussi, activer compat32
       activera également les comparaisons basées sur ASCII. Cette granularité
       peut ne pas être suffisante pour tous les usages, et, de ce fait, les
       utilisateurs devraient employer prudemment les niveaux de compatibilité.
       Lisez la documentation d'une fonctionnalité particulière pour découvrir
       le comportement actuel.

       Bash-4.3 a introduit une nouvelle variable de l'interpréteur :
       BASH_COMPAT. La valeur affectée à cette variable (un numéro de version
       décimal, comme 4.2, ou un nombre entier correspondant à l'option
       compatNN, comme 42) détermine le niveau de compatibilité.

       À partir de bash-4.4, bash a commencé à rendre obsolètes les niveaux de
       compatibilité plus anciens. Les options finiront par être retirées au
       profit de BASH_COMPAT.

       Bash-5.0 est la dernière version pour laquelle il y aura une option de
       shopt particulière pour la version précédente. Les utilisateurs devraient
       utiliser BASH_COMPAT avec bash-5.0 et les versions ultérieures.

       Le tableau suivant décrit les changements de comportement contrôlés par
       chaque configuration de niveau de compatibilité. L'étiquette compatNN est
       un raccourci utilisé pour configurer le niveau de compatibilité à NN en
       utilisant un des mécanismes suivants. Pour les versions antérieures à
       bash-5.0, le niveau de compatibilité peut être fixé avec l'option de
       compatNN de shopt correspondante. Pour bash-4.3 et les versions
       ultérieures, la variable BASH_COMPAT est privilégiée et devient
       obligatoire pour bash-5.1 et les versions ultérieures.

       compat31
              •      La protection de la partie droite de l'opérateur de
                     correspondance (=~) d'une expression rationnelle de la
                     commande [[ n'a aucun effet particulier.

       compat32
              •      L'interruption d'une liste de commandes comme « a ; b ; c »
                     provoque l'exécution de la commande suivante dans la liste
                     (avec bash-4.0 et les versions ultérieures, l'interpréteur
                     se comporte comme s'il recevait l'interruption, aussi
                     l'interruption d'une commande dans une liste termine
                     l'exécution de toute la liste).

       compat40
              •      Les opérateurs < et > de la commande [[ ne tiennent pas
                     compte des paramètres linguistiques régionaux actuels lors
                     des comparaisons de chaînes. Ils utilisent l'ordre ASCII.
                     Les versions de bash antérieures à 4.1 utilisent la
                     collation ASCII et strcmp(3). bash à partir de la
                     version 4.1 utilise la suite de collation des paramètres
                     linguistiques régionaux et strcoll(3).

       compat41
              •      En mode POSIX, time peut être suivi par des options tout en
                     continuant à être reconnu comme un mot réservé (c'est
                     l'interprétation POSIX 267).
              •      En mode POSIX, l'analyseur exige qu'il existe un nombre
                     pair de guillemets simples dans la partie mot d'un
                     développement de paramètres protégé par des guillemets
                     doubles et les traite de façon particulière, ainsi les
                     caractères entre les guillemets simples sont considérés
                     comme protégés (c'est l'interprétation POSIX 221).

       compat42
              •      La chaîne de remplacement dans le motif de substitution
                     entre guillemets doubles n'est pas sujette à la suppression
                     des guillemets, comme dans les versions postérieures à
                     bash-4.2.
              •      En mode POSIX, les guillemets simples sont considérés
                     particuliers lors du développement de la partie mot d'un
                     développement de paramètres protégée par des guillemets
                     doubles et peuvent être utilisés pour protéger une accolade
                     fermante ou un autre caractère spécial (cela fait partie de
                     l'interprétation POSIX 221) ; dans les versions
                     ultérieures, les guillemets simples ne sont pas traités
                     particulièrement dans les développements de mots entre
                     guillemets doubles.

       compat43
              •      L'interpréteur n'affiche pas de message d'avertissement si
                     une tentative est faite d'utiliser une affectation composée
                     protégée comme un argument à déclarer (déclarer -a toto='(1
                     2)'). Les versions ultérieures avertissent que cette
                     utilisation est obsolète.
              •      Les erreurs de développement de mots ne sont pas
                     considérées comme des erreurs fatales qui provoquent
                     l'échec de la commande en cours, même en mode POSIX (le
                     comportement par défaut est de les traiter comme des
                     erreurs fatales, ce qui fait que l'interpréteur termine).
              •      Lors de l'exécution d'une fonction de l'interpréteur,
                     l'état de la boucle (while/until/ etc.) n'est pas
                     réinitialisé, aussi break ou continue dans cette fonction
                     interrompt ou poursuit la boucle dans le contexte de
                     l'appel. Bash-4.4 et les versions ultérieures
                     réinitialisent l'état de la boucle pour éviter cela.

       compat44
              •      L'interpréteur configure les valeurs utilisées par
                     BASH_ARGV et BASH_ARGC de telle manière qu'elles peuvent se
                     développer en paramètres positionnels de l'interpréteur
                     même si le mode de traçage étendu n'est pas activé.
              •      Un sous-interpréteur hérite des boucles du contexte de son
                     parent, aussi break ou continue provoqueront la terminaison
                     du sous-interpréteur. Bash-5.0 et les versions ultérieures
                     réinitialisent l'état de la boucle pour éviter la
                     terminaison.
              •      Les affectations de variables précédant des commandes
                     internes comme export et readonly qui configurent des
                     attributs, continuent à affecter des variables ayant le
                     même nom dans l'environnement d'appel même si
                     l'interpréteur n'est pas en mode POSIX.

       compat50
              •      Bash-5.1 a modifié la manière dont $RANDOM est généré pour
                     introduire un peu plus d'aléa. Si le niveau de
                     compatibilité de l'interpréteur est fixé à 50 ou moins,
                     bash retourne à la méthode de bash-5.0 et des versions
                     antérieures, aussi l'ensemencement du générateur de nombres
                     aléatoires en affectant une valeur à RANDOM produira la
                     même séquence qu'avec bash-5.0.
              •      Si la table de hachage des commandes est vide, les versions
                     de bash antérieures à bash-5.1 affichaient un message
                     d’information à cet effet même quand elles produisaient une
                     sortie qui pouvait être réutilisée en entrée. Bash-5.1
                     supprime ce message quand l'option -l est fournie.

INTERPRÉTEUR RESTREINT
       Si bash démarre sous le nom rbash ou si l'option -r est fournie lors de
       son appel, l'interpréteur devient restreint. Un interpréteur restreint
       permet de créer un environnement plus contrôlé qu'un interpréteur
       standard. Il se comporte de même façon que bash à la différence des
       actions suivantes qui sont interdites ou non effectuées :

       •      changer de répertoire avec cd ;

       •      créer ou détruire les valeurs de SHELL, PATH, HISTFILE, ENV ou
              BASH_ENV ;

       •      indiquer des noms de commandes contenant un / ;

       •      indiquer un nom de fichier contenant un / comme argument de la
              commande interne . ;

       •      indiquer un nom de fichier contenant une barre oblique (/) comme
              argument de la commande interne history ;

       •      indiquer un nom de fichier contenant une barre oblique comme
              argument de l'option -p de la commande interne hash ;

       •      importer une définition de fonction dans l'environnement au
              démarrage ;

       •      analyser les valeurs de SHELLOPTS de l'environnement
              d'interpréteur au démarrage ;

       •      rediriger la sortie en utilisant les opérateurs de redirection >,
              >|, <>, >&, &> et >> ;

       •      utiliser la commande interne exec pour remplacer l'interpréteur
              par une autre commande ;

       •      ajouter ou supprimer des commandes internes avec les options -f et
              -d de la commande interne enable ;

       •      utiliser la commande interne enable pour activer les commandes
              internes de l'interpréteur désactivées ;

       •      indiquer l'option -p à la commande interne commande ;

       •      supprimer le mode restreint avec set +r ou set +o restricted.

       Ces restrictions sont mises en place après la lecture de tous les
       fichiers d’initialisation.

       When a command that is found to be a shell script is executed (see
       COMMAND EXECUTION above), rbash supprime toute restriction dans
       l'interpréteur créé pour exécuter le script.

VOIR AUSSI
       Manuel de référence de Bash, Brian Fox et Chet Ramey
       The GNU Readline Library, Brian Fox et Chet Ramey
       The GNU History Library, Brian Fox et Chet Ramey
       Portable Operating System Interface (POSIX) Part 2: Shell and Utilities,
       IEEE –
              http://pubs.opengroup.org/onlinepubs/9699919799/
       http://tiswww.case.edu/~chet/bash/POSIX – une description du mode POSIX
       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 commun à tout le système, exécuté pour
              les interpréteurs de commandes de connexion
       /etc/bash.bash_logout
              Le fichier de nettoyage des interpréteurs de connexion commun à
              tout le système, exécuté lorsqu'un interpréteur de connexion
              termine
       ~/.bash_profile
              Le fichier d'initialisation personnel exécuté pour les
              interpréteurs de commandes de connexion
       ~/.bashrc
              Le fichier d’initialisation personnel pour les interpréteurs
              interactifs
       ~/.bash_logout
              Le fichier de nettoyage personnel des interpréteurs de commandes
              de connexion, exécuté lorsqu'un interpréteur de commandes de
              connexion termine
       ~/.inputrc
              Le fichier d'initialisation personnel de readline

AUTEURS
       Brian Fox, Free Software Foundation
       bfox@gnu.org

       Chet Ramey, Case Western Reserve University
       chet.ramey@case.edu

SIGNALEMENTS DE BOGUES
       Si vous trouvez une anomalie dans bash, vous devriez la signaler. Tout
       d'abord vous devez vous assurer qu'il s'agit réellement d'une anomalie et
       qu'elle apparaît bien dans la dernière version disponible de bash. La
       dernière version est toujours disponible à partir de
       ftp://ftp.gnu.org/pub/gnu/bash/.

       Une fois que vous avez déterminé qu'une anomalie existe effectivement,
       utilisez la commande bashbug pour envoyer un signalement d'anomalie. Si
       vous avez un correctif, vous êtes encouragé à l'envoyer en même temps !
       Les suggestions ou les signalements d'anomalies de nature
       « philosophique » peuvent être envoyés (en anglais) à bug-bash@gnu.org ou
       postés dans le groupe Usenet gnu.bash.bug.

       TOUS les signalements d'anomalie doivent contenir :

       Le numéro de version de bash
       Le matériel et le système d'exploitation utilisés
       Le compilateur utilisé pour compiler
       Une description (en anglais) de l'anomalie
       Un petit script ou une « recette » qui démontre l'anomalie

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

       Les commentaires et signalement d'anomalies concernant la version
       originale de cette page de manuel (en anglais) doivent être transmis à
       chet.ramey@case.edu. Ceux concernant cette version française peuvent être
       envoyés à debian-l10n-french@lists.debian.org.

BOGUES
       Cet interpréteur de commandes est trop gros et trop 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 commandes internes et les fonctions de l'interpréteur ne peuvent pas
       être suspendues/relancées.

       Les commandes composées et les suites de commandes de la forme
       « a ; b ; c » ne sont pas gérées élégamment lors d'une interruption de
       processus. En cas de suspension d'un processus, l'interpréteur exécute
       immédiatement la commande suivante. Il suffit de placer cette suite de
       commandes entre parenthèses pour la forcer à créer un sous-interpréteur,
       qui, lui, pourra être suspendu en bloc.

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

       Il ne peut exister qu'un seul coprocessus actif à la fois.


TRADUCTION
       La traduction française de cette page de manuel a été créée par
       Christophe Blaess <ccb@club-internet.fr>, Thierry Vignaud
       <tvignaud@mandriva.com>, Amand Tihon <amand@alrj.org>, Alain Portal
       <aportal@univ-montp2.fr>, Frederic Daniel Luc Lehobey
       <Frederic@Lehobey.net>, David Prévot <david@tilapin.org> et Jean-Pierre
       Giraud <jean-pierregiraud@neuf.fr>

       Cette traduction est une documentation libre ; veuillez vous reporter à
       la GNU General Public License version 3 concernant les conditions de
       copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

       Si vous découvrez un bogue dans la traduction de cette page de manuel,
       veuillez envoyer un message à <debian-l10n-french@lists.debian.org>.



GNU Bash 5.1                     29 octobre 2020                         BASH(1)