Quels sont les opérateurs de contrôle et de redirection du Shell ?

Je vois souvent des tutoriels en ligne qui relient diverses commandes avec différents symboles. Par exemple :

command1 |  command2
command1 &  command2
command1 || command2    
command1 && command2

D'autres semblent connecter des commandes à des fichiers :

command1  > file1
command1  >> file1

Quelles sont ces choses? Comment s'appellent-ils ? Que font-ils? Y en a-t-il plus ?

Méta fil de discussion sur cette question..

Réponse acceptée :

Ceux-ci sont appelés opérateurs shell et oui, il y en a plus. Je vais donner un bref aperçu des plus courants parmi les deux grandes classes, les opérateurs de contrôle et les opérateurs de redirection, et comment ils fonctionnent par rapport au shell bash.

A. Opérateurs de contrôle

Définition POSIX

Dans le langage de commande shell, un jeton qui exécute une fonction de contrôle.
Il s'agit de l'un des symboles suivants :
&   &&   (   )   ;   ;;   <newline>   |   ||

Et |& en bash.

Un ! n'est pas un opérateur de contrôle mais un Mot Réservé. Il devient un NON logique [opérateur de négation] à l'intérieur des expressions arithmétiques et à l'intérieur des constructions de test (tout en nécessitant toujours un délimiteur d'espace).

A.1 Terminaisons de liste

; :exécutera une commande après la fin d'une autre, quel que soit le résultat de la première.
```
command1 ; command2
```
Première command1 est exécuté, au premier plan, et une fois terminé, command2 sera exécuté.

Une nouvelle ligne qui n'est pas dans un littéral de chaîne ou après certains mots-clés n'est pas équivalent à l'opérateur point-virgule. Une liste de ; les commandes simples délimitées sont toujours une liste – comme dans le parseur du shell doit continuer à lire les commandes simples qui suivent un ; commande simple délimitée avant l'exécution, alors qu'un retour à la ligne peut délimiter une liste entière de commandes - ou une liste de listes. La différence est subtile, mais compliquée :étant donné que le shell n'a pas d'impératif préalable pour lire les données après une nouvelle ligne, la nouvelle ligne marque un point où le shell peut commencer à évaluer les commandes simples qu'il a déjà lues, alors qu'un ; pas le point-virgule.
& :Cela exécutera une commande en arrière-plan, vous permettant de continuer à travailler dans le même shell.
```
 command1 & command2
```
Ici, command1 est lancé en arrière-plan et command2 commence à s'exécuter immédiatement au premier plan, sans attendre la command1 pour quitter.

Une nouvelle ligne après command1 est facultatif.

A.2 Opérateurs logiques

&& :Utilisé pour construire des listes ET, il vous permet d'exécuter une commande uniquement si une autre est sortie avec succès.
```
 command1 && command2
```
Ici, command2 s'exécutera après command1 a terminé et seulement si command1 a réussi (si son code de sortie était 0). Les deux commandes sont exécutées au premier plan.

Cette commande peut aussi s'écrire
```
if command1
then command2
else false
fi
```
ou simplement if command1; then command2; fi si le statut de retour est ignoré.
|| :Utilisé pour construire des listes OU, il permet d'exécuter une commande uniquement si une autre est sortie sans succès.
```
 command1 || command2
```
Ici, command2 ne s'exécutera que si command1 a échoué (s'il a renvoyé un état de sortie autre que 0). Les deux commandes sont exécutées au premier plan.

Cette commande peut aussi s'écrire
```
if command1
then true
else command2
fi
```
ou de manière plus courte if ! command1; then command2; fi .

Notez que && et || sont associatifs à gauche ; voir Priorité des opérateurs logiques shell &&, || pour plus d'informations.
! :Il s'agit d'un mot réservé qui agit comme l'opérateur "non" (mais doit avoir un délimiteur), utilisé pour annuler l'état de retour d'une commande - renvoie 0 si la commande renvoie un état différent de zéro, renvoie 1 si elle renvoie l'état 0 . Également un NON logique pour le test utilitaire.
```
! command1

[ ! a = a ]
```
Et un véritable opérateur NOT dans les expressions arithmétiques :
```
$ echo $((!0)) $((!23))
1 0
```

A.3 Opérateur de tuyauterie

| :L'opérateur pipe, il passe la sortie d'une commande en entrée à une autre. Une commande créée à partir de l'opérateur de canal est appelée un pipeline.
```
 command1 | command2
```
Toute sortie imprimée par command1 est passé en entrée à command2 .
|& :Ceci est un raccourci pour 2>&1 | en bash et zsh. Il transmet à la fois la sortie standard et l'erreur standard d'une commande comme entrée à une autre.
```
command1 |& command2
```

A.4 Autre ponctuation de la liste

;; est utilisé uniquement pour marquer la fin d'une instruction case. Ksh, bash et zsh prennent également en charge ;& pour passer au cas suivant et ;;& (pas dans ATT ksh) pour continuer et tester les cas suivants.

Connexe :Lister les fichiers auxquels un programme accède ?

( et ) sont utilisés pour regrouper des commandes et les lancer dans un sous-shell. { et } groupez également les commandes, mais ne les lancez pas dans un sous-shell. Voir cette réponse pour une discussion sur les différents types de parenthèses, crochets et accolades dans la syntaxe shell.

B. Opérateurs de redirection

Définition POSIX de l'opérateur de redirection

Dans le langage de commande shell, un jeton qui exécute une fonction de redirection. C'est l'un des symboles suivants :
<     >     >|     <<     >>     <&     >&     <<-     <>

Ceux-ci vous permettent de contrôler l'entrée et la sortie de vos commandes. Ils peuvent apparaître n'importe où dans une simple commande ou peuvent suivre une commande. Les redirections sont traitées dans l'ordre dans lequel elles apparaissent, de gauche à droite.

