Eclats de vers : Ordina 04 : Shell

Les espaces ont une fonction essentielle : séparer les chaînes de caractères que le shell va considérer comme des mots. On a vu par exemple que dans une ligne de commande, les arguments sont des mots séparés par un espace.

Lorsqu'on souhaite signaler au shell qu'une chaîne de caractères contenant des espaces doit malgré tout être considérée comme un seul mot, on dispose de trois techniques.

La première méthode utilise le préfixe « \ » devant chaque espace. Exemple :

Chaîne\ de\ caractères\ vue\ comme\ un\ seul\ mot

La deuxième méthode entoure la chaîne de guillemets simples :

'Chaîne de caractères vue comme un seul mot'

La troisième méthode entoure la chaîne de guillemets doubles :

"Chaîne de caractères vue comme un seul mot"

Une précommande modifie la façon dont le shell interprète la ligne. Comme son nom l'indique, on la place avant la commande :

/precommande/ /commande/ /argument(s)/

Une commande interne du shell est appelée builtin, par opposition aux commandes externes du système d'exploitation. Lorsqu'il y a un risque d'ambiguité, les précommandes suivantes permettent de préciser quel type de commande on souhaite exécuter :

Il existe plusieurs méthodes pour transformer les caractères magiques en caractères ordinaires. La première méthode utilise le préfixe « \ »:

\/caractère_magique/

La deuxième méthode utilise des guillemets simples sur une chaîne contenant des caractères magiques :

'/chaine_avec_caractères_magiques/'

La troisième méthode utilise des guillemets doubles :

"/chaine_avec_caractères_magiques/"

ce qui a pour effet d'annuler l'effet spécial de certains caractères (dont les espaces) mais pas de tous. Par exemple, le « $ » est toujours actif.

Les accolades permettent de jongler avec les variantes d'un mot. Ainsi :

{/Chaine/,/Variante/}

est équivalent à :

/Chaine/   /Variante/

Plus généralement :

/abc/{/Chaine/,/Variante/}/xyz/

est équivalent à :

/abc//Chaine//xyz/
 
/abc//Variante//xyz/

Un exemple courant d'utilisation est de renommer un fichier vers un nom proche. Ainsi, pour modifier l'extension .txt en .sh, on fait :

mv /fichier/.{txt,sh}

qui sera étendu par le shell en :

mv /fichier/.txt /fichier/.sh

Les accolades permettent également de générer une plage de nombres entiers. On utilise alors la forme :

{/M/../N/}

Un fichier est un objet destiné à contenir des données.

Un répertoire est un objet destiné à contenir d'autres objets : fichiers, sous-répertoires, etc.

Un lien symbolique est un objet destiné à contenir une adresse permettant d'accéder à un autre objet : fichier, répertoire, etc. On dit que le lien symbolique référence l'objet auquel il permet d'accéder.

Un lien dur est un fichier synonyme d'un autre fichier : les deux noms référencent le même fichier.

Le répertoire racine est symbolisé par :

/

Le répertoire courant est désigné par un point :

.

Le répertoire parent est le répertoire contenant le répertoire courant. On le désigne par deux points consécutifs :

..

