Ash - Commande Linux - Commande Unix

PRÉNOM

sh - interpréteur de commandes ( shell )

SYNOPSIS

sh [- / + aCefnuvxIimqsVEbc ] [- o longname ] -words [ cible ... ]

LA DESCRIPTION

Sh est l'interpréteur de commandes standard pour le système. La version actuelle de sh est en cours de modification pour être conforme aux spécifications POSIX 1003.2 et 1003.2a du shell. Cette version a de nombreuses caractéristiques qui la rendent semblable à certains égards au shell Korn, mais ce n'est pas un clone de Korn (voir ksh (1)). Seules les fonctionnalités désignées par POSIX et quelques extensions de Berkeley sont intégrées dans ce shell. Nous nous attendons à la conformité POSIX au moment où 4.4 BSD est publié. 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 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 autre shell avec la commande chsh (1)). Le shell implémente un langage qui a des constructions de contrôle de flux, une fonctionnalité de macro qui fournit une variété de fonctionnalités en plus du stockage de données, avec des fonctions 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 à l'utilisation interactive et non interactive (scripts shell). Autrement dit, les commandes peuvent être tapées directement sur 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

Si aucun argument n'est présent et si l'entrée standard du shell est connectée à un terminal (ou si l'indicateur -i est activé) et que l'option -c n'est pas présente, le shell est considéré comme un shell interactif. Un shell interactif invite généralement avant chaque commande et gère différemment les erreurs de programmation et de commande (comme décrit ci-dessous). Au premier démarrage, le shell inspecte l'argument 0, et s'il commence par un tiret «-», le shell est également considéré comme un shell de connexion. Cela est normalement effectué automatiquement par le système lors de la première connexion de l'utilisateur. Un shell de connexion lit d'abord les commandes des fichiers / etc / profile et .profile si elles existent. Si la variable d'environnement ENV est définie à l'entrée d'un shell ou est définie dans le fichier .profile d'un shell de connexion, le shell lit ensuite les commandes du fichier nommé dans ENV. Par conséquent, un utilisateur doit placer les commandes à exécuter uniquement sur l'heure de connexion dans le fichier .profile, et les commandes qui sont exécutées pour chaque shell dans le fichier ENV . Pour définir la variable ENV sur un fichier, placez la ligne suivante dans votre fichier .profile de votre répertoire de base

ENV = $ HOME / .shinit; exporter ENV

en substituant `` .shinit '' tout nom de fichier que vous souhaitez. Comme le fichier ENV est lu pour chaque invocation du shell, y compris les scripts shell et les shells non interactifs, le paradigme suivant est utile pour limiter les commandes du fichier ENV aux invocations interactives. Placez les commandes dans le `` cas '' et `` esac '' ci-dessous (ces commandes sont décrites plus loin):

cas $ - en * i *)

# commandes à usage interactif seulement

...

Esac

Si des arguments de ligne de commande en dehors des 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 paramètres positionnels du shell ($ 1 , 2 $, etc). Sinon, le shell lit les commandes depuis son entrée standard.

Traitement de liste d'arguments

Toutes les options de lettre unique ont un nom correspondant qui peut être utilisé comme argument pour l'option -o. Le nom du set - o est fourni à côté de l 'option lettre unique dans la description ci - dessous. La spécification d'un tiret `` - '' active l'option, tandis que l'utilisation d'un plus `` + '' désactive l'option. Les options suivantes peuvent être définies à partir de la ligne de commande ou avec le jeu intégré (1) (décrit plus loin).

-un allexport

Exporter toutes les variables affectées à. (NON REMPLI pour 4.4alpha)

-c

Lire les commandes à partir de la ligne de commande. Aucune commande ne sera lue à partir de l'entrée standard.

-C noclobber

Ne pas écraser les fichiers existants avec ``> '' (UNIMPLEMENTED for 4.4alpha)

-e errexit

Si ce n'est pas interactif, quittez 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ésactiver l'extension de chemin d'accès .

-n noexec

Si ce n'est pas interactif, lisez les commandes mais ne les exécutez pas. Ceci est utile pour vérifier la syntaxe des scripts shell.

-u nounset

Écrivez un message à l'erreur standard en essayant de développer une variable qui n'est pas définie, et si le shell n'est pas interactif, quittez immédiatement. (NON REMPLI pour 4.4alpha)

-v verbeux

Le shell écrit son entrée à l'erreur standard à mesure qu'elle est lue. Utile pour le débogage.

-x xtrace

