LIBOF

Manuels pour la ligne de commande

Man » Manuel en ligne de sh - documentation en ligne détaillée pour la page de manuel sh

🌍 ☰ 
dash — interpréteur de commandes (shell)

SYNOPSIS

dash     [-aCefnuvxIimqVEbp]    [+aCefnuvxIimqVEbp]    [-o    option_name]    [+o    option_name]
[command_file [argument ...]]
dash -c [-aCefnuvxIimqVEbp] [+aCefnuvxIimqVEbp] [-o option_name] [+o option_name]  command_string
[command_name [argument ...]]
dash -s [-aCefnuvxIimqVEbp] [+aCefnuvxIimqVEbp] [-o option_name] [+o option_name] [argument ...]

DESCRIPTION

dash  est l'interpréteur de commandes standard du système. La version actuelle de dash est en cours
de modification pour se conformer aux spécifications POSIX 1003.2 et 1003.2a pour le shell. Cette
version possède de nombreuses fonctionnalités qui la rendent similaire à certains égards au shell Korn,
mais il ne s'agit pas d'un clone du shell Korn (voir ksh(1)). Seules les fonctionnalités désignées par
POSIX, ainsi que quelques extensions Berkeley, sont intégrées à ce shell. Cette page de manuel n'est
pas destinée à être un tutoriel ou une spécification complète du shell.

Aperçu

Le shell est une commande qui lit les lignes à partir d'un fichier ou du terminal, les interprète et exécute généralement d'autres commandes. C'est le programme qui s'exécute lorsqu'un utilisateur se connecte au système (bien qu'un utilisateur puisse sélectionner un shell différent avec la commande chsh(1)). Le shell implémente un langage qui possède des constructions de contrôle de flux, une installation de macro qui fournit une variété de fonctionnalités en plus du stockage de données, ainsi que des capacités intégrées d'historique et d'édition de ligne. Il intègre de nombreuses fonctionnalités pour faciliter l'utilisation interactive et présente l'avantage que le langage d'interprétation est commun à la fois à l'utilisation interactive et non interactive (scripts shell). C'est-à-dire que les commandes peuvent être tapées directement dans le shell en cours d'exécution ou peuvent être placées dans un fichier et le fichier peut être exécuté directement par le shell.

Invocation

S'il n'y a pas d'arguments et si l'entrée standard du shell est connectée à un terminal (ou si le flag -i est défini), et si l'option -c n'est pas présente, le shell est considéré comme un shell interactif. Un shell interactif affiche généralement une invite avant chaque commande et gère différemment les erreurs de programmation et de commande (comme décrit ci-dessous). Au démarrage, le shell inspecte l'argument 0, et si celui-ci commence par un tiret ‘-’, le shell est également considéré comme un shell de connexion. Cela se fait normalement automatiquement par le système lorsque l'utilisateur se connecte pour la première fois. Un shell de connexion lit d'abord les commandes des fichiers /etc/profile et .profile s'ils existent. Si la variable d'environnement ENV est définie lors de l'entrée dans un shell interactif, ou si elle est définie dans le fichier .profile d'un shell de connexion, le shell lit ensuite les commandes du fichier dont le nom est indiqué dans ENV. Par conséquent, un utilisateur doit placer les commandes qui doivent être exécutées uniquement au moment de la connexion dans le fichier .profile, et les commandes qui sont exécutées pour chaque shell interactif dans le fichier ENV. Pour définir la variable ENV sur un fichier, placez la ligne suivante dans le fichier .profile de votre répertoire personnel.

ENV=$HOME/.shinit; export ENV

en substituant « .shinit » par le nom de fichier de votre choix.

Si des arguments en ligne de commande autres que les options ont été spécifiés, le shell traite le premier argument comme le nom d’un fichier à partir duquel lire les commandes (un script shell), et les arguments restants sont définis comme les paramètres de position du shell ($1, $2, etc.). Sinon, le shell lit les commandes à partir de son entrée standard.

Traitement de la liste d’arguments

Toutes les options à lettre unique qui ont un nom correspondant peuvent être utilisées comme argument de l’option -o. La commande « set -o nom » est fournie à côté de l’option à lettre unique dans la description ci-dessous. Spécifier un tiret « - » active l’option, tandis que l’utilisation d’un signe plus « + » la désactive. Les options suivantes peuvent être définies à partir de la ligne de commande ou à l’aide de la commande intégrée « set » (décrite ultérieurement).

-a allexport     Exporte toutes les variables affectées.

-c             Lit les commandes à partir de l’opérande command_string au lieu de l’entrée standard. Le paramètre spécial 0 sera défini à partir de l’opérande command_name et les paramètres de position ($1, $2, etc.) seront définis à partir des opérandes restants.

-C noclobber     N’écrase pas les fichiers existants avec « > ».

-e errexit       Si ce n’est pas interactif, quitte immédiatement si une commande non testée échoue. Le statut de sortie d’une commande est considéré comme explicitement testé si la commande est utilisée pour contrôler un if, elif, while ou until ; ou si la commande est l’opérande de gauche d’un opérateur « && » ou « || ».

-f noglob       Désactive l’expansion du chemin.

-n noexec       Si ce n’est pas interactif, lit les commandes mais ne les exécute pas. Ceci est utile pour vérifier la syntaxe des scripts shell.

-u nounset      Écrit un message sur la sortie d’erreur lors de la tentative d’expansion d’une variable qui n’est pas définie, et si le shell n’est pas interactif, quitte immédiatement.

-v verbose      Le shell écrit son entrée sur la sortie d’erreur au fur et à mesure qu’elle est lue. Utile pour le débogage.

-x xtrace       Écrit chaque commande sur la sortie d’erreur (précédée d’un « + ») avant qu’elle ne soit exécutée. Utile pour le débogage.

-I ignoreeof    Ignore les EOF de l’entrée lorsqu’il est interactif.

-i interactive   Force le shell à se comporter de manière interactive.

-l             Fait en sorte que dash agisse comme s’il avait été appelé en tant que shell de connexion.

-m monitor      Active le contrôle des tâches (défini automatiquement lorsqu’il est interactif).

-s stdin       Lit les commandes à partir de l’entrée standard (défini automatiquement s’il n’y a pas d’arguments de fichier). Cette option n’a aucun effet une fois que le shell a déjà commencé à s’exécuter (c’est-à-dire avec la commande « set »).

-V vi            Active le mode d’édition en ligne de commande vi(1) intégré (désactive -E s’il a été défini).

-E emacs         Active le mode d’édition en ligne de commande [emacs](filenameemacs.md)(1) intégré (désactive -V s’il a été défini).

-b notify        Active la notification asynchrone de la fin des tâches en arrière-plan. (NON IMPLÉMENTÉ pour 4.4alpha)

-p priviliged    N’essaie pas de réinitialiser l’UID effectif s’il ne correspond pas à l’UID. Par défaut, cette option n’est pas définie afin d’éviter une utilisation incorrecte par les programmes setuid root via system(3) ou popen(3).

Structure lexicale

Le shell lit les entrées ligne par ligne à partir d’un fichier et les divise en mots en utilisant les espaces (espaces et tabulations), ainsi que certaines séquences de caractères qui sont spéciales pour le shell, appelées « opérateurs ». Il existe deux types d’opérateurs : les opérateurs de contrôle et les opérateurs de redirection (leur signification est expliquée plus loin). Voici une liste des opérateurs :

Opérateurs de contrôle : & && ( ) ; ;; | ||

Opérateurs de redirection : < > >| << >> <& >& <<- <>

Guillemets

Les guillemets sont utilisés pour supprimer la signification spéciale de certains caractères ou mots pour le shell, tels que les opérateurs, les espaces ou les mots-clés. Il existe trois types de guillemets : les guillemets simples, les guillemets doubles et la barre oblique inverse.

Barre oblique inverse

Une barre oblique inverse conserve la signification littérale du caractère qui la suit, à l’exception de ⟨newline⟩. Une barre oblique inverse précédant une ⟨newline⟩ est traitée comme une continuation de ligne.

Guillemets simples

L’inclusion de caractères entre guillemets simples conserve la signification littérale de tous les caractères (à l’exception des guillemets simples, ce qui rend impossible l’inclusion de guillemets simples dans une chaîne entre guillemets simples).

Guillemets doubles