Le tilde désigne le répertoire personnel (souvent home//utilisateur) de l'utilisateur courant :

~

Le symbole :

~/utilisateur/

désigne le répertoire personnel d'un utilisateur donné.

Le zsh a également comme convention de désigner par :

~+

le répertoire actuel et par :

~-

le répertoire d'où l'on vient.

La commande cd permet d'accéder à un sous-répertoire Rép du répertoire courant :

cd /Rép/

Il est possible de se déplacer de plusieurs niveaux d'un coup. La commande :

cd /Rép_1///Rép_2/

accède au sous-répertoire Rép₂ du sous-répertoire Rép₁ du répertoire courant. On généralise cette commande par :

cd /Rép_1///Rép_2///...///Rép_N/

On parle pour :

/Rép_1///Rép_2///...///Rép_N/

de chemin relatif, car il dépend du répertoire courant. Il est également possible de désigner le chemin de répertoires en partant de la racine du système de fichier. Il suffit pour cela de faire précéder le chemin du symbole / désignant la racine :

cd //Rép_1///Rép_2///...///Rép_N/

On parle pour :

//Rép_1///Rép_2///...///Rép_N/

de chemin absolu, car il ne dépend pas du répertoire courant.

On se déplace vers le répertoire parent par :

cd ..

On se déplace vers le répertoire racine par :

cd /

On se déplace vers le répertoire d'où l'on vient par :

cd -

La commande :

pwd

affiche le répertoire courant.

La pile de répertoires permet de conserver les répertoires fréquemment utilisés. Le répertoire courant sera toujours adapté au répertoire situé au sommet de la pile.

On ajoute un répertoire au sommet de la pile par :

pushd /répertoire/

Cette commande a donc également pour effet de se déplacer vers le répertoire donné.

On supprime le répertoire situé au sommet de la pile par :

popd

Cette commande a également pour effet de se déplacer vers le répertoire qui était situé juste sous le sommet de la pile et qui devient à présent le sommet.

On affiche le contenu de la pile par :

dirs -v

On se déplace au /N/^ème répertoire en partant du sommet de la pile par :

pushd +/N/

On se déplace au /N/^ème répertoire en partant du bas de la pile par :

pushd -/N/

Chaque répertoire de la pile est également accessible par :

cd ~/N/

où N est le numéro du répertoire donné par la sortie de « dirs -v »

La commande :

ls

affiche le contenu du répertoire courant : fichiers, sous-répertoires, liens, etc. Par défaut, elle n'affiche pas les objets cachés, qui commencent par convention par un point dans les systèmes Unix. L'option -a permet d'afficher tous les objets, masqués ou non :

ls -a

On peut donner en argument le nom du répertoire dont on souhaite afficher le contenu :

ls /répertoire/

L'option -l affiche plus d'information :

ls -l

L'option -t trie par date de dernière modification :

ls -t

L'option -d permet d'afficher seulement les informations sur un répertoire, sans en explorer le contenu :

ls -d /répertoire/

On la combine souvent avec l'option -l :

ls -l -d /répertoire/

Les options pouvant se condenser devant un unique tiret, on a la forme équivalente :

ls -ld /répertoire/

La commande :

mkdir /répertoire/

crée un répertoire. L'option -p permet de créer plusieurs niveaux de répertoires d'un coup :

mkdir -p /Rép_1///Rép_2///...///Rép_N/

La commande cp permet de copie un fichier source vers un fichier ou répertoire destination :

cp /source/ /destination/

Cet exemple copie le contenu d'un fichier dans un autre :

cp /fichier_1/ /fichier_2/

Cet exemple copie un fichier dans un répertoire donné :

cp /fichier/ /répertoire/

Cet exemple copie un fichier provenant d'un autre répertoire dans le répertoire courant :

cp /chemin///fichier/ .

Cet exemple copie un fichier dans le répertoire parent :

cp /fichier/ ..

Par défaut, la commande cp n'agit que sur des fichiers. L'option -R lui demande d'agir récursivement sur les répertoires, les sous-répertoires, et ainsi de suite :

cp -R /répertoire-source/ /répertoire-destination/

La commande mv permet de renommer ou déplacer un fichier. Sa syntaxe est similaire à celle de cp :

mv /source/ /destination/

Cet exemple renomme un fichier :

mv /fichier_1/ /fichier_2/

Cet exemple déplace un fichier dans un répertoire donné :

mv /fichier/ /répertoire/

Cet exemple déplace un fichier provenant d'un autre répertoire dans le répertoire courant :

mv /chemin///fichier/ .

Cet exemple déplace un fichier dans le répertoire parent :

mv /fichier/ ..

La commande rm efface des fichiers :

rm /fichier(s)/

L'option -r lui demande d'agir récursivement sur des répertoires :

rm -r /répertoire(s)/

L'option -f lui demande de ne pas demander confirmation :

rm -f /fichier(s)/
rm -rf /répertoire(s)/

Pour être plus précis, la commande rm n'efface pas les contenus des fichiers sur le disque, mais uniquement les entrée correspondantes dans la table du système de fichier.

Sous les systèmes UNIX, un fichier appartient à un propriétaire et à un groupe. On peut modifier ces paramètres via la commande :

chown /propriétaire/:/groupe/ /fichier/

Attention toutefois, une fois que l'on n'est plus propriétaire du fichier, il n'y a plus de retour en arrière possible : seul le propriétaire d'un fichier et le super-utilisateur root peuvent modifier propriétaire et groupe d'un fichier.

Les principales permissions attachées à un fichier sont :

• r : Droit de lecture
• w : Droit d'écriture (de modification)
• x : Droit d'exécution

Ces permissions peuvent être données ou retirées :

• u : au propriétaire
• g : aux membres du groupe
• o : aux autres

Les permissions s'ajoutent au moyen de la commande :

chmod /qui/+/quoi/ /fichier/

ou se retirent au moyen de la commande :

chmod /qui/-/quoi/ /fichier/

où :

• qui = u, g ou o
• quoi = r, w ou x

Ainsi, la commande :

chmod g+w /fichier/

donne les droits d'écriture aux membres du groupes.

Les attributs permettent de configurer finement certains fichiers Ils se modifient avec la commande :

chattr

qui utilise une syntexe +attribut/-attribut analogue à chmod.

La commande mount permet de monter un système de fichiers dans le répertoire d'un autre. Ce dernier répertoire est appelé point de montage :

mount /systèmeDeFichiers/
 /pointDeMontage/

Les systèmes de fichiers sont généralement accessible par des fichiers magiques situés dans le répertoire /dev :

mount /dev//systèmeDeFichiers/
 /pointDeMontage/

Un fichier image est un fichier contenant un système de fichiers. L'option -o loop permet de monter un fichier image :

mount -o loop /fichierImage/
 /pointDeMontage/

Que faire si l’on souhaite manipuler plusieurs images en même temps ? On utilise losetup :

losetup -f

qui affiche le premier périphérique de boucle libre :

/dev/loop0

On lie ensuite ce résultat au fichier image par :

losetup /dev/loop0 /fichierImage/

Il ne reste plus qu'à monter ce périphérique :

mount /dev/loop0 /pointDeMontage/

Si on souhaite recommencer avec une autre image :

losetup -f

qui affiche le premier périphérique de boucle libre :

/dev/loop1

On lie ensuite ce résultat au fichier image par :

losetup /dev/loop1 /autreFichierImage/

Il ne reste plus qu'à monter ce périphérique :

mount /dev/loop1 /pointDeMontage/

La structure :

/commande1/ && /commande2/

exécute commande2 uniquement si commande1 réussit.

La structure :

/commande1/ || /commande2/

exécute commande2 uniquement si commande1 échoue.

La structure :

/commande1/ &&
/commande2/ ||
/commande3/

exécute commande2 si commande1 réussit. Si commande1 ou commande2 échoue, commande3 sera exécutée.

Par exemple, la commande :

wait %/nom/ && /commande/

attend la fin du job dont le nom contient nom et exécute commande ensuite.

La ligne suivante demande à la commande de lire son entrée standard dans un fichier :

/commande/ < /fichier/

On dit alors que l'entrée standard est redirigée vers le fichier.

On peut demander à une commande d'écrire ses données de sortie standard dans un fichier :

/commande/ > /fichier/

Le fichier est écrasé si il existe déjà. On dit que la sortie standard est redirigée vers le fichier.

On peut demander à une commande d'écrire ses données de sortie et d'erreur standard dans un fichier :

/commande/ >& /fichier/

La ligne suivante produit le même résultat :

/commande/ &> /fichier/

On peut demander à une commande d'écrire ses données de sortie et d'erreur standard en ajout à la fin d'un fichier :

/commande/ >>& /fichier/

La ligne suivante produit le même résultat :

/commande/ &>> /fichier/

La sortie standard d'une commande peut être redirigée vers l'entrée standard d'une autre commande, le flux de données passant de la première à la seconde :

/commande-1/ | /commande-2/

Plusieurs commandes peuvent être chaînées ainsi :

/commande-1/ | /commande-2/ |
/.../ | /commande-N/

Les données passent donc d'une commande à l'autre, un peu comme l'eau circule dans une canalisation. Cette analogie explique la dénomination anglaise de « pipe », qui peut se traduire par « tube ».

Les canaux d'entrée et de sortie par défaut ont des codes :

• 0 : entrée standard
• 1 : sortie standard
• 2 : erreur standard

Les autres canaux (de 3 à 9) sont des canaux auxiliaires.

La commande suivante :

/commande/ <> /fichier/

ouvre le fichier en lecture et en écriture tout en redirigeant l'entrée vers le fichier. Lorsqu'on la combine avec une redirection de la sortie standard vers l'entrée, la commande va lire et écrire ses données dans le même fichier :

/commande/ <> /fichier/ 1>&0

Un multios est une redirection multiple.

On peut rediriger l'entrée vers plusieurs fichiers :

/commande/
 < /fichier-1/
 < /fichier-2/

Les fichiers sont lus dans l'ordre de leur apparition.

On peut rediriger la sortie vers plusieurs fichiers :

/commande/
 > /fichier-1/
 > /fichier-2/

La sortie est alors écrite dans chaque fichier vers lequel on redirige.

On peut combiner entrée et pipe. La ligne suivante demande à la seconde commande de lire ses données dans la sortie de la première commande, puis dans le fichier :

/commande-1/ | /commande-2/
	 < /fichier/

On peut combiner sortie et pipe. La ligne suivante demande à la première commande d'écrire ses données dans le fichier et de les envoyer à l'entrée de la seconde commande :

/commande-1/ > /fichier/ |
/commande-2/

On peut déclarer une variable par :

typeset /variable/

L'instruction unset permet de donner un statut indéfini à une variable :

unset /variable/

L'instruction :

/variable/=/valeur/

définit ou modifie la valeur contenue dans une variable. L'accès au contenu de cette variable se fait via la syntaxe :

$/variable/

Il peut être souhaitable de délimiter clairement le nom d'une variable, surtout si celle-ci est entourée de texte. On utilise alors des accolades :

${/variable/}

Supposons que :

/variable/=/contenu/

On souhaite que l'expression :

/abc/ $/variable/ /xyz/

soit considérée comme un seul mot malgré les espaces. On est alors tenté d'utiliser les guillemets simples :

print '/abc/ $/variable/ /xyz/'

mais il faut savoir que cette méthode annule l'effet de tous les caractères magiques et donc des « $ ». La commande précédente affichera donc littéralement :

/abc/ $/variable/ /xyz/

Si on souhaite afficher le contenu de la variable, on utilisera les guillemets doubles. La commande : :

print "/abc/ $/variable/ /xyz/"

remplacera la variable par son contenu avant d'afficher :

/abc/ /contenu/ /xyz/

Une variable contenant des espaces, du type :

/variable/="/abc/ /def/ /.../ /uvw/"

est considérée comme un seul mot à cause des guillemets doubles, d'ailleurs nécessaires à la définition. On peut cependant demander au shell de considérer le contenu de la variable comme une liste de mots. On utilise alors la syntaxe :

${=/variable/}

Lorsque le séparateur n'est pas un espace, on peut le signaler par :

${(s//séparateur//)/variable/}

On dit qu'une variable en référence une autre lorsqu'elle contient le nom d'une autre variable. La syntaxe :

${(P)/variable/}

s'évalue au contenu de la variable que contient variable. Pour y voir plus clair, supposons que :

/variable_cible/=/contenu/
/variable_référence/=/variable_cible/

La commande :

print $/variable_référence/

affiche le texte :

/variable_cible/

tandis que  :

print ${(P)/variable/}

affiche le texte :

/contenu/

Par défaut, le shell n'interprète qu'une seule fois les motifs magiques d'une ligne de commande. Donc, si :

/variable/=/contenu/

La syntaxe :

$/variable/

sera simplement transformée en :

/contenu/

sans étape suplémentaire, et ce, même si le contenu de la variable contient des motifs réinterprétables. Il est cependant possible de demander au shell de réinterpréter le contenu de la variable. Cela se fait au moyen de la syntaxe :

${(e)/variable/}

Par exemple, si :

/variable_cible/=/contenu/
/variable/='$/variable_cible/'

la commande :

print $/variable/

affichera :

$/variable_cible/

tandis que :

print ${(e)/variable/}

affichera :

/contenu/

La commande :

print $(( [#/base/] /variable/ ))

exprime la valeur numérique contenue dans variable dans la base base.

Une substitution remplace la première occurence d'un motif par une chaîne donnée.

Une substitution globale remplace toutes les occurences d'un motif par une chaîne donnée.

On peut utiliser des fanions afin de demander d'afficher la partie supprimée ou la partie restante :

La forme en (R) est en général inutile, puisqu'elle correspond au cas par défaut, mais peut être utile dans certains cas.

Certaines expressions permettent de spécifier une valeur alternative si la variable est vide ou non définie.

Il est possible d'annuler l'effet magique de cartains caractères contenus dans une variable.

Si on active l'option :

setopt extendedglob

on dispose en plus des motifs de globbing suivant :

Les fanions s'insèrent aux motifs de globbing pour modifier leur comportement.

Les rétro-références peuvent être utilisées dans :

• les remplacements si le motif modifié dépend du motif initial
• les motifs où des sous-motifs doivent être répétés

L'activation des rétro-référence remplit le tableau $match avec chaque sous-motif inclus dans des parenthèses.

Lorsqu'une variable contient un motif de globbing, ce dernier n'est par défaut pas activé. On peut toutefois provoquer la génération des noms de fichiers via l'expression :

${~/variable/}

Ainsi, la suite :

/variable/=*
print $/variable/

affiche le caractère « * » tandis que la suite :

/variable/=*
print ${~/variable/}

affiche la liste de tous les fichiers du répertoire.

La précommande noglob permet de désactiver la génération de fichiers pour la commande qui suit :

noglob /commande/ /globe-désactivé/

On peut déclarer une variable comme étant un tableau par :

typeset -a /tableau/

La syntaxe :

/tableau/=(/element_1 element_2 ... element_N/)

définit ou modifie un tableau.

On accède à un élément d'un tableau par :

/tableau/[/indice/]

Précisons que cet accès peut servir autant en lecture :

print $/tableau/[/indice/]

qu'en écriture :

/tableau/[/indice/]=/valeur/

Les indices positifs sont comptés à partir de 1 au début du tableau et les indices négatifs à partir de la fin. L'élément :

$/tableau/[2]

est donc le deuxième et :

$/tableau/[-2]

l'avant-dernier.

On peut accéder à un sous-tableau contenant les éléments M à N :

$/tableau/[/M/,/N/]

Notons la notation particulière :

$/tableau/[*]

décrivant tout le tableau, et donc équivalente à :

$/tableau/[1,-1]

Une variable contenant des espaces, du type :

/variable/="/abc/ /def/ /.../ /uvw/"

peut être éclatée en un tableau de mots au moyen la syntaxe :

${(z)/variable/}

On obtient le même effet en éclatant en mots puis en insérant la liste dans les parenthèses servant à définir la valeur d'un tableau :

( ${=/variable/} )

Supposons que :

/tableau/=( /abc/ /def/ /.../ /uvw/ )

On peut fusionner les éléments d'un tableau en une seule chaîne de caractère au moyen de la syntaxe :

${(j//Séparateur//)/tableau/}

Le résultat s'écrira :

"/abc//Séparateur//def//Séparateur//...//Séparateur//uvw/"

Il est possible de former un tableau à partir d'un fichier, à raison d'un élément par ligne. On utilise la syntaxe :

/tableau/=( ${(f)"$(< /fichier/)"} )

Supposons que :

/tableau_1/=(/T_1_ T_2_ T_3_/)
/tableau_2/=(/U_1 U_2/)

La commande :

print ${^/tableau_1/}${^/tableau_2/}

affiche :

/T_1_//U_1/ /T_1_//U_2/ /T_2_//U_1/ /T_2_//U_2/ /T_3_//U_1/ /T_3_//U_2/

Supposons que :

/tableau/=(/ELT_1 ELT_2 ... ELT_N/)

La commande :

print "/abc/${/tableau/}/xyz/"

affiche sans surprise :

/abc//ELT_1 ELT_2  ... ELT_N//xyz/

Il est possible de reproduire le contexte pour chaque élément du tableau. La commande :

print "/abc/${^/tableau/}/xyz/"

affiche :

/abc//ELT_1//xyz/ /abc</bleu>/ELT_2//xyz/ /.../ /abc//ELT_N//xyz/ /.../

On peut utiliser la génération de fichiers pour remplir un tableau via la syntaxe :

/tableau/=( /globbing/ )

Les éléments du tableau seront alors les fichiers générés.

La plupart des modificateurs agissent aussi sur les tableaux. On utilise alors la syntaxe :

${/tableau/:/modificateur/}

Le modificateur est alors appliqué à chaque élément du tableau.

On peut déclarer une variable comme étant un dictionnaire par :

typeset -A /dictionnaire/

La syntaxe :

/dictionnaire/=(/clé_1 val_1 clé_2 val_2 .../)

définit ou modifie un dictionnaire.

On accède à un élément d'un dictionnaire par :

/dictionnaire/[/clé/]

Précisons que cet accès peut servir autant en lecture :

print $/dictionnaire/[/clé/]

qu'en écriture :

/dictionnaire/[/clé/]=/valeur/

Une variable ordinaire n'est accessible que depuis le shell courant. Pour qu'une variable soit également accessible dans les sous-processus lancés par le shell courant, il faut la déclarer en utilisant le mot clef export :

export /variable/=/valeur/

Une telle variable est nommée variable d'environnement. Voici quelques exemples de variables d'environnements :

Le shell zsh associe un tableau aux variables d'environnement contenant des chemins d'accès. Les deux-points y sont remplacés par des espaces. La syntaxe :

path=/cheminA/:/cheminB/:/.../

est équivalente à :

export PATH=/cheminA/:/cheminB/:/.../

Autres exemples :

Pour lancer un script avec son chemin absolu :

//chemin-absolu///script/

Pour lancer un script du répertoire courant :

.//script/

Le plus simple est encore de placer le script dans un répertoire contenu dans la variable d'environnement $PATH. On le lance alors simplement par :

/script/

La commande eval exécute une chaine de caractère, mono ou multiligne. Exemple :

/var/=`cat /fichier/`
eval $/var/

Pour lancer un script, le shell crée un nouveau processus dans lequel le script est exécuté. Si on désire exécuter le script dans le processus courant, on fait :

source /chemin///script/

ou, si le script est dans $PATH :

source /script/

Par défaut, le shell exécute un script en lançant une nouvelle instance de lui-même qui va exécuter les commandes contenues dans le fichier. On peut toutefois demander que l'exécution du script soit effectuée par un interpréteur de commande donné. On insère alors la syntaxe :

#!/interpréteur/

à la première ligne du fichier. En fait, les caractères « #! » doivent être les deux premiers du fichier. Voici quelques exemples d'interpréteurs de commandes de type shell :

et quelques exemples d'autres langages de script :

Une variable utilisée dans un script peut recevoir une valeur dans la ligne de commande appelante :

/variable/=/valeur/   /script/

La variable est alors accessible dans le code du script et uniquement dans celui-ci.

Tout comme n'importe quelle commande, un script peut être appelé avec des arguments :

/script/ /argument_1/ /argument_2/ /.../ /argument_N/

Dans le code du script, ces arguments sont disponibles via des variables particulières :

Les valeurs correspondant à ces variables s'obtiennent, comme pour n'importe quelle variable, en ajoutant un « $ » devant leur nom :

La commande :

exec /commande/

remplace le shell exécutant le script par commande. Ce peut être utile afin d'éviter la création d'un processus superflu. Le cas typique est celui du script uniligne, ou alors en lançant la dernière commande du script :

#!/bin/sh
...
exec /commande/

L'instruction exit termine le script et renvoie un code de sortie N :

exit /N/

où N est un entier compris entre 0 et 255.

Le groupement par parenthèses crée un sous-shell exécutant une suite de commandes :

( /commande1/ ; /commande2/ ; /.../ ; /commandeN/ )

Le groupement par accolades exécute une suite de commandes vue comme une commande unique dans le shell courant :

{ /commande1/ ; /commande2/ ; /.../ ; /commandeN/ ; }

La commande set permet entre-autres de modifier les options du shell :

Le shell zsh lit sa configuration dans plusieurs fichiers :

• Le fichier ~/.zshrc, lu à chaque démarrage d'un zsh intéractif
• Le fichier ~/.zshenv, contenant les initialisations des variables d'environnement
• Le fichier ~/.zprofile, lu à chaque démarrage d'un zsh de session
• Le fichier ~/.zlogin, lu à chaque démarrage d'un zsh de session
• Le fichier ~/.zlogout, lu à chaque fermeture de session zsh

Le mode intéractif est simplement celui correspondant à l'interpréteur de commande, par opposition au shell non intéractif exécutant un script. L'option -i peut forcer le mode intéractif :

zsh -i

Un zsh de session (on dit aussi de login) s'obtient par :

zsh -

ou :

zsh -l

La valeur d'une variable « $<span class="bleu">variable/ » peut bien entendu s'utiliser partout à la place d'une chaîne de caractères ou d'un nombre. Il existe en plus certains tests propres aux variables.

Notons que dans d'autres langages de programmation comme python, c'est l'inverse : les valeurs non nulles sont vraies et une valeur nulle est fausse.

La suite de commandes :

( /commande1/ ; exit 0 )

réussit toujours. Par conséquent, la structure :

/condition/ &&
( /commande1/ ; exit 0 ) ||
/commande2/

va exécuter commande1 si la condition est vraie et commande2 dans le cas contraire.

La structure if permet d'exécuter conditionnellement une suite de commandes. La forme la plus simple est :

if [ /condition/ ]
then
/commande(s)/
fi

Dans la forme suivante, la suite commande(s)-1 est exécutée si la condition est vraie. Dans le cas contraire, c'est la suite commande(s)-2 qui est exécutée :

if [ /condition/ ]
then
/commande(s)-1/
else
/commande(s)-2/
fi

Dans la forme suivante, la suite commande(s)-1 est exécutée si la condition-1 est vraie. Si la condition-1 est fausse mais que la condition-2 est vraie, la suite commande(s)-2 est exécutée. Si les deux conditions sont fausses, c'est la suite commande(s)-3 qui est exécutée :

if [ /condition-1/ ]
then
/commande(s)-1/
elif [ /condition-2/ ]
then
/commande(s)-2/
else
/commande(s)-3/
fi

Avec « et » :

if [ /condition1/ -a /condition2/ ]
then
/commande/
fi

Avec « ou » :

if [ /condition1/ -o /condition2/ ]
then
/commande/
fi

Avec « et » sur des commandes :

if /commande1/ && /commande2/
then
/commande/
fi

Avec « ou » sur des commandes :

if /commande1/ || /commande2/
then
/commande/
fi

La structure case compare une variable avec une série de motifs de type globbing. Au premier motif qui correspond avec le contenu de la variable, les commandes correspondantes sont exécutées et le shell sort de la structure. La forme générique est :

case /variable/ in
/motif-1/) /commande(s)-1/ ;;
/motif-2/) /commande(s)-2/ ;;
...
/motif-N/) /commande(s)-N/ ;;
esac

Un motif du type :

/motif-1/ | /motif-2/ )

correspondra avec la variable si motif-1 ou motif-2 correspond

Cet exemple applique une série de commandes dans le cas où la variable contient un nom de fichier html ou php et une autre série de commandes dans le cas contraire :

case /variable/ in
*.html | *.php) /commande(s)-1/ ;;
*) /commande(s)-2/ ;;
esac

La boucle for applique une même opération à tous les éléments d'une liste. La forme générique est :

for /variable/ in /liste/
do
... $/variable/ ...
done

Si aucune liste, n'est donnée, la boucle sera appliquée à $1, $2, $3, etc. Ainsi :

for /variable/
do
... $/variable/ ...
done

est équivalent à :

for /variable/ in $1 $2 $3 ...
do
... $/variable/ ...
done

Exemple : appliquer la même opération à une liste de valeurs données :

for /variable/ in /val1 val2 ... valN/
do
... $/variable/ ...
done

Exemple : appliquer la même opération à tous les fichiers d'un répertoire :

for /fichier/ in *
do
/commande/ $/fichier/
done

Exemple : appliquer la même opération à tous les fichiers se terminant par .ogg :

for /fichier/ in */.ogg/
do
/commande/ $/fichier/
done

La boucle while exécute une même série de commandes jusqu'au moment où une condition devient fausse. Cette boucle dispose d'une entrée et d'une sortie standard. La forme générique est :

while /condition/
do
/commande/
done

On peut appliquer une même commande à chaque ligne d'un fichier, il suffit de rediriger l'entrée standard d'une boucle while vers ce fichier :

while read /ligne/
do
/commande/ $/ligne/
done < /fichier/

On peut également rediriger la sortie de la boucle :

while read /ligne/
do
/commande/ $/ligne/
done < /fichier/ > /sortie/

On peut appliquer une même commande commande2 à chaque ligne de la sortie d'une autre commande commande1, il suffit de rediriger l'entrée standard de commande1 vers une boucle while :

/commande1/ | while read /ligne/
do
/commande2/ $/ligne/
done

L'instruction break sert à sortir d'une boucle for ou while.

L'instruction continue sert à aller directement à la prochaine itération d'une boucle for ou while.

Les combinaisons de touches permettant d'éditer la ligne de commande sont associées à des fonctions d'édition via l'instruction « bindkey » :

bindkey /combinaison/ /fonction-edition/

La fonction d'édition « push-line-or-edit », associée par défaut à la combinaison :

<alt q>

ou :

<esc> q

place la ligne de commande en cours d'édition sur une pile, puis l'efface pour permettre d'entrer une autre ligne de commande. Une fois cette autre ligne entrée et exécutée, la commande antérieure est retirée de la pile et affichée à nouveau.

On peut ajouter plusieurs lignes successives dans la pile en utilisant « <alt q> » plusieurs fois de suite. Dès qu'une commande entrée est exécutée de façon classique avec « <Return> », la ligne la plus haute dans la pile (si cette dernière n'est pas vide) est retirée et affichée.

La combinaison <ctrl v> permet d'écrire littéralement une touche ou une combinaison de touches ayant un effet spécial. Par exemple, la suite :

<ctrl v> <ctrl u>

affichera le caractère <ctrl u> sous la forme ^U, sans l'effet habituel qui efface la ligne de commande.

La touche activant la complétion est simplement la tabulation. Elle agit de différentes façons suivant le contexte :

• Si le mot en cours peut être complété partiellement ou totalement de façon non ambiguë, la tabulation complète le mot
• Si il existe plusieurs solutions possible, la tabulation les affiche
• Si les solutions sont déjà affichées, la tabulation permet d'accéder au menu

Petit exemple, dans un répertoire qui contient bidule.html et bidule.tex. Si on tape :

ls bid

une première tabulation complètera la partie non ambiguë :

ls bidule

Une deuxième tabulation affichera les solutions :

bidule.html bidule.tex

et une troisième tabulation accèdera au menu correspondant, permettant de sélectionner la solution désirée.

Remarque : ce comportement peut changer suivant les options, mais l'idée générale reste la même.

Avec ces options :

bindkey '/codeToucheUp/' history-beginning-search-backward
bindkey '/codeToucheDown/' history-beginning-search-forward

les flèches haut et bas donnent accès à l'historique des commandes correspondant à la partie déjà frappée. Par exemple, si l'historique contient :

ls bidule
ls -l tutu
pwd
ls -l toto
ls machin
cd repertoire

et que l'on tape :

ls -l (flèches vers le haut)

on aura accès sucessivement à :

ls -l toto
ls -l tutu

Les codes des touches dépendent du type de terminal. Ils s'obtiennent par :

<ctrl v> <up>
<ctrl v> <down>

<td><alt n></td> <td>Complétion du premier mot par la ligne de commande suivante dans l'historique</td> </tr>

Dans les expressions régulières étendues, les parenthèses isolant les sous-motifs ne sont pas précédées par des backslashs \ :

Le mode positif correspond au sed bavard. Il s'utilise en ligne de commande sous la forme :

sed '/commandeSed/'

ou, dans un script :

#!/bin/sed -f
/commandeSed/

Le mode négatif correspond au sed silencieux. Il s'utilise en ligne de commande sous la forme :

sed -n '/commandeSed/'

ou, dans un script :

#!/bin/sed -nf
/commandeSed/

Voici quelques commandes sed de substitutions restreintes.

Exemple : remplacer motif par (motif motif) :

sed 's//motif//(& &)/g' < /entree/ > /sortie/

awk '/commandesAwk/'

#!/usr/bin/awk -f
/commandesAwk/

L'option -F permet de modifier le séparateur de champ à l'entrée :

awk -F '/séparateur/' /.../