Ecrire chaque commande à l'erreur standard (précédée d'un `+ 'avant qu'elle ne soit exécutée) Utile pour le débogage.

-q quietprofile

Si les options -v ou -x ont été définies, ne les appliquez pas lors de la lecture des fichiers d'initialisation, ceux-ci étant / etc / profile .profile et le fichier spécifié par la variable d'environnement ENV .

-Je ignoreeof

Ignorer EOF de l'entrée lorsque interactif.

-i interactif

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

-m moniteur

Activer le contrôle du travail (défini automatiquement lors de l'interactivité).

-s stdin

Lit les commandes à partir de l'entrée standard (définie automatiquement si aucun argument de fichier n'est présent). Cette option n'a aucun effet lorsqu'elle est définie après que le shell a déjà démarré (c'est-à-dire avec set (1)).

-V vi

Activer l'éditeur de ligne de commande vi (1) intégré (désactive - E s'il a été défini).

-E Emacs

Activer l'éditeur de ligne de commande emacs (1) intégré (désactive -V s'il a été défini).

-b notifier

Activer la notification asynchrone de l'achèvement du travail en arrière-plan. (NON REMPLI pour 4.4alpha)

Structure lexicale

Le shell lit l'entrée en termes de lignes à partir d'un fichier et le divise en mots à blanc (espaces et tabulations), et à certaines séquences de caractères spécifiques au shell appelés «opérateurs». Il existe deux types d'opérateurs: les opérateurs de contrôle et les opérateurs de redirection (leur signification est discutée plus tard). Voici une liste d'opérateurs:

"Opérateurs de contrôle:"

& && (); ;; | ||

"Opérateur de redirection:"

<>> | << >> <&> & << - <>

Citant

La citation est utilisée pour supprimer la signification particulière de certains caractères ou mots au 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 les barres obliques inversées.

Barre oblique inverse

Une barre oblique inverse préserve la signification littérale du caractère suivant, à l'exception de AQ Newline. Une barre oblique inverse précédant une nouvelle ligne Aq est traitée comme une continuation de ligne.

Guillemets simples

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

Double citation

La présence de caractères entre guillemets préserve la signification littérale de tous les caractères sauf dollar ($) backquote (`) et barre oblique inverse (\) La barre oblique inversée à l'intérieur des guillemets doubles est historiquement étrange et ne sert qu'à citer les caractères suivants:

$ `\

Sinon, il reste littéral.

Mots réservés

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

! Ta Taif Ta Ta Ta alors Ta cas

sinon Ta pour Ta puis Ta Ta Ta

Ta Ta fait Ta jusqu'à Ta si Ta esac

Leur signification est discutée plus tard.

Alias

Un alias est un nom et un ensemble de valeurs correspondant utilisant 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é les mots réservés, le shell vérifie le mot pour voir s'il correspond à un alias. Si c'est le cas, il le remplace dans le flux d'entrée avec sa valeur. Par exemple, s'il y a un alias appelé `` lf '' avec la valeur `` ls -F '' alors l'entrée:

lf foobar

deviendrait

ls -F foobar

Les alias constituent un moyen pratique pour les utilisateurs naïfs de créer des raccourcis pour les commandes sans devoir apprendre à créer des fonctions avec des arguments. Ils peuvent également être utilisés pour créer du code lexical obscur. Cette utilisation est déconseillée.

Commandes

Le shell interprète les mots qu'il lit en fonction d'un langage dont la spécification sort du cadre de cette page de manuel (se référer à la BNF dans le document POSIX 1003.2). Essentiellement, cependant, 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 le shell a reconnu une commande simple. Sinon, une commande complexe ou une autre construction spéciale peut avoir été reconnue.

Commandes simples

Si une commande simple a été reconnue, le shell effectue les actions suivantes:

  1. Les mots principaux 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 (décrits ci-dessous) sont supprimés et enregistrés pour traitement.
  2. Les mots restants sont développés comme décrit dans la section intitulée «Expansions» et le premier mot restant est considéré comme le nom de la commande et la commande est située. Les mots restants sont considérés comme les arguments de la commande. Si aucun nom de commande ne s'affiche, les affectations de variables `` nom = valeur '' reconnues dans l'élément 1 affectent le shell en cours.
  3. Les redirections sont effectuées comme décrit dans la section suivante.

Redirections

Les redirections sont utilisées pour changer où une commande lit son entrée ou envoie sa sortie. En général, les redirections ouvrent, ferment ou dupliquent une référence existante à un fichier. Le format global utilisé pour la redirection est:

[n] fichier redir-op

redir-op est l'un des opérateurs de redirection mentionnés précédemment. Voici une liste des redirections possibles. Le Bq n est un nombre optionnel, comme dans `3 '(pas` Bq 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 remplacez l'option- C .

[n] >> fichier

Ajouter la sortie standard (ou n) au fichier.

[n]

Redirige l'entrée standard (ou n) à partir du fichier.

[n1] <& n2

Dupliquer l'entrée standard (ou n1) du descripteur de fichier n2.

[n] <& -

Fermer l'entrée standard (ou n).

[n1]> & n2

Dupliquer la sortie standard (ou n1) de n2.

[n]> & -

Fermer la sortie standard (ou n).

