Petit précis de shell

Syntaxe de base

Les commandes s’écrivent soit :

• les unes à la suite des autres séparées par ; (peu recommandé)
• séparées les unes des autres par un saut de ligne

Chaque commande peut prendre des options (qui modifient la façon dont la commande se comporte comme affiche de l’aide, modifier la verbosité de la sortie, etc.) de deux types :

• les options courtes (l, r, h pour ls par exemple) qui sont passés comme suit : CMD -ARG
• les options longues (recursive pour rsync par exemple) qui se passent comme ceci : CMD --ARGUMENT

Il est évidement possible de passer plusieurs options à une même commande.

Certains paramètres existent sous une forme courte et une forme longue. Consulter le manuel de la commande pour plus de détails. Le manuel contient également la liste complète des arguments supportés par une commande.

Certains commandes ne respectent pas la convention énoncée ci-dessus. Leurs arguments long se passent avec un seul - (find en est un exemple).

Les commandes peuvent aussi prendre des arguments positionnels. Ils se placent après les paramètres.

Exemple : ls -R ~/Documents. Par défaut, ls ne liste que les fichiers et dossiers dans le dossier courant. L’option -R permet de descendre dans tous les dossiers. L’argument ~/Documents permet d’exécuter la commande dans le dossier ~/Documents sans s’y déplacer.

Pensez à la commande man qui prend comme argument une autre commande et affiche son manuel.

Les variables

Les variables se déclarent comme ceci : var="ping". Notez bien l'absence d'espaces entre var, = et "ping". Si vous ajoutez des espaces, le shell tentera de faire un test. Voir Conditions if … else ….

Ensuite, pour utiliser une variable, il faut mettre un $ devant le nom de la variable. Par exemple : echo $var affichera le contenu de la variable var. La variable est aussi remplacée par sa valeur dans une chaîne si elle est encadrée par des guillemets mais pas si elle est encadrée par des apostrophes. Par exemple :

• echo "$var pong" affichera ping pong.
• echo '$var pong' affichera $var pong.

Valeurs de retour des commandes et exceptions

Une fois qu’une commande s’est exécutée, elle renvoie une valeur de retour afin d’informer l’utilisateur. Cette valeur permet en effet de savoir si la commande s’est exécutée correctement. Voici les valeurs de retour courantes et leur signification :

• 0 : tout va bien
• 1 : erreur
• 2 : erreur grave

Vous pouvez vous aussi utiliser ces valeurs de retour. Par défaut, un script qui se complète correctement retourne 0. Mais vous pouvez (par exemple si un utilisateur tente d’exécuter un script qui nécessite un argument sans) retourner un autre code d’erreur avec la commande exit. Il suffit de lui passer le code qu’elle doit retourner. Votre script s’arrêtera alors avec le code d’erreur spécifié.

Vous pouvez connaître la valeur de retour de la dernière commande exécutée avec la variable $?.

Les valeurs de retour ne sont pas limitées à 0, 1, 2. Par convention, c'est n'importe quel entier positif. À chaque entier est associé une signification, ce qui permet de comprendre ce qui s'est passé si une commande échoue.

Exécuter une commande

S’il est facile dans les cas simples d’exécuter une commande, dès lors qu’en shell tout est chaîne de caractères, si vous voulez affecter la sortie d’une commande à une variable, vous ne pouvez pas simplement faire var=CMD car var va alors valoir la chaîne CMD.

Pour obtenir le résultat souhaité vous devez placer CMS entre $(…). Par exemple : var=$(ls).

Vous pouvez aussi mettre la commande entre backquote `. Mais cette syntaxe ` est plus ancienne et ne doit plus être utilisée. La syntaxe $(…) présente l’avantage de pouvoir imbriquer les commandes sans ambiguïté.

Il est également tout à fait possible de stocker une commande dans une variable pour l'exécuter ensuite (une fois de plus, tout est chaîne de caractère). Une commande est en effet une chaîne de caractère située en position 0 sur une ligne.

mon_cd=cd
$mon_cd

Conditions et itérations

if QQC
then
    CMDS
else
    CMDS
fi

while QQC
do
    CMD
done

for var in `CMD`
do
   CMD
done

Généralités

Un script peut prendre des paramètres qui ont le même but que les arguments d’une fonction : lui passer des informations. Un paramètre peut être :

• une variable

• une chaîne de caractère (donc un nombre, en shell on ne fait pas la distinction). Si la chaîne à passer en paramètre contient plusieurs mots séparés par des espaces, ne pas oublier de la mettre entre ‘ ou “.

  Si une variable coucou contient la chaîne ‘salut’, alors ‘$coucou toi’ sera compris $coucou toi tandis que $coucou toi sera interprétée en salut toi

  Les paramètres se passent à un script comme ceux d’une commande. Ils sont ensuite disponibles dans l’ordre avec des numéros :

  • le premier : $1
  • le deuxième : $2
  • et ainsi de suite

  Le shell ne supporte que 9 paramètres.

Les paramètres spéciaux

• $0 : contient le nom du script

• $# : contient le nombre d’arguments passés au script

  Le paramètre $0 est toujours passé au script. $# est donc toujours supérieur ou égal à 1.