L’inclusion de caractères entre guillemets doubles conserve la signification littérale de tous les caractères, à l’exception du signe dollar ($), de la apostrophe inversée (`) et de la barre oblique inverse (\). La barre oblique inverse à l’intérieur des guillemets doubles est historiquement particulière et ne sert qu’à échapper les caractères suivants : $ " \ . Sinon, elle reste littérale.

Mots réservés

Les mots réservés sont des mots qui ont une signification spéciale pour le shell et qui sont reconnus au début d’une ligne et après un opérateur de contrôle. Les suivants sont des mots réservés :

!       elif    fi      while   case
else    for     then    {       }
do      done    until   if      esac

Leur signification est expliquée plus loin.

Alias

Un alias est un nom et une valeur correspondante définis à l’aide de la commande intégrée alias(1). Chaque fois qu’un mot réservé peut apparaître (voir ci-dessus), et après avoir vérifié la présence de mots réservés, le shell vérifie si le mot correspond à un alias. Si c’est le cas, il le remplace dans le flux d’entrée par sa valeur. Par exemple, s’il existe un alias nommé « lf » avec la valeur « ls -F », l’entrée suivante :

lf foobar ⟨return⟩

deviendrait :

ls -F foobar ⟨return⟩

Les alias offrent un moyen pratique aux utilisateurs novices de créer des raccourcis pour les commandes sans avoir à apprendre à créer des fonctions avec des arguments. Ils peuvent également être utilisés pour créer un code lexicalement obscur. Cette utilisation est déconseillée.

Commandes

L’interpréteur de commandes interprète les mots qu’il lit selon un langage, dont la spécification est hors du champ d’application de cette page de manuel (voir la BNF dans le document POSIX 1003.2). Essentiellement, une ligne est lue et si le premier mot de la ligne (ou après un opérateur de contrôle) n’est pas un mot réservé, alors l’interpréteur a reconnu une commande simple. Sinon, une commande complexe ou une autre construction spéciale a été reconnue.

Commandes simples

Si une commande simple a été reconnue, l’interpréteur effectue les actions suivantes :

     Les premiers mots de la forme « nom=valeur » sont supprimés et affectés à l’environnement de la commande simple. Les opérateurs de redirection et leurs arguments (comme décrit
ci-dessous) sont supprimés et conservés pour un traitement ultérieur.

     Les mots restants sont développés comme décrit dans la section intitulée « Développements », et
le premier mot restant est considéré comme le nom de la commande, et la commande est localisée.
Les mots restants sont considérés comme les arguments de la commande. Si aucun nom de commande
n’a été trouvé, alors les affectations de variables « nom=valeur » reconnues dans l’élément 1 affectent
l’interpréteur de commandes actuel.

     Les redirections sont effectuées comme décrit dans la section suivante.

Redirections

Les redirections sont utilisées pour modifier l’endroit où une commande lit ses entrées ou envoie ses sorties. En général, les redirections ouvrent, ferment ou dupliquent une référence existante à un fichier. Le format général utilisé pour la redirection est le suivant :

[n] redir-op fichier

où redir-op est l’un des opérateurs de redirection mentionnés précédemment. Voici une liste des
redirections possibles. Le [n] est un nombre facultatif compris entre 0 et 9, comme dans « 3 » (et non « [3] »),
qui fait référence à un descripteur de fichier.

[n]> fichier Redirige la sortie standard (ou n) vers le fichier.

[n]>| fichier Idem, mais annule l’option -C.

[n]>> fichier Ajoute la sortie standard (ou n) au fichier.

[n]< fichier Redirige l’entrée standard (ou n) à partir du fichier.

[n1]<&n2 Copie le descripteur de fichier n2 comme sortie standard (ou descripteur de fichier n1). Descripteur de fichier n2.

[n]<&- Ferme l’entrée standard (ou n).

[n1]>&n2 Copie le descripteur de fichier n2 comme entrée standard (ou descripteur de fichier n1). Descripteur de fichier n2.

[n]>&- Ferme la sortie standard (ou n).

[n]<> fichier Ouvre le fichier en lecture et en écriture sur l’entrée standard (ou n).

La redirection suivante est souvent appelée « document en ligne ».

[n]<< délimiteur
texte-du-document-en-ligne ...
délimiteur

Tout le texte des lignes suivantes jusqu’au délimiteur est enregistré et mis à la disposition de la commande sur l’entrée standard, ou sur le descripteur de fichier n, s’il est spécifié. Si le délimiteur spécifié sur la première ligne est entre guillemets, alors le texte-du-document-en-ligne est traité littéralement ; sinon, le texte est soumis à l’expansion des paramètres, à la substitution de commandes et à l’expansion arithmétique (comme décrit dans la section sur les « Développements »). Si l’opérateur est « <<- » au lieu de « << », alors les tabulations au début du texte-du-document-en-ligne sont supprimées.

Recherche et exécution

Il existe trois types de commandes : les fonctions shell, les commandes intégrées et les programmes normaux. La commande est recherchée (par son nom) dans cet ordre. Elles sont chacune exécutées d’une manière différente.

Lorsqu’une fonction shell est exécutée, tous les paramètres de position du shell (à l’exception de $0, qui reste inchangé) sont définis sur les arguments de la fonction shell. Les variables qui sont explicitement placées dans l’environnement de la commande (en plaçant des affectations à ces variables avant le nom de la fonction) sont rendues locales à la fonction et sont définies sur les valeurs données. Ensuite, la commande donnée dans la définition de la fonction est exécutée. Les paramètres de position sont restaurés à leurs valeurs d’origine lorsque la commande est terminée. Tout cela se produit dans le shell actuel.

Les commandes intégrées sont exécutées en interne au shell, sans générer de nouveau processus.

Sinon, si le nom de la commande ne correspond pas à une fonction ou à une commande intégrée, la commande est recherchée en tant que programme normal dans le système de fichiers (comme décrit dans la section suivante). Lorsqu’un programme normal est exécuté, le shell exécute le programme, en lui transmettant les arguments et l’environnement. Si le programme n’est pas un fichier exécutable normal (c’est-à-dire s’il ne commence pas par le « nombre magique » dont la représentation ASCII est « #! », de sorte que execve(2) renvoie ENOEXEC), le shell interprète le programme dans un sous-shell. Le sous-shell se réinitialise dans ce cas, de sorte que l’effet est comme si un nouveau shell avait été invoqué pour gérer le script shell ad hoc, à l’exception de la localisation des commandes hachées situées dans le shell parent, qui sont mémorisées par le sous-shell.

Notez que les versions précédentes de ce document et le code source lui-même font référence de manière trompeuse et sporadique à un script shell sans nombre magique comme un « procédure shell ».

Recherche de chemin

Lors de la localisation d’une commande, le shell vérifie d’abord s’il existe une fonction shell portant ce nom. Ensuite, il recherche une commande intégrée portant ce nom. Si une commande intégrée n’est pas trouvée, l’une des deux choses suivantes se produit :

Les noms de commandes contenant une barre oblique sont simplement exécutés sans effectuer de recherche.

Le shell recherche chaque entrée dans la variable PATH à tour de rôle pour la commande. La valeur de la variable PATH doit être une série d’entrées séparées par des deux-points. Chaque entrée consiste en un nom de répertoire. Le répertoire courant peut être indiqué implicitement par un répertoire vide, ou explicitement par un seul point.

Statut de sortie de la commande

Chaque commande a un statut de sortie qui peut influencer le comportement des autres commandes shell. Le principe est qu’une commande se termine avec zéro pour indiquer un fonctionnement normal ou un succès, et non zéro pour indiquer un échec, une erreur ou une indication fausse. La page de manuel de chaque commande doit indiquer les différents codes de sortie et leur signification. De plus, les commandes intégrées renvoient des codes de sortie, tout comme une fonction shell exécutée.

Si une commande ne consiste qu’en des affectations de variables, son statut de sortie est celui de la dernière substitution de commande, le cas échéant, sinon 0.

Commandes complexes

Les commandes complexes sont des combinaisons de commandes simples avec des opérateurs de contrôle ou des mots réservés, qui créent ensemble une commande complexe plus importante. Plus généralement, une commande est l’une des suivantes :

commande simple

pipeline

liste ou liste de commandes

commande composée

définition de fonction

Sauf indication contraire, le statut de sortie d’une commande est celui de la dernière commande simple exécutée par la commande.

Pipelines

Un pipeline est une séquence d’une ou plusieurs commandes séparées par l’opérateur de contrôle |. La sortie standard de toutes les commandes, sauf la dernière, est connectée à l’entrée standard de la commande suivante. La sortie standard de la dernière commande est héritée du shell, comme d’habitude.

Le format d’un pipeline est :

[!] commande1 [| commande2 ...]

La sortie standard de commande1 est connectée à l’entrée standard de commande2. L’entrée standard, la sortie standard ou les deux d’une commande sont considérées comme étant affectées par le pipeline avant toute redirection spécifiée par les opérateurs de redirection qui font partie de la commande.

Si le pipeline n’est pas exécuté en arrière-plan (voir ci-dessous), le shell attend que toutes les commandes soient terminées.

Si l’option pipefail était activée lorsque le shell a commencé l’exécution du pipeline, le statut de sortie du pipeline est le statut de sortie de la dernière commande spécifiée dans le pipeline qui a renvoyé un statut différent de zéro, ou zéro si toutes les commandes du pipeline ont renvoyé un statut de zéro. Si l’option pipefail n’était pas activée, le statut de sortie du pipeline est le statut de sortie de la dernière commande spécifiée dans le pipeline ; les statuts de sortie de toute autre commande ne sont pas utilisés. Si le mot réservé ! précède le pipeline, son statut de sortie est la négation logique du statut de sortie décrit ci-dessus.

Étant donné que l’affectation de l’entrée standard ou de la sortie standard, ou des deux, par le pipeline a lieu avant la redirection, elle peut être modifiée par la redirection. Par exemple :

$ commande1 2>&1 | commande2

envoie à la fois la sortie standard et la sortie d’erreur de commande1 à l’entrée standard de commande2.

Un terminateur ; ou ⟨newline⟩ fait exécuter séquentiellement la liste AND-OR précédente (décrite ci-dessous) ; un & fait exécuter la liste AND-OR précédente de manière asynchrone.

Notez que, contrairement à certains autres shells, chaque processus du pipeline est un enfant du shell appelant (à moins qu’il ne s’agisse d’une commande intégrée du shell, auquel cas il s’exécute dans le shell actuel, mais tout effet qu’il a sur l’environnement est annulé).

Commandes en arrière-plan – &

Si une commande est terminée par l’opérateur de contrôle ampersand (&), le shell exécute la commande de manière asynchrone, c’est-à-dire que le shell n’attend pas que la commande se termine avant d’exécuter la commande suivante.

Le format pour exécuter une commande en arrière-plan est :

commande1 & [commande2 & ...]

Si le shell n’est pas interactif, l’entrée standard d’une commande asynchrone est définie sur /dev/null.

Listes – En général

Une liste est une séquence de zéro ou plusieurs commandes séparées par des sauts de ligne, des points-virgules ou des esperluettes, et terminée éventuellement par l’un de ces trois caractères. Les commandes d’une liste sont exécutées dans l’ordre dans lequel elles sont écrites. Si une commande est suivie d’une esperluette, le shell démarre la commande et passe immédiatement à la commande suivante ; sinon, il attend que la commande se termine avant de passer à la commande suivante.

Opérateurs de liste à court-circuit

« && » et « || » sont des opérateurs de liste « ET-OU ». « && » exécute la première commande, puis exécute la deuxième commande uniquement si le code de sortie de la première commande est égal à zéro. « || » est similaire, mais exécute la deuxième commande uniquement si le code de sortie de la première commande est différent de zéro. « && » et « || » ont la même priorité.

Structures de contrôle de flux – if, while, for, case

La syntaxe de la commande if est la suivante :

if liste
then liste
[ elif liste
then liste ] ...
[ else liste ]
fi

La syntaxe de la commande while est la suivante :

while liste
do liste
done

Les deux listes sont exécutées de manière répétée tant que le code de sortie de la première liste est égal à zéro. La commande until est similaire, mais le mot until remplace while, ce qui la fait répéter jusqu’à ce que le code de sortie de la première liste soit égal à zéro.

La syntaxe de la commande for est la suivante :

for variable [ in [ mot ... ] ]
do liste
done

Les mots qui suivent in sont développés, puis la liste est exécutée de manière répétée avec la variable définie sur chaque mot à tour de rôle. Omettre in mot ... équivaut à in "$@".

La syntaxe des commandes break et continue est la suivante :

break [ nombre ]
continue [ nombre ]

Break termine les nombre boucles for ou while les plus internes. Continue passe à l’itération suivante de la boucle la plus interne. Ces commandes sont implémentées en tant que commandes intégrées.

La syntaxe de la commande case est la suivante :

case mot in
[(]motif) liste ;;
...
esac

Le motif peut en fait être un ou plusieurs motifs (voir « Motifs du shell » décrits plus loin), séparés par des caractères « | ». Le caractère « ( » avant le motif est facultatif.

Regroupement des commandes

Les commandes peuvent être regroupées en écrivant soit

(liste)

soit

{ liste ; }

La première de ces commandes exécute les commandes dans un sous-shell. Les commandes intégrées regroupées dans une (liste) n’affecteront pas le shell actuel. La deuxième forme ne crée pas un autre shell, elle est donc légèrement plus efficace. Le regroupement des commandes de cette manière permet de rediriger leur sortie comme s’il s’agissait d’un seul programme :

{ printf " hello " ; printf " world\n" ; } > greeting

Notez que « } » doit suivre un opérateur de contrôle (ici, « ; ») afin qu’il soit reconnu comme un mot réservé et non comme un autre argument de commande.

Fonctions

La syntaxe d’une définition de fonction est la suivante :

nom () commande

Une définition de fonction est une instruction exécutable ; lorsqu’elle est exécutée, elle installe une fonction nommée nom et renvoie un code de sortie égal à zéro. La commande est normalement une liste entre accolades « { » et « } ».

Les variables peuvent être déclarées comme locales à une fonction en utilisant la commande local. Celle-ci doit apparaître comme la première instruction d'une fonction, et la syntaxe est :

local [variable | -] ...

^ ocal est implémenté en tant que commande intégrée.

Lorsqu'une variable est rendue locale, elle hérite de la valeur initiale et des drapeaux d'exportation et de lecture seule de la variable portant le même nom dans la portée environnante, s'il en existe une. Sinon, la variable est initialement non définie. Le shell utilise une portée dynamique, de sorte que si vous rendez la variable x locale à la fonction f, qui appelle ensuite la fonction g, les références à la variable x faites à l'intérieur de g feront référence à la variable x déclarée dans f, et non à la variable globale portant le nom x.

La seule variable spéciale qui peut être rendue locale est « - ». Rendre « - » local permet à toutes les options du shell qui sont modifiées via la commande set à l'intérieur de la fonction d'être restaurées à leurs valeurs d'origine lorsque la fonction se termine.

La syntaxe de la commande return est :

return [code_de_sortie]

Elle termine l'exécution de la fonction en cours. Return est implémenté en tant que commande intégrée.

Variables et paramètres

Le shell maintient un ensemble de paramètres. Un paramètre désigné par un nom est appelé une variable. Au démarrage, le shell transforme toutes les variables d'environnement en variables de shell. De nouvelles variables peuvent être définies en utilisant la forme :

nom=valeur

Les variables définies par l'utilisateur doivent avoir un nom composé uniquement de lettres, de chiffres et de traits de soulignement, dont le premier ne doit pas être un chiffre. Un paramètre peut également être désigné par un nombre ou un caractère spécial, comme expliqué ci-dessous.

Paramètres positionnels

Un paramètre positionnel est un paramètre désigné par un nombre (n > 0). Le shell les définit initialement aux valeurs des arguments de ligne de commande qui suivent le nom du script shell. La commande intégrée set peut également être utilisée pour les définir ou les réinitialiser.

Paramètres spéciaux

Un paramètre spécial est un paramètre désigné par l'un des caractères spéciaux suivants. La valeur du paramètre est indiquée à côté de son caractère.

*            Se développe en les paramètres positionnels, en commençant par un. Lorsque le développement se produit à l'intérieur d'une chaîne entre guillemets, il se développe en un seul champ avec la valeur de chaque paramètre séparée par le premier caractère de la variable `IFS`, ou par un espace si `IFS` n'est pas défini.

@            Se développe en les paramètres positionnels, en commençant par un. Lorsque le développement se produit entre guillemets, chaque paramètre positionnel se développe en tant qu'argument distinct. S'il n'y a pas de paramètres positionnels, le développement de `@` génère zéro argument, même si `@` est entre guillemets. Ce que cela signifie essentiellement, par exemple, c'est que si `$1` est « abc » et `$2` est « def ghi », alors `"$@"` se développe en les deux arguments suivants :

"abc" "def ghi"

#            Se développe en le nombre de paramètres positionnels.

?            Se développe en l’état de sortie du pipeline le plus récent.

- (Tiret.) Se développe en les indicateurs d’options actuels (les noms d’options à une seule lettre concaténés
en une chaîne) tels que spécifiés lors de l’invocation, par la commande intégrée set, ou implicitement
par le shell.

$            Se développe en l’ID de processus du shell invoqué. Un sous-shell conserve la même valeur
de $ que son parent.

!            Se développe en l’ID de processus de la commande de fond la plus récente exécutée à partir
du shell actuel. Pour un pipeline, l’ID de processus est celui de la dernière commande du
pipeline.

0(Zéro.)    Se développe en le nom du shell ou du script shell.

Développements de mots

Cette clause décrit les différents développements qui sont effectués sur les mots. Tous les développements ne sont pas effectués sur chaque mot, comme expliqué plus loin.

Les développements de tilde, les développements de paramètres, les substitutions de commandes, les développements arithmétiques et les suppressions de guillemets qui se produisent dans un seul mot se développent en un seul champ. Seul le fractionnement de champs ou le développement de chemins d’accès peut créer plusieurs champs à partir d’un seul mot. La seule exception à cette règle est le développement du paramètre spécial @ entre guillemets doubles, comme décrit ci-dessus.

L’ordre du développement des mots est le suivant :

      Développement de tilde, Développement de paramètres, Substitution de commandes, Développement arithmétique (ils se produisent tous en même temps).

      Le fractionnement de champs est effectué sur les champs générés à l’étape (1), sauf si la variable IFS est
nulle.

      Développement de chemins d’accès (sauf si set -f est en vigueur).

      Suppression de guillemets.

Le caractère $ est utilisé pour introduire le développement de paramètres, la substitution de commandes ou l’évaluation arithmétique.

Développement de tilde (substitution du répertoire personnel d’un utilisateur)

Un mot commençant par un caractère tilde (~) non entre guillemets est soumis au développement de tilde. Tous les caractères jusqu’à une barre oblique (/) ou la fin du mot sont traités comme un nom d’utilisateur et sont remplacés par le répertoire personnel de l’utilisateur. Si le nom d’utilisateur est manquant (comme dans ~/foobar), le tilde est remplacé par la valeur de la variable HOME (le répertoire personnel de l’utilisateur actuel).

Développement de paramètres

Le format du développement de paramètres est le suivant :

${expression}

où expression est constituée de tous les caractères jusqu’à la « } » correspondante. Toute « } » échappée par une barre oblique inversée ou dans une chaîne entre guillemets, et les caractères dans les développements arithmétiques, les substitutions de commandes et les développements de variables intégrés, ne sont pas examinés pour déterminer la « } » correspondante.

La forme la plus simple du développement de paramètres est la suivante :

${paramètre}

La valeur, le cas échéant, du paramètre est substituée.

Le nom ou le symbole du paramètre peut être entouré d’accolades, ce qui est facultatif, sauf pour les paramètres de position ayant plus d’un chiffre ou lorsque le paramètre est suivi d’un caractère qui pourrait être interprété comme faisant partie du nom. Si un développement de paramètres se produit à l’intérieur de guillemets doubles :

      Le développement de chemins d’accès n’est pas effectué sur les résultats du développement.

La division de chaîne n'est pas effectuée sur les résultats de l'expansion, à l'exception de @.

De plus, une expansion de paramètre peut être modifiée en utilisant l'un des formats suivants.

${parameter:-word}  Utiliser des valeurs par défaut. Si le paramètre n'est pas défini ou est nul, l'expansion de word est substituée ; sinon, la valeur du paramètre est substituée.

${parameter:=word}  Attribuer des valeurs par défaut. Si le paramètre n'est pas défini ou est nul, l'expansion de word est affectée au paramètre. Dans tous les cas, la valeur finale du paramètre est substituée. Seules les variables, et non les paramètres positionnels ou spéciaux, peuvent être affectées de cette manière.

${parameter:?[word]}  Indiquer une erreur si nul ou non défini. Si le paramètre n'est pas défini ou est nul, l'expansion de word (ou un message indiquant qu'il n'est pas défini si word est omis) est écrite sur la sortie standard d'erreur et le shell se termine avec un code de sortie différent de zéro. Sinon, la valeur du paramètre est substituée. Un shell interactif n'est pas tenu de se terminer.

${parameter:+word}  Utiliser une valeur alternative. Si le paramètre n'est pas défini ou est nul, la valeur nulle est substituée ; sinon, l'expansion de word est substituée.

Dans les expansions de paramètres présentées précédemment, l'utilisation du deux-points dans le format entraîne un test pour un paramètre qui n'est pas défini ou est nul ; l'omission du deux-points entraîne un test pour un paramètre qui n'est défini.

${#parameter}  Longueur de la chaîne. La longueur, en caractères, de la valeur du paramètre.

Les quatre variétés d'expansion de paramètres suivantes permettent le traitement des sous-chaînes. Dans chaque cas, la notation de correspondance de motifs (voir « Motifs du shell »), et non la notation d'expression régulière, est utilisée pour évaluer les motifs. Si le paramètre est * ou @, le résultat de l'expansion n'est pas spécifié. Envelopper la chaîne complète de l'expansion de paramètre entre guillemets doubles n'entraîne pas le fait que les quatre caractères de motif suivants soient mis entre guillemets, tandis que la mise entre guillemets des caractères à l'intérieur des accolades a cet effet.

${parameter%word}  Supprimer le plus petit suffixe de motif. Le mot est étendu pour produire un motif. L'expansion du paramètre donne alors le paramètre, avec la plus petite partie du suffixe correspondant au motif supprimée.

${parameter%%word}  Supprimer le plus grand suffixe de motif. Le mot est étendu pour produire un motif. L'expansion du paramètre donne alors le paramètre, avec la plus grande partie du suffixe correspondant au motif supprimée.

${parameter#word}  Supprimer le plus petit préfixe de motif. Le mot est étendu pour produire un motif. L'expansion du paramètre donne alors le paramètre, avec la plus petite partie du préfixe correspondant au motif supprimée.

${parameter##word}  Supprimer le plus grand préfixe de motif. Le mot est étendu pour produire un motif. L'expansion du paramètre donne alors le paramètre, avec la plus grande partie du préfixe correspondant au motif supprimée.

Substitution de commande

La substitution de commande permet de substituer la sortie d'une commande à la place du nom de la commande elle-même. La substitution de commande se produit lorsque la commande est incluse comme suit :

$(commande)

ou (version entre guillemets inversés) :

\`commande\`

Le shell effectue une substitution de commande en exécutant la commande dans un sous-environnement et en remplaçant la substitution de commande par la sortie standard de la commande, en supprimant les séquences d’une ou plusieurs fins de ligne à la fin de la substitution. (Les fins de ligne intégrées avant la fin de la sortie ne sont pas supprimées ; cependant, lors de la division des champs, elles peuvent être traduites en espaces, en fonction de la valeur de IFS et des guillemets utilisés.)

Expansion arithmétique

L’expansion arithmétique fournit un mécanisme pour évaluer une expression arithmétique et substituer sa valeur. Le format de l’expansion arithmétique est le suivant :

$((expression))

L’expression est traitée comme si elle était entre guillemets doubles, à l’exception d’une paire de guillemets doubles à l’intérieur de l’expression, qui n’est pas traitée de manière spéciale. Le shell effectue l’expansion de tous les jetons dans l’expression pour l’expansion des paramètres, la substitution de commande et la suppression des guillemets.

Ensuite, le shell traite cela comme une expression arithmétique et substitue la valeur de l’expression.

Division des espaces (division des champs)

Après l’expansion des paramètres, la substitution de commande et l’expansion arithmétique, le shell analyse les résultats des expansions et substitutions qui n’ont pas eu lieu entre guillemets doubles, afin de procéder à la division des champs, ce qui peut entraîner plusieurs champs.

Le shell traite chaque caractère de IFS comme un délimiteur et utilise ces délimiteurs pour diviser les résultats de l’expansion des paramètres et de la substitution de commande en champs.

Expansion du chemin (génération des noms de fichiers)

Sauf si l’indicateur -f est défini, la génération des noms de fichiers est effectuée après que la division des mots est terminée. Chaque mot est considéré comme une série de modèles, séparés par des barres obliques. Le processus d’expansion remplace le mot par les noms de tous les fichiers existants dont les noms peuvent être formés en remplaçant chaque modèle par une chaîne qui correspond au modèle spécifié. Il existe deux restrictions à cela : premièrement, un modèle ne peut pas correspondre à une chaîne contenant une barre oblique, et deuxièmement, un modèle ne peut pas correspondre à une chaîne commençant par un point, à moins que le premier caractère du modèle soit un point. La section suivante décrit les modèles utilisés pour l’expansion du chemin et la commande case.

Modèles de shell

Un modèle se compose de caractères normaux, qui correspondent à eux-mêmes, et de méta-caractères. Les méta-caractères sont « ! », « * », « ? » et « [ ». Ces caractères perdent leur signification spéciale s’ils sont entre guillemets. Lorsqu’une substitution de commande ou de variable est effectuée et que le signe dollar ou les guillemets inversés ne sont pas entre guillemets doubles, la valeur de la variable ou la sortie de la commande est analysée pour rechercher ces caractères, et ils sont transformés en méta-caractères.

Un astérisque (« * ») correspond à n’importe quelle chaîne de caractères. Un point d’interrogation correspond à n’importe quel caractère unique. Un crochet gauche (« [ ») introduit une classe de caractères. La fin de la classe de caractères est indiquée par un « ] »; si le « ] » est manquant, le « [ » correspond à un « [ » plutôt qu’à l’introduction d’une classe de caractères. Une classe de caractères correspond à l’un des caractères entre les crochets. Une plage de caractères peut être spécifiée à l’aide d’un tiret. La classe de caractères peut être complétée en faisant d’un point d’exclamation le premier caractère de la classe de caractères.

Pour inclure un caractère « ] » dans une classe de caractères, placez-le en premier (après le caractère « ! », le cas échéant). Pour inclure un signe moins, placez-le en premier ou en dernier dans la liste.

Commandes intégrées

Cette section répertorie les commandes intégrées qui le sont parce qu’elles doivent effectuer une opération qui ne peut pas être effectuée par un processus séparé. En plus de celles-ci, il existe plusieurs autres commandes qui peuvent être intégrées pour des raisons d’efficacité (par exemple, printf(1), echo(1), test(1), etc.).

:

true  Une commande nulle qui renvoie une valeur de sortie de 0 (vrai).

false Une commande nulle qui renvoie une valeur de sortie de 1 (faux).

. file Les commandes du fichier spécifié sont lues et exécutées par le shell.

alias [nom[=chaîne...]] Si nom=chaîne est spécifié, le shell définit l’alias nom avec la valeur chaîne. Si seul nom est spécifié, la valeur de l’alias nom est affichée. Sans arguments, la commande intégrée alias affiche les noms et les valeurs de tous les alias définis (voir unalias).

bg [travail] ... Continue les travaux spécifiés (ou le travail actuel si aucun travail n’est spécifié) en arrière-plan.

command [-p] [-v] [-V] commande [arg ...] Exécute la commande spécifiée, mais ignore les fonctions du shell lors de sa recherche. (Ceci est utile lorsque vous avez une fonction de shell portant le même nom qu’une commande intégrée.)

-p  recherche la commande en utilisant un PATH qui garantit de trouver tous les utilitaires standard.

-V  N’exécute pas la commande, mais recherche la commande et affiche la résolution de la recherche de commande. C’est la même chose que la commande intégrée type.

-v  N’exécute pas la commande, mais recherche la commande et affiche le chemin d’accès absolu des utilitaires, le nom des commandes intégrées ou le développement des alias.

cd|chdir cd|chdir [-LP] [répertoire] Passe au répertoire spécifié (par défaut, HOME). Si une entrée pour CDPATH apparaît dans l’environnement de la commande cd ou si la variable de shell CDPATH est définie et que le nom du répertoire ne commence pas par une barre oblique, les répertoires répertoriés dans CDPATH seront recherchés pour le répertoire spécifié. Le format de CDPATH est le même que celui de PATH. Si une seule barre oblique est spécifiée comme argument, elle sera remplacée par la valeur de OLDPWD. La commande cd affichera le nom du répertoire vers lequel elle a réellement basculé si celui-ci est différent du nom donné par l’utilisateur. Ils peuvent être différents, soit parce que le mécanisme CDPATH a été utilisé, soit parce que l’argument est une seule barre oblique. L’option -P fait que la structure de répertoire physique est utilisée, c’est-à-dire que tous les liens symboliques sont résolus à leurs valeurs respectives. L’option -L désactive l’effet de toute option -P précédente.

echo [-n] args...

Affiche les arguments sur la sortie standard, séparés par des espaces. Sauf si l'option -n est présente, une nouvelle ligne est affichée après les arguments.

Si l'une des séquences de caractères suivantes est rencontrée pendant la sortie, la séquence n'est pas affichée. Au lieu de cela, l'action spécifiée est effectuée :

\b    Un caractère de retour arrière est affiché.

\c    La sortie suivante est supprimée. Ceci est généralement utilisé à la fin du dernier argument pour supprimer la nouvelle ligne que echo afficherait normalement.

\e    Affiche un caractère d'échappement (ESC).

\f    Affiche un saut de page.

\n    Affiche un caractère de nouvelle ligne.

\r    Affiche un retour chariot.

\t    Affiche une tabulation (horizontale).

\v    Affiche une tabulation verticale.

\0digits

Affiche le caractère dont la valeur est donnée par zéro à trois chiffres octaux. S'il n'y a aucun chiffre, un caractère nul est affiché.

\\    Affiche une barre oblique inversée.

Toutes les autres séquences de caractères précédées d'une barre oblique inversée produisent un comportement indéfini.

eval string ...

Concatène tous les arguments avec des espaces. Ensuite, réanalyse et exécute la commande.

exec [commande arg ...]

Sauf si la commande est omise, le processus shell est remplacé par le programme spécifié (qui doit être un programme réel, et non une fonction ou une commande interne du shell). Toutes les redirections de la commande exec sont marquées comme permanentes, de sorte qu'elles ne sont pas annulées lorsque la commande exec se termine.

exit [exitstatus]

Termine le processus shell. Si exitstatus est donné, il est utilisé comme statut de sortie du shell ; sinon, le statut de sortie de la commande précédente est utilisé.

export name ...

export -p

Les noms spécifiés sont exportés afin qu'ils apparaissent dans l'environnement des commandes suivantes. La seule façon de supprimer une variable de l'exportation est de la supprimer. Le shell permet de définir la valeur d'une variable en même temps que son exportation en écrivant :

export name=value

Sans arguments, la commande export répertorie les noms de toutes les variables exportées. Avec l'option -p spécifiée, la sortie sera formatée de manière appropriée pour une utilisation non interactive.

fc [-e éditeur] [premier [dernier]]

fc -l [-nr] [premier [dernier]]

fc -s [ancien=nouveau] [premier]

La commande interne fc répertorie ou modifie et réexécute les commandes entrées précédemment dans un shell interactif.

-e éditeur

Utilise l'éditeur nommé par éditeur pour modifier les commandes. La chaîne de l'éditeur est un nom de commande, soumis à une recherche via la variable PATH. La valeur de la variable FCEDIT est utilisée par défaut lorsque -e n'est pas spécifié. Si FCEDIT est nulle ou non définie, la valeur de la variable EDITOR est utilisée. Si EDITOR est nulle ou non définie, ed(1) est utilisé comme éditeur.

-l (ell)

Répertorie les commandes au lieu d'invoquer un éditeur. Les commandes sont écrites dans la séquence indiquée par les opérandes premier et dernier, comme affecté par -r, chaque commande étant précédée du numéro de commande.

-n     Supprimer les numéros de commande lors de l’affichage avec -l.

-r     Inverser l’ordre des commandes affichées (avec -l) ou modifiées (sans -l ni -s).

-s     Réexécuter la commande sans invoquer un éditeur.

first

last   Sélectionner les commandes à afficher ou à modifier. Le nombre de commandes précédentes auxquelles on peut accéder est déterminé par la valeur de la variable HISTSIZE. La valeur de first ou last, ou des deux, est l’une des suivantes :

[+]number
Un nombre positif représentant un numéro de commande ; les numéros de commande peuvent être affichés avec l’option -l.

-number
Un nombre décimal négatif représentant la commande qui a été exécutée il y a number de commandes. Par exemple, -1 est la commande immédiatement précédente.

string
Une chaîne indiquant la commande la plus récemment entrée qui commence par cette chaîne. Si l’opérande old=new n’est pas également spécifié avec -s, la forme chaîne du premier opérande ne peut pas contenir un signe égal.

Les variables d’environnement suivantes affectent l’exécution de fc :

FCEDIT    Nom de l’éditeur à utiliser.

HISTSIZE  Le nombre de commandes précédentes auxquelles on peut accéder.

fg [job]

Déplacer le travail spécifié ou le travail actuel vers l’avant-plan.

getopts optstring var [arg ...]

La commande POSIX getopts, à ne pas confondre avec l’utilitaire getop(1) dérivé de Bell Labs.

Le premier argument doit être une série de lettres, dont chacune peut être suivie facultativement d’un deux-points pour indiquer que l’option nécessite un argument. La variable spécifiée est définie avec l’option analysée.

La commande getopts déprécie l’ancien utilitaire getop(1) en raison de sa gestion des arguments contenant des espaces.

La commande intégrée getopts peut être utilisée pour obtenir les options et leurs arguments à partir d’une liste de paramètres. Lorsqu’elle est appelée, getopts place la valeur de l’option suivante de la chaîne d’options dans la liste dans la variable de shell spécifiée par var et son index dans la variable de shell OPTIND. Lorsque le shell est appelé, OPTIND est initialisé à 1. Pour chaque option qui nécessite un argument, la commande intégrée getopts la place dans la variable de shell OPTARG. Si une option n’est pas autorisée dans la chaîne d’options, la variable OPTARG est effacée.

Par défaut, les variables $1, ..., $n sont inspectées ; si des arguments sont spécifiés, ils seront analysés à la place.

optstring est une chaîne de lettres d’options reconnues (voir getop(3)). Si une lettre est suivie d’un deux-points, l’option est censée avoir un argument qui peut ou non être séparé de celle-ci par un ou plusieurs espaces. Si un caractère d’option n’est pas trouvé à l’endroit prévu, getopts définira la variable var sur «  ?  » ; getopts effacera ensuite OPTARG et écrira une sortie sur la sortie standard d’erreur. En spécifiant un deux-points comme premier caractère de optstring, toutes les erreurs seront ignorées.

Après la dernière option, getopts renverra une valeur non nulle et définira var sur «  ?  ».

Le fragment de code suivant montre comment on pourrait traiter les arguments d’une commande qui peut prendre les options [a] et [b], et l’option [c], qui nécessite un argument.

while getopts abc: f
do
case $f in
a | b)  flag=$f;;
c)      carg=$OPTARG;;
\?)     echo $USAGE; exit 1;;
esac
done
shift $((OPTIND - 1))

Ce code acceptera les commandes suivantes comme équivalentes :

cmd -acarg file file
cmd -a -c arg file file
cmd -carg -a file file
cmd -a -carg -- file file

hash [commande ...]

hash -r

Le shell maintient une table de hachage qui mémorise les emplacements des commandes. Sans aucun argument, la commande hash affiche le contenu de cette table. Les entrées qui n’ont pas été consultées depuis la dernière commande cd sont marquées d’un astérisque ; il est possible que ces entrées soient invalides.

Avec des arguments, la commande hash supprime les commandes spécifiées de la table de hachage (sauf si ce sont des fonctions), puis les localise. L’option -r fait que la commande hash supprime toutes les entrées de la table de hachage, à l’exception des fonctions.

jobs [-lp] [job ...]

Affiche l’état de tous les travaux, ou seulement des travaux spécifiés : Par défaut, affiche le numéro du travail, le statut actuel (+/-), le cas échéant, l’état du travail et sa commande shell. -l  affiche également l’ID du processus du leader du groupe et uniquement l’ID du processus et les commandes shell des autres membres du travail. -p  affiche uniquement les ID des processus des leaders, un par ligne.

kill [-s sigspec | -signum | -sigspec] [pid | job ...]

Équivalent à kill(1), mais une spécification de travail peut également être fournie. Les signaux peuvent être des noms (insensibles à la casse) sans le préfixe SIG ou des nombres décimaux ; la valeur par défaut est TERM.

kill -l [signum | exitstatus]

Affiche les noms de signaux disponibles sans le préfixe SIG. Si signum est spécifié, affiche uniquement le sigspec pour ce signal. Si exitstatus est spécifié (supérieur à 128), affiche uniquement le sigspec qui l’a provoqué.

pwd [-LP]

Commande intégrée qui mémorise le répertoire courant plutôt que de le recalculer à chaque fois. Cela la rend plus rapide. Cependant, si le répertoire courant est renommé, la version intégrée de pwd continuera à afficher l’ancien nom du répertoire. L’option -P affiche la valeur physique du répertoire de travail actuel, c’est-à-dire que tous les liens symboliques sont résolus à leurs valeurs respectives. L’option -L désactive l’effet de toute option -P précédente.

read [-p prompt] [-r] variable [...]

Le message est affiché si l’option -p est spécifiée et que l’entrée standard est un terminal. Ensuite, une ligne est lue à partir de l’entrée standard. Le saut de ligne final est supprimé de la ligne, et la ligne est divisée comme décrit dans la section sur la division de mots ci-dessus, et les parties sont assignées aux variables dans l’ordre. Au moins une variable doit être spécifiée. S’il y a plus de parties que de variables, les parties restantes (ainsi que les caractères dans IFS qui les séparent) sont attribuées à la dernière variable. S’il y a plus de variables que de parties, les variables restantes reçoivent une chaîne vide. La commande read intégrée indique le succès, sauf si la fin du fichier est rencontrée en entrée, auquel cas l’échec est renvoyé.

Par défaut, sauf si l’option -r est spécifiée, la barre oblique inverse « \ » agit comme un caractère d’échappement, ce qui fait que le caractère suivant est traité littéralement. Si une barre oblique inverse est suivie d’un saut de ligne, la barre oblique inverse et le saut de ligne seront supprimés.

readonly name ...

readonly -p

Les noms spécifiés sont marqués comme étant en lecture seule, de sorte qu’ils ne peuvent pas être modifiés ou supprimés ultérieurement. Le shell permet de définir la valeur d’une variable au moment où elle est marquée comme étant en lecture seule en écrivant :

readonly name=value

Sans arguments, la commande readonly liste les noms de toutes les variables en lecture seule. Avec l’option -p spécifiée, la sortie sera formatée de manière appropriée pour une utilisation non interactive.

printf format [value]...

printf formate et affiche ses arguments en fonction du format, une chaîne de caractères qui contient trois types d’objets : des caractères simples, qui sont simplement copiés vers la sortie standard, des séquences d’échappement de caractères qui sont converties et copiées vers la sortie standard, et des spécifications de format, dont chacune provoque l’affichage de la valeur suivante.

Chaque valeur est traitée comme une chaîne si la spécification de format correspondante est soit b, soit c, soit s ; sinon, elle est évaluée comme une constante C, avec les ajouts suivants : Un signe plus ou moins est autorisé en tête. Si le premier caractère est une seule ou une double guillemet, la valeur du prochain octet.

La chaîne de format est réutilisée aussi souvent que nécessaire jusqu’à ce que toutes les valeurs soient consommées. Toute spécification de format supplémentaire est évaluée avec zéro ou la chaîne nulle.

Les séquences d’échappement de caractères sont en notation oblique inverse, comme défini dans ANSI X3.159-1989 (« ANSI C89 »). Les caractères et leurs significations sont les suivants :

\a    Écrire un caractère <cloche>.

\b    Écrire un caractère <retour arrière>.

\e    Écrire un caractère <échappement> (ESC).

\f    Écrire un caractère <saut de page>.

\n    Écrire un caractère <saut de ligne>.

\r    Écrire un caractère <retour chariot>.

\t    Écrire un caractère <tabulation>.

\v    Écrire un caractère <tabulation verticale>.

\\    Écrire un caractère oblique inverse.

\num  Écrire un caractère 8 bits dont la valeur ASCII est le nombre octal de 1, 2 ou 3 chiffres num.

Chaque spécification de format est introduite par le caractère pourcentage (« % »). Le reste de la spécification de format comprend, dans l’ordre suivant :

Zéro ou plusieurs des indicateurs suivants :

#    Un caractère « # » spécifiant que la valeur doit être imprimée dans une « forme alternative ». Pour les formats b, c, d et s, cette option n’a aucun effet.

Pour le format o, la précision du nombre est augmentée afin de forcer le premier caractère de la chaîne de sortie à être un zéro. Pour le format x (X), un résultat non nul a la chaîne 0x (0X) préfixée. Pour les formats e, E, f, g et G, le résultat contiendra toujours un point décimal, même s’il n’y a pas de chiffres après le point (normalement, un point décimal n’apparaît que dans les résultats de ces formats s’il y a un chiffre après le point décimal). Pour les formats g et G, les zéros terminaux ne sont pas supprimés du résultat comme ils le seraient autrement.

- Un signe moins `-' qui spécifie un alignement à gauche de la sortie dans le champ indiqué ;

+ Un caractère `+' qui spécifie qu'un signe doit toujours être placé avant le nombre lors de l’utilisation de formats signés.

‘ ’ Un espace qui spécifie qu’un espace doit être laissé avant un nombre positif pour un format signé. Un `+' annule un espace si les deux sont utilisés ;

0 Un zéro `0' qui indique que le remplissage avec des zéros doit être utilisé plutôt que le remplissage avec des espaces. Un `-' annule un `0' si les deux sont utilisés ;

Largeur de champ : Une chaîne de chiffres facultative qui spécifie une largeur de champ ; si la chaîne de sortie contient moins de caractères que la largeur de champ, elle sera remplie avec des espaces à gauche (ou à droite, si l’indicateur d’alignement à gauche a été donné) pour atteindre la largeur de champ (notez qu’un zéro en tête est un indicateur, mais un zéro intégré fait partie d’une largeur de champ) ;

Précision :
Un point, « . », facultatif, suivi d’une chaîne de chiffres facultative qui donne une précision qui spécifie le nombre de chiffres à afficher après le point décimal, pour les formats e et f, ou le nombre maximal d’octets à imprimer à partir d’une chaîne (formats b et s) ; si la chaîne de chiffres est manquante, la précision est traitée comme zéro ;

Format :
Un caractère qui indique le type de format à utiliser (l’un des diouxXfwEgGbcs).

Une largeur de champ ou une précision peut être « * » au lieu d’une chaîne de chiffres. Dans ce cas, un argument fournit la largeur de champ ou la précision.

Les caractères de format et leurs significations sont les suivants :

diouXx L’argument est imprimé sous forme de nombre décimal signé (d ou i), octal non signé, décimal non signé ou hexadécimal non signé (X ou x), respectivement.

f L’argument est imprimé dans le style [-]ddd.ddd, où le nombre de chiffres après le point décimal est égal à la spécification de précision de l’argument. Si la précision est manquante, 6 chiffres sont donnés ; si la précision est explicitement 0, aucun chiffre ni point décimal n’est imprimé.

eE L’argument est imprimé dans le style [-]d.ddde±dd, où il y a un chiffre avant le point décimal et le nombre après est égal à la spécification de précision de l’argument ; lorsque la précision est manquante, 6 chiffres sont produits. Une majuscule E est utilisée pour un format « E ».

gG L’argument est imprimé dans le style f ou dans le style e (E), selon celui qui donne la plus grande précision dans le minimum d’espace.

b Les caractères de la chaîne d’argument sont imprimés avec les séquences d’échappement d’antislash développées. Les séquences d’échappement d’antislash supplémentaires suivantes sont prises en charge :

\c Annule le traitement du reste des caractères dans la chaîne d’opérande qui le contient, toutes les chaînes d’opérandes restantes et tous les caractères supplémentaires dans l’opérande de format.

\0num Écrit un caractère de 8 bits dont la valeur ASCII est le nombre octal de 1, 2 ou 3 chiffres, représenté par num.

c Le premier caractère de l'argument est imprimé.

s Les caractères de la chaîne d'arguments sont imprimés jusqu'à la fin de la chaîne ou jusqu'à ce que le nombre d'octets indiqué par la spécification de précision soit atteint ; si la précision est omise, tous les caractères de la chaîne sont imprimés.

% Imprime un « % » ; aucun argument n'est utilisé.

Dans aucun cas, une largeur de champ inexistante ou trop petite n'entraîne pas de troncature du champ ; le remplissage a lieu uniquement si la largeur de champ spécifiée dépasse la largeur réelle.

set [{ -options | +options | -- }] arg ...

La commande set effectue trois fonctions différentes.

Sans argument, elle affiche les valeurs de toutes les variables shell.

Si des options sont données, elle définit les indicateurs d'options spécifiés, ou les efface comme décrit dans la section intitulée « Traitement de la liste d'arguments ». Dans un cas particulier, si l'option est -o ou +o et qu'aucun argument n'est fourni, le shell affiche les paramètres de toutes ses options. Si l'option est -o, les paramètres sont affichés dans un format lisible ; si l'option est +o, les paramètres sont affichés dans un format adapté à la réintroduction dans le shell afin d'affecter les mêmes paramètres d'option.

En plus des noms d'options répertoriés dans la section « Traitement de la liste d'arguments », les options suivantes peuvent être spécifiées en tant qu'arguments de -o ou +o :

pipefail Dérive le statut de sortie d'un pipeline à partir des statuts de sortie de toutes les commandes du pipeline, et non uniquement de la dernière commande, comme décrit dans la section « Pipelines ».

La troisième utilisation de la commande set est de définir les valeurs des paramètres de position du shell aux arguments spécifiés. Pour modifier les paramètres de position sans modifier les options, utilisez « -- » comme premier argument de set. S'il n'y a pas d'arguments, la commande set efface tous les paramètres de position (ce qui équivaut à exécuter « shift $# »).

shift [n]

Décale les paramètres de position n fois. Un décalage définit la valeur de $1 sur la valeur de $2, la valeur de $2 sur la valeur de $3, et ainsi de suite, en diminuant la valeur de $# de 1. Si n est supérieur au nombre de paramètres de position, shift affiche un message d'erreur et quitte avec un statut de retour de 2.

test expression

[ expression ]

L'utilitaire test évalue l'expression et, si elle est vraie, renvoie un statut de sortie de zéro (vrai) ; sinon, il renvoie 1 (faux). S'il n'y a pas d'expression, test renvoie également 1 (faux).

Tous les opérateurs et indicateurs sont des arguments distincts de l'utilitaire test.

Les primaires suivants sont utilisés pour construire l'expression :

-b file Vrai si le fichier existe et est un fichier spécial de type bloc.

-c file Vrai si le fichier existe et est un fichier spécial de type caractère.

-d file Vrai si le fichier existe et est un répertoire.

-e file Vrai si le fichier existe (quel que soit le type).

-f file Vrai si le fichier existe et est un fichier ordinaire.

-g fichier   Vrai si le fichier existe et que son indicateur d’ID de groupe est activé.

-h fichier   Vrai si le fichier existe et qu’il s’agit d’un lien symbolique.

-k fichier   Vrai si le fichier existe et que son bit collant est activé.

-n chaîne   Vrai si la longueur de la chaîne est différente de zéro.

-p fichier   Vrai si le fichier est un tube nommé (FIFO).

-r fichier   Vrai si le fichier existe et qu’il est lisible.

-s fichier   Vrai si le fichier existe et que sa taille est supérieure à zéro.

-t descripteur_de_fichier

Vrai si le fichier dont le numéro de descripteur de fichier est descripteur_de_fichier est ouvert et est associé à un terminal.

-u fichier   Vrai si le fichier existe et que son indicateur d’ID d’utilisateur est activé.

-w fichier   Vrai si le fichier existe et qu’il est accessible en écriture. Vrai indique uniquement que le drapeau d’écriture est activé. Le fichier n’est pas accessible en écriture sur un système de fichiers en lecture seule, même si ce test indique vrai.

-x fichier   Vrai si le fichier existe et qu’il est exécutable. Vrai indique uniquement que le drapeau d’exécution est activé. Si le fichier est un répertoire, vrai indique que le fichier peut être recherché.

-z chaîne   Vrai si la longueur de la chaîne est nulle.

-L fichier   Vrai si le fichier existe et qu’il s’agit d’un lien symbolique. Cet opérateur est conservé pour la compatibilité avec les versions antérieures de ce programme. Ne vous fiez pas à son existence ; utilisez plutôt -h.

-O fichier   Vrai si le fichier existe et que son propriétaire correspond à l’ID d’utilisateur effectif de ce processus.

-G fichier   Vrai si le fichier existe et que son groupe correspond à l’ID de groupe effectif de ce processus.

-S fichier   Vrai si le fichier existe et qu’il s’agit d’un socket.

fichier1 -nt fichier2

Vrai si fichier1 et fichier2 existent et que fichier1 est plus récent que fichier2, ou si fichier1 existe mais que fichier2 n’existe pas.

fichier1 -ot fichier2

Vrai si fichier1 et fichier2 existent et que fichier1 est plus ancien que fichier2, ou si fichier2 existe mais que fichier1 n’existe pas.

fichier1 -ef fichier2

Vrai si fichier1 et fichier2 existent et font référence au même fichier.

chaîne   Vrai si la chaîne n’est pas la chaîne nulle.

s1 = s2   Vrai si les chaînes s1 et s2 sont identiques.

s1 != s2   Vrai si les chaînes s1 et s2 ne sont pas identiques.

s1 < s2   Vrai si la chaîne s1 est antérieure à s2 en fonction de la valeur ASCII de leurs caractères.

s1 > s2   Vrai si la chaîne s1 est postérieure à s2 en fonction de la valeur ASCII de leurs caractères.

n1 -eq n2   Vrai si les entiers n1 et n2 sont algébriquement égaux.

n1 -ne n2   Vrai si les entiers n1 et n2 ne sont pas algébriquement égaux.

n1 -gt n2   Vrai si l’entier n1 est algébriquement supérieur à l’entier n2.

n1 -ge n2   Vrai si l’entier n1 est algébriquement supérieur ou égal à l’entier n2.

n1 -lt n2   Vrai si l’entier n1 est algébriquement inférieur à l’entier n2.

n1 -le n2   Vrai si l’entier n1 est algébriquement inférieur ou égal à l’entier n2.

Ces opérateurs primaires peuvent être combinés avec les opérateurs suivants :

! expression  Vrai si expression est faux.

expression1 -a expression2

Vrai si expression1 et expression2 sont vrais.

expression1 -o expression2

Vrai si expression1 ou expression2 sont vrais.

(expression) Vrai si l'expression est vraie.

L'opérateur -a a une priorité plus élevée que l'opérateur -o.

times   Affiche le temps d'exécution cumulé du shell et des processus exécutés à partir du shell. Le code de retour est 0.

trap [action signal ...]
Permet au shell d'analyser et d'exécuter l'action lorsqu'un des signaux spécifiés est reçu. Les signaux sont spécifiés par leur numéro ou par le nom du signal. Si le signal est 0 ou EXIT, l'action est exécutée lorsque le shell se termine. L'action peut être vide (''), ce qui fait que les signaux spécifiés sont ignorés. Si l'action est omise ou définie sur '-', les signaux spécifiés reçoivent leur action par défaut. Lorsqu'un shell crée un sous-shell, il réinitialise les signaux piégés (mais pas ignorés) à leur action par défaut. La commande trap n'a aucun effet sur les signaux qui étaient ignorés au démarrage du shell. La commande trap sans aucun argument affiche une liste des signaux et de leurs actions correspondantes sur la sortie standard dans un format adapté à un shell qui obtiendrait les mêmes résultats de piégeage.

Exemples :

trap

Affiche la liste des signaux piégés et de leurs actions correspondantes.

trap '' INT QUIT TSTP 30

Ignore les signaux INT, QUIT, TSTP, USR1.

trap date INT

Affiche la date lorsqu'il reçoit le signal INT.

type [nom ...]
Interprète chaque nom comme une commande et affiche la résolution de la recherche de commande. Les résolutions possibles sont : mot-clé du shell, alias, commande intégrée du shell, commande, alias suivi et non trouvé. Pour les alias, l'expansion de l'alias est affichée ; pour les commandes et les alias suivis, le chemin complet de la commande est affiché.

ulimit [-H | -S] [-a | -tfdscmlpnvwr [valeur]]
Permet de connaître ou de définir les limites dures ou souples des processus ou de définir de nouvelles limites. Le choix entre la limite dure (qui ne peut être violée par aucun processus et qui ne peut pas être augmentée une fois qu'elle a été diminuée) et la limite souple (qui provoque l'envoi d'un signal aux processus, mais pas nécessairement leur suppression, et qui peut être augmentée) est effectué à l'aide des indicateurs suivants :

-H      définit ou interroge les limites dures.

-S      définit ou interroge les limites souples. Si ni -H ni -S n'est spécifié, la limite souple est affichée ou les deux limites sont définies. Si les deux sont spécifiés, le dernier l'emporte.

La limite à interroger ou à définir est ensuite choisie en spécifiant l'un des indicateurs suivants :

-a      affiche toutes les limites actuelles.

-t      affiche ou définit la limite du temps CPU (en secondes).

-f      affiche ou définit la limite de la taille maximale du fichier pouvant être créé (en blocs de 512 octets).

-d      affiche ou définit la limite de la taille du segment de données d'un processus (en kilooctets).

-s      affiche ou définit la limite de la taille de la pile d'un processus (en kilooctets).

-c      affiche ou définit la limite de la taille maximale du fichier de vidage du cœur pouvant être produit (en blocs de 512 octets).

-m      affiche ou définit la limite de la quantité totale de mémoire physique pouvant être utilisée par un processus (en kilooctets).

-l      affiche ou définit la limite de la quantité de mémoire qu'un processus peut verrouiller avec mlock(2) (en kilooctets).

-p : affiche ou définit la limite du nombre de processus qu'un utilisateur peut avoir en cours
    à un moment donné.

-n : affiche ou définit la limite du nombre de fichiers qu'un processus peut avoir ouverts
    simultanément.

-v : affiche ou définit la limite de la mémoire virtuelle totale qui peut être utilisée par un
    processus (en kilooctets).

-w : affiche ou définit la limite du nombre total de verrous détenus par un processus.

-r : affiche ou définit la limite de la priorité d'ordonnancement en temps réel d'un processus.

Si aucune de ces options n'est spécifiée, la limite de la taille des fichiers est affichée ou définie. Si une valeur est spécifiée, la limite est définie sur ce nombre ; sinon, la limite actuelle est affichée.

Les limites d'un processus arbitraire peuvent être affichées ou définies à l'aide de l'utilitaire sysctl(8).

umask [masque]

Définit la valeur de umask (voir umask(2)) à la valeur octale spécifiée. Si l'argument est ommis, la valeur de umask est affichée.

unalias [-a] [nom]

Si un nom est spécifié, le shell supprime cet alias. Si l'option -a est spécifiée, tous les alias sont supprimés.

unset [-fv] nom ...

Les variables et fonctions spécifiées sont supprimées et non exportées. Si -f ou -v est spécifié, la fonction ou la variable correspondante est supprimée, respectivement. Si un nom donné correspond à la fois à une variable et à une fonction, et qu'aucune option n'est donnée, seule la variable est supprimée.

wait [tâche]

Attend la fin de la tâche spécifiée et renvoie le code de sortie du dernier processus de la tâche. Si l'argument est omis, attend la fin de toutes les tâches et renvoie un code de sortie de zéro.

Édition de la ligne de commande

Lorsque dash est utilisé de manière interactive à partir d'un terminal, la commande actuelle et l'historique des commandes (voir fc dans « Commandes intégrées ») peuvent être édités à l'aide de l'édition de ligne de commande en mode vi. Ce mode utilise des commandes, décrites ci-dessous, similaires à un sous-ensemble de celles décrites dans la page de manuel vi. La commande 'set -o vi' active l'édition en mode vi et place sh en mode insertion vi. Lorsque le mode vi est activé, sh peut basculer entre le mode insertion et le mode commande. Il est similaire à vi : taper ⟨ESC⟩ passe en mode commande vi. Appuyer sur ⟨Entrée⟩ en mode commande enverra la ligne au shell.

CODE DE SORTIE

Les erreurs détectées par le shell, telles qu'une erreur de syntaxe, feront que le shell se terminera avec un code de sortie non nul. Si le shell n'est pas un shell interactif, l'exécution du fichier shell sera interrompue. Sinon, le shell renverra le code de sortie de la dernière commande exécutée, ou s'il utilise la commande intégrée exit avec un argument numérique, il renverra cet argument.

ENVIRONNEMENT

HOME : défini automatiquement par login(1) à partir du répertoire de connexion de l'utilisateur dans
le fichier de mot de passe (passwd(4)). Cette variable d'environnement fonctionne également comme
argument par défaut pour la commande intégrée cd.

PATH : le chemin de recherche par défaut pour les exécutables. Voir la section ci-dessus « Recherche de
chemin ».

CDPATH : le chemin de recherche utilisé avec la commande intégrée cd.

MAIL       Le nom du fichier de courrier, qui sera vérifié pour détecter l'arrivée de nouveaux courriers. Remplacé par MAILPATH.

MAILCHECK  La fréquence, en secondes, à laquelle le shell vérifie l'arrivée de courriers dans les fichiers spécifiés par MAILPATH ou le fichier MAIL. Si la valeur est définie sur 0, la vérification aura lieu à chaque invite.

MAILPATH   Une liste de noms de fichiers séparés par des deux-points « : », que le shell doit vérifier pour détecter les nouveaux courriers. Ce paramètre d'environnement remplace le paramètre MAIL. Il existe un maximum de 10 boîtes aux lettres qui peuvent être surveillées en même temps.

PS1        La chaîne de caractères de l'invite principale, qui par défaut est « $ », sauf si vous êtes l'utilisateur super, auquel cas elle est par défaut « # ».

PS2        La chaîne de caractères de l'invite secondaire, qui par défaut est « > ».

PS4        La sortie affichée avant chaque ligne lorsque le mode de traçage de l'exécution (set -x) est activé, par défaut « + ».

IFS        Séparateurs de champs d'entrée. Normalement, ce paramètre est défini sur ⟨espace⟩, ⟨tabulation⟩ et ⟨saut de ligne⟩. Voir la section « Division par espace blanc » pour plus de détails.

TERM       Le paramètre de terminal par défaut pour le shell. Ce paramètre est hérité par les processus enfants du shell et est utilisé dans les modes d'édition de l'historique.

HISTSIZE   Le nombre de lignes dans le tampon d'historique du shell.

PWD        La valeur logique du répertoire de travail actuel. Ce paramètre est défini par la commande cd.

OLDPWD     La valeur logique précédente du répertoire de travail actuel. Ce paramètre est défini par la commande cd.

PPID       L'ID de processus du processus parent du shell.

FICHIERS

$HOME/.profile

/etc/profile

VOIR AUSSI

csh(1), echo(1), getopt(1), ksh(1), login(1), printf(1), test(1), getopt(3), passwd(5), environ(7), sysctl(8)

HISTORIQUE

dash est une implémentation conforme à POSIX de /bin/sh qui vise à être aussi petite que possible. dash est un descendant direct de la version NetBSD d'ash (l'Almquist SHell), qui a été portée sur Linux au début de 1997. Il a été renommé en dash en 2002.

BUGS

Il faut éviter à tout prix les scripts shell avec setuid, car ils représentent un risque important pour la sécurité.

PS1, PS2 et PS4 doivent être soumis à l'expansion des paramètres avant d'être affichés.