fichier [n] <>

Ouvrir le fichier pour lire et écrire sur l'entrée standard (ou n).

La redirection suivante est souvent appelée `` document ici ''

[n] << délimiteur

ici-doc-text ...

délimiteur

Tout le texte sur les lignes successives jusqu'au délimiteur est sauvegardé et mis à la disposition de la commande sur l'entrée standard, ou du descripteur de fichier n s'il est spécifié. Si le délimiteur tel que spécifié sur la ligne initiale est cité, alors le texte here-doc 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 "Expansions") 'Si l'opérateur est `` << -' 'au lieu de `` <<', alors les onglets principaux dans le document here-doc sont supprimés.

Recherche et exécution

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

Quand une fonction shell est exécutée, tous les paramètres de position du shell (sauf $ 0, qui reste inchangé) sont mis aux arguments de la fonction shell. Les variables qui sont explicitement placées dans l'environnement de la commande (en leur affectant des affectations avant le nom de la fonction) sont rendues locales à la fonction et sont mises aux valeurs données. Ensuite, la commande donnée dans la définition de la fonction est exécutée. Les paramètres positionnels sont restaurés à leurs valeurs d'origine lorsque la commande est terminée. Tout cela se produit dans le shell actuel.

Les builtins shell sont exécutés en interne sur le shell, sans engendrer de nouveau processus.

Sinon, si le nom de la commande ne correspond pas à une fonction ou à un builtin, la commande est recherchée comme un 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 passant les arguments et l'environnement au programme. Si le programme n'est pas un fichier exécutable normal (ie, s'il ne commence pas par le "nombre magique" dont la représentation ASCII est "#!", Alors execve (2) retourne Er ENOEXEC alors) le shell interprétera le programme dans un sous-couche. Le shell enfant se réinitialisera dans ce cas, de sorte que l'effet sera comme si un nouveau shell avait été appelé pour gérer le script shell ad-hoc, sauf que l'emplacement des commandes hachées situé dans le shell parent sera mémorisé par le enfant.

Notez que les versions précédentes de ce document et le code source lui-même se réfèrent de manière trompeuse et sporadique à un script shell sans numéro magique en tant que "procédure shell".

Recherche de chemin

Lors de la localisation d'une commande, le shell regarde d'abord s'il a une fonction shell par ce nom. Ensuite, il recherche une commande interne de ce nom. Si une commande intégrée n'est pas trouvée, l'une des deux choses suivantes se produit:

  1. Les noms de commande contenant une barre oblique sont simplement exécutés sans effectuer de recherches.
  2. Le shell recherche chaque entrée dans PATH à tour de rôle pour la commande. La valeur de la variable PATH devrait être une série d'entrées séparées par des deux-points. Chaque entrée est constituée d'un nom de répertoire. Le répertoire courant peut être indiqué implicitement par un nom de répertoire vide, ou explicitement par une seule période.

Statut de sortie de la commande

Chaque commande a un statut de sortie qui peut influencer le comportement des autres commandes du shell. Le paradigme est qu'une commande se termine par zéro pour la normale ou la réussite, et non nulle pour l'échec, l'erreur ou une fausse indication. La page de manuel pour chaque commande doit indiquer les différents codes de sortie et ce qu'ils signifient. De plus, les commandes intégrées renvoient des codes de sortie, tout comme une fonction shell exécutée.

Commandes complexes

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

  • commande simple
  • pipeline
  • liste ou liste composée
  • commande composée
  • définition de la 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:

[!] command1 [| commande2 ...]

La sortie standard de command1 est connectée à l'entrée standard de command2. L'entrée standard, la sortie standard ou les deux d'une commande est considérée comme affectée par le pipeline avant toute redirection spécifiée par les opérateurs de redirection faisant partie de la commande.

Si le pipeline n'est pas en arrière-plan (voir plus loin), le shell attend que toutes les commandes soient terminées.

Si le mot réservé! ne précède pas le pipeline, l'état de sortie est l'état de sortie de la dernière commande spécifiée dans le pipeline. Sinon, le statut de sortie est le NON logique du statut de sortie de la dernière commande. Autrement dit, si la dernière commande renvoie zéro, le statut de sortie est 1; Si la dernière commande renvoie plus de zéro, le statut de sortie est zéro.

Comme l'affectation de pipeline de l'entrée standard ou de la sortie standard ou les deux a lieu avant la redirection, elle peut être modifiée par redirection. Par exemple:

$ command1 2> & 1 | commande2

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

UNE ; ou terminator provoque l'exécution séquentielle de la liste AND-OR précédente (décrite ci-après); a & provoque l'exécution asynchrone de la liste AND-OU précédente.

Notez que contrairement à d'autres shells, chaque processus dans le pipeline est un enfant du shell appelant (sauf s'il s'agit d'un shell intégré, auquel cas il s'exécute dans le shell en cours - mais tout effet sur l'environnement est effacé).