< :Donne une entrée à une commande.
```
command < file.txt
```
Ce qui précède exécutera la command sur le contenu de file.txt .
<> :idem ci-dessus, mais le fichier est ouvert en lecture+écriture mode au lieu de lecture seule :
```
command <> file.txt
```
Si le fichier n'existe pas, il sera créé.

Cet opérateur est rarement utilisé car les commandes ne font généralement que lire depuis leur stdin, bien que cela puisse être utile dans un certain nombre de situations spécifiques.
> :dirige la sortie d'une commande dans un fichier.
```
command > out.txt
```
Ce qui précède enregistrera la sortie de command comme out.txt . Si le fichier existe, son contenu sera écrasé et s'il n'existe pas, il sera créé.

Cet opérateur est également souvent utilisé pour choisir si quelque chose doit être imprimé sur l'erreur standard ou sur la sortie standard :
```
command >out.txt 2>error.txt
```
Dans l'exemple ci-dessus, > redirigera la sortie standard et 2> redirige l'erreur standard. La sortie peut également être redirigée à l'aide de 1> mais, puisque c'est la valeur par défaut, le 1 est généralement omis et s'écrit simplement sous la forme > .

Donc, pour exécuter la command sur file.txt et enregistrez sa sortie dans out.txt et tout message d'erreur dans error.txt vous exécuteriez :
```
command < file.txt > out.txt 2> error.txt
```
>| :fait la même chose que > , mais écrasera la cible, même si le shell a été configuré pour refuser l'écrasement (avec set -C ou set -o noclobber ).
```
command >| out.txt
```
Si out.txt existe, la sortie de la command remplacera son contenu. S'il n'existe pas, il sera créé.
>> :fait la même chose que > , sauf que si le fichier cible existe, les nouvelles données sont ajoutées.
```
command >> out.txt
```
Si out.txt existe, la sortie de la command y sera ajouté, après tout ce qui s'y trouve déjà. S'il n'existe pas, il sera créé.
>& :(selon la spécification POSIX) lorsqu'il est entouré de chiffres (1>&2 ) ou - sur le côté droit (1>&- ) soit redirige un seul descripteur de fichier ou le ferme (>&- ).

Un >& suivi d'un numéro de descripteur de fichier est un moyen portable de rediriger un descripteur de fichier, et >&- est un moyen portable de fermer un descripteur de fichier.

Si le côté droit de cette redirection est un fichier, veuillez lire l'entrée suivante.
>& , &> , >>& et &>> :(lire ci-dessus également) Rediriger à la fois l'erreur standard et la sortie standard, en remplaçant ou en ajoutant, respectivement.
```
command &> out.txt
```
Erreur standard et sortie standard de la command sera enregistré dans out.txt , en écrasant son contenu ou en le créant s'il n'existe pas.
```
command &>> out.txt
```
Comme ci-dessus, sauf que si out.txt existe, la sortie et l'erreur de command lui sera annexé.

Le &> la variante provient de bash , tandis que le >& la variante vient de csh (des décennies plus tôt). Ils sont tous les deux en conflit avec d'autres opérateurs de shell POSIX et ne doivent pas être utilisés dans sh portable scripts.
< :Un document ici. Il est souvent utilisé pour imprimer des chaînes multilignes.
```
 command << WORD
     Text
 WORD
```
Ici, command prendra tout jusqu'à ce qu'il trouve la prochaine occurrence de WORD , Text dans l'exemple ci-dessus, comme input . Tandis que WORD est souvent EoF ou des variantes de celle-ci, il peut s'agir de n'importe quelle chaîne alphanumérique (et pas seulement) que vous aimez. Lorsque WORD est cité, le texte dans le document ici est traité littéralement et aucune expansion n'est effectuée (sur les variables par exemple). S'il n'est pas entre guillemets, les variables seront développées. Pour plus de détails, consultez le manuel de bash.

Si vous souhaitez diriger la sortie de la command << WORD ... WORD directement dans une ou plusieurs autres commandes, vous devez mettre le tube sur la même ligne que << WORD , vous ne pouvez pas le mettre après le mot de fin ou sur la ligne suivante. Par exemple :
```
 command << WORD | command2 | command3...
     Text
 WORD
```
<<< :Ici des chaînes, similaires aux documents ici, mais destinées à une seule ligne. Ceux-ci n'existent que dans le port Unix ou rc (d'où il provient), zsh, certaines implémentations de ksh, yash et bash.
```
command <<< WORD
```
Tout ce qui est donné comme WORD est développé et sa valeur est transmise en entrée à la command . Ceci est souvent utilisé pour transmettre le contenu de variables comme entrée à une commande. Par exemple :
```
 $ foo="bar"
 $ sed 's/a/A/' <<< "$foo"
 bAr
 # as a short-cut for the standard:
 $ printf '%sn' "$foo" | sed 's/a/A/'
 bAr
 # or
 sed 's/a/A/' << EOF
 $foo
 EOF
```

Quelques autres opérateurs (>&- , x>&y x<&y ) peut être utilisé pour fermer ou dupliquer des descripteurs de fichiers. Pour plus de détails à leur sujet, veuillez consulter la section correspondante du manuel de votre shell (ici par exemple pour bash).

En relation :Comment différer l'expansion variable ?

Cela ne couvre que les opérateurs les plus courants des shells de type Bourne. Certains shells ont leurs propres opérateurs de redirection supplémentaires.

Ksh, bash et zsh ont également des constructions <(…) , >(…) et =(…) (ce dernier en zsh seul). Ce ne sont pas des redirections, mais des substitutions de processus.