• $? : le code de retour de la dernière commande invoquée

• $$ : le PID du shell qui exécute le script

• $! : le PID du dernier processus lancé en arrière plan

• $* : l’ensemble des paramètres en un seul argument

• $@ : L’ensemble des arguments, un argument par paramètre

Pour bien voir la différence entre $* et $@, il suffit de regarder la sortie du script suivant :

echo 'Avec $*'
for param in "$*" ; do
  echo $param
done

echo 'Avec $@'
for param in "$@" ; do
  echo $param
done

Les commandes shift et set

La commande set permet d’affecter les paramètres. Ainsi set bonjour salut bonsoir va initialiser $1 à bonjour, $2 à salut et $3 à bonsoir. Les paramètres spéciaux $#, $* et $@ sont mis à jour.

La commande shift permet de décaler les variables. Ainsi, si après shift $1 prend la valeur de $2 et ainsi de suite. shift n décale les arguments de n.

Le mot clé return

Comme la plupart des langages, le shell dispose d'un mot clé return. Lorsque ce mot clé est exécuté dans une fonction, cette fonction est exécuté jusqu'à ce mot clé, puis l'exécution du programme reprend à l'instruction suivante. Ce mot clé est particulièrement utile pour que des fonctions renvoient des codes d'erreur sans pour autant arrêter le script (ce que exit aurait fait).

Les flux sortant

Les flux représentent les sorties générées par les commandes. Par défaut, il existe deux flux :

• le flux standard
• le flux d’erreur

Par défaut, il s’affiche sur la sortie standard (votre écran pour être bref). Il peut s’avérer intéressant d’envoyer ces flux ailleurs (logs, le néant, etc.). Pour cela, on va les rediriger. Par exemple pour rediriger la sortie de ls dans un fichier nommé toto, on fait :

• ls > toto
• ou
• ls >> toto

La première solution efface le contenu du fichier puis écrit dedans. La seconde ajoute la sortie à la fin du fichier. On a ici redirigé le flux standard. Pour rediriger les flux d’erreurs, on utilise les symboles 2> ou 2>>. On peut évidemment combiner les deux : ls -R / > mes_fichiers.txt 2> errors.log avec toutes les variantes possibles.

Pour rediriger l’erreur au même endroit que l’entrée, on peut faire ls > toto 2> toto ou plus simplement ls > toto 2>&1. Pour rediriger une sortie vers le néant, on l’envoie dans /dev/null.

Les flux entrant

Il est également possible de passer en paramètre le contenu d’un fichier. Pour cela, on utilise le symbole <.

Exemple

while getopts ":h:u:p:P" opt
do
    case "$opt" in
        h)
            host=$OPTARG; hflag=true;;
        u)
            user=$OPTARG; uflag=true;;
        p)
            passwd=$OPTARG; pflag=true;;
        P)
            Pflag=true;;
        :)
            echo "Option -$OPTARG requires an argument." >&2
            usage; exit 1;;
        \?)
            usage; exit 0;;
    esac
done

shift $((OPTIND-1)) # To get the 1st positional argument with $1

Variables disponibles uniquement en Bash

• RANDOM (pour la génération de nombre aléatoire). Voir les trucs et astuces pour plus de détails.

Syntaxe

• &> et |&. Permettent de rediriger tous les flux vers un fichier ou de passer tous les flux à une commande (pipe généralisé)
• {2..10} pour générer des séquences de nombres
• [[ ARGS ]] : permet de faire des tests de façon plus facile ou agréable. Exemple : [[ chaine == chaine2 ]]
• =~ : s'utilise conjointement avec [[ ]] pour tester si la chaîne de gauche est contenu dans celle de droite
• $((ARGS)) est un raccourcis pour la fonction let

Autres

• Le nombre de paramètres en bash n’est pas limité à 9. Les paramètres positionnels de numéros supérieurs à 10 s’appellent comme suit : ${num}

Différences entre la sortie de ls et de find

• ls renvoie simplement la liste des fichiers.
• find renvoie un chemin absolu si l’argument donnée est un chemin absolu et relatif (de la forme ./fichier) si l’argument est .

ET et OU dans le langage

L’opérateur && permet de réaliser un ET paresseux entre deux commandes. Ainsi, par exemple : cmd1 && cmd2. cmd2 ne sera exécuté que si cmd1 a pu s’exécuter correctement. En outre le code de retour de l’ensemble ne sera 0 que si les deux commandes ont pu s’exécuter correctement.

L’opérateur || permet de réaliser un OU paresseux entre deux commandes. Ainsi, par exemple : cmd1 || cmd2. Si cmd1 s’exécute correctement cmd2 ne sera pas exécutée. Si cmd1 retourne une erreur, cmd2 sera exécutée. Le code de retour de l’ensemble correspond à un OU entre les deux codes de retour.

Ceci peut s’utiliser dans les conditions.

Des fonctionnalités analogues existes dans d’autres langages inspirés du shell comme Perl ou PHP.

Pour exécuter simplement deux commandes à la suite des autres sur une seule ligne, il suffit de séparer les commandes par un point virgule.