Commandes de fond -

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

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

command1 & [commande2 & ...]

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

Listes - Généralement parlant

Une liste est une séquence de zéro ou plusieurs commandes séparées par des retours à la ligne, des points-virgules ou des esperluettes, et éventuellement terminées par l'un de ces trois caractères. Les commandes d'une liste sont exécutées dans l'ordre où elles sont écrites. Si la commande est suivie d'une perluète, le shell lance 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 de court-circuit

`` && '' et `` || '' sont des opérateurs de liste AND-OR. `` && '' exécute la première commande, puis exécute la deuxième commande si l'état de sortie de la première commande est zéro. `` || '' est similaire, mais exécute la deuxième commande si l'état de sortie de la première commande est différent de zéro. `` && '' et `` || '' ont tous les deux la même priorité.

Constructions de contrôle de flux - si, pendant, pour, cas

La syntaxe de la commande if est

si liste
puis liste
[liste elif
puis liste] ...
[autre liste]
Fi

La syntaxe de la commande while est

tandis que la liste
faire une liste
terminé

Les deux listes sont exécutées à plusieurs reprises alors que le statut de sortie de la première liste est zéro. La commande until est similaire, mais a le mot until à la place de while, ce qui le fait se répéter jusqu'à ce que le statut de sortie de la première liste soit nul.

La syntaxe de la commande for est

pour variable dans le mot ...
faire une liste
terminé

Les mots sont développés, puis la liste est exécutée à plusieurs reprises avec la variable définie pour chaque mot à tour de rôle. fait et fait peut être remplacé par `` {'' et ``} ''

La syntaxe de la commande break et continue est

casser [num]
continuer [num]

Break termine le numéro le plus profond pour ou en boucle. Continuer avec la prochaine itération de la boucle la plus interne. Ceux-ci sont implémentés en tant que commandes intégrées.

La syntaxe de la commande case est

mot de cas dans
modèle) liste ;;
...
Esac

Le motif peut en fait être un ou plusieurs motifs (voir Patterns de Shell décrits plus loin), séparés par des caractères `` ''.

Grouper les commandes ensemble

Les commandes peuvent être groupées en écrivant

(liste)

ou

{ liste;

Le premier d'entre eux exécute les commandes dans un sous-shell. Les commandes intégrées regroupées dans un (liste) n'affectent pas le shell actuel. La deuxième forme ne fourche pas un autre shell, elle est donc légèrement plus efficace. Regrouper des commandes de cette façon vous permet de rediriger leur sortie comme s'il s'agissait d'un seul programme:

{printf bonjour; monde printf \ n ";}> salutation

Les fonctions

La syntaxe d'une définition de fonction est

commande name ()

Une définition de fonction est une instruction exécutable; lorsqu'il est exécuté, il installe une fonction nommée name et renvoie un état de sortie nul. La commande est normalement une liste entre `` {'' et ``} ''

Les variables peuvent être déclarées locales à une fonction en utilisant une commande locale. Cela devrait apparaître comme la première déclaration d'une fonction, et la syntaxe est

local [variable | -] ...

Local 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 exportés et en lecture seule de la variable ayant le même nom dans la portée environnante, s'il y en a un. Sinon, la variable est initialement non définie. Le shell utilise une portée dynamique, de sorte que si vous faites la variable x locale à fonction f, qui appelle alors la fonction g, les références à la variable x faite à l'intérieur de g se réfèrent à la variable x déclarée à l'intérieur de f .

Le seul paramètre spécial qui peut être rendu local est `` - '' Rendre `` - '' local toutes les options de shell qui sont modifiées via la commande set dans la fonction pour restaurer leurs valeurs d'origine quand la fonction retourne.

La syntaxe de la commande de retour est

retour [exitstatus

Il termine la fonction en cours d'exécution. Le retour 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énoté par un nom s'appelle une variable. Au démarrage, le shell transforme toutes les variables d'environnement en variables shell. De nouvelles variables peuvent être définies en utilisant le formulaire

nom = valeur

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

Paramètres de position

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

Paramètres spéciaux

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

*

S'étend aux paramètres de position, en commençant par un. Lorsque l'expansion se produit dans une chaîne entre guillemets doubles, elle 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 si IFS n'est pas défini.

@

S'étend aux paramètres de position, en commençant par un. Lorsque l'expansion se produit entre guillemets, chaque paramètre de position se développe en tant qu'argument séparé. S'il n'y a pas de paramètres positionnels, l'expansion de @ génère zéro argument, même si @ est entre guillemets. Ce que cela signifie, par exemple, est que si $ 1 est `` abc '' et $ 2 est `` def ghi '' alors Qq $ @ s'étend aux deux arguments:

abc def ghi

#

S'étend au nombre de paramètres de position.

?

S'étend au statut de sortie du pipeline le plus récent.

- (Trait d'union.)

Développe les indicateurs d'option en cours (les noms d'option à lettre unique concaténés en une chaîne) comme spécifié lors de l'invocation, par la commande set set, ou implicitement par le shell.

$

Développe l'ID de processus du shell appelé. Un sous-shell conserve la même valeur de $ que son parent.

!

Développe l'ID du processus de la commande d'arrière-plan 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)

Développe le nom du shell ou du script shell.

Expansions de mots

Cette clause décrit les différentes extensions effectuées sur les mots. Toutes les extensions ne sont pas effectuées sur chaque mot, comme expliqué plus tard.

Les expansions de tilde, les expansions de paramètres, les substitutions de commandes, les expansions arithmétiques et les suppressions de citation qui se produisent dans un seul mot se développent en un seul champ. C'est seulement le fractionnement de champ ou l'expansion de chemin qui peut créer plusieurs champs d'un seul mot. La seule exception à cette règle est l'expansion du paramètre spécial @ entre guillemets, comme cela a été décrit ci-dessus.

L'ordre d'expansion des mots est:

  1. Expansion de Tilde, Expansion de paramètre, Substitution de commande, Expansion arithmétique (tout cela se produit en même temps).
  2. Le fractionnement de champs est effectué sur les champs générés par l'étape (1) sauf si la variable IFS est nulle.
  3. Expansion du chemin (sauf si set- f est en vigueur).
  4. Suppression de devis

Le caractère $ est utilisé pour introduire une extension de paramètre, une substitution de commande ou une évaluation arithmétique.

Tilde Expansion (substitution du répertoire personnel d'un utilisateur)

Un mot commençant par un caractère tilde non cité (~) est soumis à une expansion 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 de base de l'utilisateur actuel).

Expansion de paramètre

Le format pour l'expansion des paramètres est le suivant:

où expression est composée de tous les caractères jusqu'à la correspondance ``} '' Tout ``} '' échappé par une barre oblique inverse ou dans une chaîne entre guillemets, et les caractères dans les expansions arithmétiques, les substitutions de commandes et les expansions variables ne sont pas examinés correspondant ``} ''

La forme la plus simple pour l'expansion des paramètres est:

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 facultatives, à l'exception des paramètres positionnels à plusieurs chiffres ou lorsque le paramètre est suivi d'un caractère pouvant être interprété comme faisant partie du nom. Si une extension de paramètre se produit à l'intérieur de guillemets:

  1. L'extension de chemin n'est pas effectuée sur les résultats de l'expansion.
  2. Le fractionnement des champs n'est pas effectué sur les résultats de l'expansion, à l'exception de @.

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

Utiliser les valeurs par défaut Si le paramètre est unset ou null, l'expansion du mot est substituée; sinon, la valeur du paramètre est substituée.

Assigner des valeurs par défaut. Si le paramètre est unset ou null, l'expansion du mot est affectée au paramètre. Dans tous les cas, la valeur finale du paramètre est substituée. Seules les variables, pas les paramètres de position ou les paramètres spéciaux, peuvent être affectés de cette manière.

Indiquer une erreur si Null ou Unset. Si le paramètre est unset ou null, l'expansion du mot (ou un message l'indiquant non renseigné si le mot est omis) est écrit dans l'erreur standard et le shell se ferme avec un état de sortie différent de zéro. Sinon, la valeur du paramètre est substituée. Un shell interactif n'a pas besoin de quitter.

Utilisez une valeur alternative. Si le paramètre est unset ou null, null est substitué; sinon, l'expansion de mot est substituée.

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

Longueur de chaine. 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 de la sous-chaîne. Dans chaque cas, la notation de mise en correspondance de motifs (voir Modèles de coquilles), plutôt que 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é. L'inclusion de la chaîne d'extension de paramètre complète entre guillemets n'entraîne pas la citation des quatre variétés de caractères de motif suivantes, alors que l'insertion de caractères dans les accolades a cet effet.

Retirer le plus petit motif de suffixe. Le mot est développé pour produire un motif. L'expansion des paramètres donne alors un paramètre, la plus petite partie du suffixe correspondant au motif supprimé.

Supprimer le plus grand modèle de suffixe. Le mot est développé pour produire un motif. L'expansion des paramètres entraîne alors un paramètre, la plus grande partie du suffixe correspondant au motif supprimé.

Retirer le plus petit motif de préfixe. Le mot est développé pour produire un motif. L'expansion des paramètres donne alors un paramètre, la plus petite partie du préfixe correspondant au motif supprimé.

Supprimer le plus grand motif de préfixe. Le mot est développé pour produire un motif. L'expansion des paramètres entraîne alors un paramètre, la plus grande partie du préfixe correspondant au motif supprimé.

Substitution de commande

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

$ (commande)

ou Po `` backquoted '' version Pc:

`command`

Le shell étend la substitution de commandes en exécutant la commande dans un environnement de sous-shell et en remplaçant la substitution de commandes par la sortie standard de la commande, en supprimant les séquences d'un ou plusieurs à la fin de la substitution. (Les incorporés avant la fin de la sortie ne sont pas supprimés, mais ils peuvent être convertis en , en fonction de la valeur de IFS et du quotient en cours.

Expansion arithmétique

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

$ ((expression))

L'expression est traitée comme si elle était entre guillemets, sauf qu'une double-citation dans l'expression n'est pas traitée spécialement. Le shell développe tous les jetons dans l'expression pour l'expansion des paramètres, la substitution de commandes et la suppression de devis.

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

Séparation d'espaces blancs (division de champs)

Après l'expansion des paramètres, la substitution de commandes et l'expansion arithmétique, le shell analyse les résultats des expansions et des substitutions qui ne se produisaient pas entre guillemets pour le fractionnement des champs, ce qui peut entraîner l'apparition de plusieurs champs.

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

Expansion de nom de fichier (génération de nom de fichier)

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

Shell Patterns

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 leurs significations spéciales s'ils sont cités. Lorsque la commande ou la substitution de variable est effectuée et que les guillemets ou les guillemets ne sont pas entre guillemets, la valeur de la variable ou la sortie de la commande est analysée pour 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 à un seul caractère. Un crochet gauche (`` ['') introduit une classe de caractères. La fin de la classe de caractères est indiquée par a (``] '') si le ``] '' est manquant alors le `` ['' correspond à un `` ['' plutôt que d'introduire 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 en utilisant un signe moins. 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 ``] '' dans une classe de caractères, faites-en le premier caractère listé (après le `! '' S'il y en a un). Pour inclure un signe moins, définissez-le comme le premier ou le dernier caractère répertorié

Builtins

Cette section répertorie les commandes intégrées qui sont intégrées car elles doivent effectuer certaines opérations qui ne peuvent pas être exécutées par un processus distinct. En plus de cela, il y a plusieurs autres commandes qui peuvent être intégrées pour l'efficacité (par exemple echo 1).

:

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

. fichier

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

alias [ nom [ = chaîne ... ]]

Si name = string est spécifié, le shell définit le nom de l'alias avec la chaîne de valeur. Si seul le nom est spécifié, la valeur du nom de l'alias est imprimée. Sans argument, l' alias builtin imprime les noms et les valeurs de tous les alias définis (voir unalias)

bg [ job] ...

Continuez les travaux spécifiés (ou le travail en cours si aucun travail n'est donné) en arrière-plan.

command commande arg ...

Exécutez la commande intégrée spécifiée. (Ceci est utile lorsque vous avez une fonction shell avec le même nom qu'une commande intégrée.)

cd [ répertoire ]

Passer 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 que la variable shell CDPATH est définie et que le nom du répertoire ne commence pas par une barre oblique, les répertoires listés dans CDPATH pour le répertoire spécifié. Le format de CDPATH est le même que celui de PATH. Dans un shell interactif, la commande cd affichera le nom du répertoire dans lequel il est réellement passé si ce n'est pas le même que le nom donné par l'utilisateur. Ceux-ci peuvent être différents soit parce que le mécanisme CDPATH a été utilisé, soit parce qu'un lien symbolique a été franchi.

chaîne eval ...

Concatène tous les arguments avec des espaces. Ensuite, ré-analyser et exécuter 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 vrai programme, pas un shell intégré ou une fonction). Toutes les redirections sur la commande exec sont marquées comme permanentes, afin qu'elles ne soient pas annulées lorsque la commande exec se termine.

exit [ exitstatus ]

Terminer 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é.

nom d' exportation ...

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 dés-exporter une variable est de l'annuler. Le shell permet de définir la valeur d'une variable en même temps qu'elle est exportée en écrivant

nom d'exportation = valeur

Sans arguments, la commande export liste 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 ]

Le fc builtin répertorie, ou édite et ré-exécute, les commandes préalablement entrées dans un shell interactif.

-e éditeur

Utilisez l'éditeur nommé par l'é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 null ou unset, la valeur de la variable EDITOR est utilisée. Si EDITOR est nul ou non défini, ed (1) est utilisé comme éditeur.

-l (ell)

Liste les commandes plutôt que d'invoquer un éditeur sur eux. Les commandes sont écrites dans la séquence indiquée par le premier et le dernier opérandes, affectés par - r avec chaque commande précédée du numéro de commande.

-n

Supprimer les numéros de commande lors de l'inscription avec -l.

-r

Inverser l'ordre des commandes listées (avec -l ou éditées (ni -l ni -s)

-s

Ré-exécutez la commande sans invoquer un éditeur.

premier

dernier

Sélectionnez les commandes à lister ou modifier. Le nombre de commandes précédentes accessibles est déterminé par la valeur de la variable HISTSIZE . La valeur de premier ou dernier ou les deux sont l'un des suivants:

[+] nombre

Un nombre positif représentant un numéro de commande; Les numéros de commande peuvent être affichés avec l'option -l .

-nombre

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

chaîne

Une chaîne indiquant la dernière commande entrée qui commence par cette chaîne. Si l'ancien opérande new n'est pas spécifié avec -s, la forme de chaîne du premier opérande ne peut pas contenir un signe égal incorporé.

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 qui sont accessibles.

fg [ job ]

Déplacez le travail spécifié ou le travail en cours vers l'avant-plan.

getopts optstring var

La commande POSIX getopts , à ne pas confondre avec getopt (1) de Bell Labs .

Le premier argument devrait être une série de lettres, chacune pouvant être suivie d'un deux-points pour indiquer que l'option nécessite un argument. La variable spécifiée est définie sur l'option analysée.

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

Le getin intégré peut être utilisé pour obtenir des options et leurs arguments à partir d'une liste de paramètres. Lorsqu'il est invoqué, getopts place la valeur de l'option suivante dans la liste de la variable shell spécifiée par var et son index dans la variable shell OPTIND Lorsque le shell est appelé , OPTIND est initialisé à 1. Pour chaque option qui nécessite un argument, le getopts intégré le placera dans la variable shell OPTARG Si une option n'est pas permise dans l' optstring alors OPTARG sera désactivé .

optstring est une chaîne de lettres d'options reconnues. Si une lettre est suivie d'un deux-points, on s'attend à ce que l'option ait un argument qui peut être séparé ou non de l'espace blanc. Si un caractère d'option n'est pas trouvé où prévu, getopts définira la variable var à un ``? '' Getopts désactive alors OPTARG et écrit la sortie à l'erreur standard. En spécifiant un deux-points comme premier caractère d' optstring, toutes les erreurs seront ignorées.

Une valeur différente de zéro est renvoyée lorsque la dernière option est atteinte. S'il n'y a pas d'arguments restants, getopts placera var dans l'option spéciale, `` - '' sinon, il mettra var à ``? ''

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

alors que getopts abc: f
faire
cas $ f dans
a | b) drapeau = $ f ;;
c) carg = $ OPTARG ;;
\?) echo $ USAGE; sortie 1 ;;
Esac
terminé
Maj `expr $ OPTIND - 1`

Ce code acceptera l'un des éléments suivants comme équivalents:

fichier de fichier cmd -acarg
cmd -a -c fichier de fichier arg
cmd -carg -a fichier fichier
cmd -a -carg - fichier fichier

hash -rv commande ...

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

Avec les arguments, la commande hash supprime les commandes spécifiées de la table de hachage (à moins qu'elles ne soient des fonctions), puis les localise. Avec l'option -v, hash imprime les emplacements des commandes telles qu'elles les trouvent. L'option -r force la commande hash à supprimer toutes les entrées de la table de hachage à l'exception des fonctions.

jobid [ job ]

Imprimez les identifiants de processus des processus dans le travail. Si l'argument du travail est omis, le travail en cours est utilisé.

emplois

Cette commande répertorie tous les processus d'arrière-plan qui sont des enfants du processus shell actuel.

pwd

Imprime le répertoire actuel. La commande intégrée peut différer du programme du même nom, car la commande intégrée mémorise le répertoire courant plutôt que de le recalculer à chaque fois. Cela le rend plus rapide. Toutefois, si le répertoire en cours est renommé, la version intégrée de pwd continuera à imprimer l'ancien nom du répertoire.

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

L'invite est imprimée si l'option -p est spécifiée et l'entrée standard est un terminal. Ensuite, une ligne est lue à partir de l'entrée standard. La nouvelle ligne arrière est supprimée de la ligne et la ligne est divisée comme décrit dans la section sur la division des mots ci-dessus, et les pièces sont affectées aux variables dans l'ordre. Au moins une variable doit être spécifiée. S'il y a plus de pièces que de variables, les pièces restantes (ainsi que les caractères dans IFS qui les ont séparées) sont affectées à la dernière variable. S'il y a plus de variables que de morceaux, les variables restantes sont assignées à la chaîne nulle. Le readin intégré indiquera le succès sauf si EOF est rencontré en entrée, auquel cas l'échec est renvoyé.

Par défaut, sauf si l'option -r est spécifiée, la barre oblique inversée `` \ '' agit comme un caractère d'échappement, provoquant le traitement littéral du caractère suivant. Si une barre oblique inverse est suivie d'une nouvelle ligne, la barre oblique inverse et la nouvelle ligne seront supprimées.

nom en lecture seule ...

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 désactivés par la suite. Le shell permet de définir la valeur d'une variable en même temps qu'elle est marquée en lecture seule en écrivant

nom en lecture seule = valeur

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.

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

La commande set effectue trois fonctions différentes.

Sans arguments, il liste les valeurs de toutes les variables du shell.

Si des options sont données, elle définit les indicateurs d'option spécifiés ou les efface comme décrit dans la section intitulée Traitement des listes d'arguments Sx.

La troisième utilisation de la commande set consiste à définir les valeurs des paramètres de position du shell sur les arguments spécifiés. Pour modifier les paramètres de position sans modifier les options, utilisez `` - '' comme premier argument à définir. Si aucun argument n'est présent, la commande set effacera tous les paramètres positionnels (équivalent à l'exécution de `` shift $ #. ''

valeur variable

Assigne une valeur à la variable. (En général, il vaut mieux écrire variable = valeur plutôt que d'utiliser setvar setvar est destiné à être utilisé dans des fonctions qui affectent des valeurs à des variables dont les noms sont passés en paramètres.)

décalage [ n ]

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

fois

Imprime les temps utilisateur et système accumulés pour le shell et pour les processus exécutés à partir du shell. L'état de retour est 0.

signal d' action de piège ...

Cause que le shell analyse et exécute l'action lorsque l'un des signaux spécifiés est reçu. Les signaux sont spécifiés par le numéro de signal. Si le signal est 0, l'action est exécutée à la sortie du shell. action peut être nulle ou `` - '' la première fait que le signal spécifié est ignoré et que le dernier fait que l'action par défaut est prise. Lorsque le shell décolle un sous - shell , il réinitialise les signaux capturés (mais non ignorés) à l'action par défaut. La commande trap n'a aucun effet sur les signaux ignorés lors de l'entrée dans le shell.

tapez [ nom ... ]

Interprétez chaque nom comme une commande et imprimez la résolution de la recherche de commande. Les résolutions possibles sont: mot clé shell, alias, shell intégré , commande, alias suivi et non trouvé. Pour les alias, l'extension d'alias est imprimée. Pour les commandes et les alias suivis, le chemin complet de la commande est imprimé.

ulimit [- H -S ] [- a -tfdscmlpn [ valeur ]]

Renseignez-vous sur ou fixez les limites strictes ou douces des processus ou définissez de nouvelles limites. Le choix entre une limite stricte (qu'aucun processus n'est autorisé à violer, et qui ne peut être levé une fois abaissé) et une limite douce (qui permet de signaler des processus mais pas nécessairement tués, et qui peuvent être levés) est faite avec ces drapeaux:

-H

définir ou se renseigner sur les limites strictes

-S

définir ou se renseigner sur 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 gagne.

La limite à interroger ou à définir est alors choisie en spécifiant l'un de ces drapeaux:

-une

montrer toutes les limites actuelles

-t

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

-F

affiche ou définit la limite sur le plus grand fichier qui peut être créé (dans des blocs de 512 octets)

-ré

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

-s

affiche ou définit la limite de la taille de la pile d'un processus (en kilo-octets)

-c

affiche ou définit la limite de la plus grande taille de vidage de l'image centrale (en blocs de 512 octets)

-m

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

-l

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

-p

afficher ou définir la limite du nombre de processus que cet utilisateur peut avoir en même temps

-n

afficher ou définir la limite sur les fichiers numériques qu'un processus peut ouvrir en même temps

Si aucun d'entre eux n'est spécifié, c'est la limite de taille de fichier qui est affichée ou définie. Si la 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éfinissez la valeur de umask (voir umask (2)) sur la valeur octale spécifiée. Si l'argument est omis, la valeur umask est imprimée.

unalias [- a ] [ nom ]

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

nom non renseigné ...

Les variables et fonctions spécifiées sont non définies et non exportées. Si un nom donné correspond à la fois à une variable et à une fonction, la variable et la fonction sont toutes deux désactivées.

attends [ job ]

Attendez que le travail spécifié se termine et renvoyez le statut de sortie du dernier processus dans le travail. Si l'argument est omis, attendez que tous les travaux se terminent et que l'état de sortie soit zéro.

Modification de la ligne de commande

Lorsque sh est utilisé de manière interactive à partir d'un terminal, la commande en cours et l'historique des commandes (voir fc dans Sx Builtins) peuvent être édités en utilisant l'édition de ligne de commande vi-mode. Ce mode utilise des commandes, décrites ci-dessous, similaires à un sous-ensemble de celles décrites dans la page vi man. La commande `set '-o vi active l'édition du mode vi et place sh dans le mode d'insertion vi. Lorsque vi-mode est activé, sh peut être commuté entre le mode insertion et le mode commande. L'éditeur n'est pas décrit en entier ici, mais sera dans un document ultérieur. C'est similaire à vi: en tapant Aq ESC, vous passerez en mode de commande VI. Frapper le retour Aq en mode commande passera la ligne au shell.

Important: Utilisez la commande man ( % man ) pour voir comment une commande est utilisée sur votre ordinateur.