Introduction à la programmation en Bash

Syntaxe :       nom=[valeur]   [ nom=[valeur] ... ]

Il est impératif que le nom de la variable, le symbole = et la valeur à affecter ne forment qu’une seule chaîne de caractères.
Plusieurs affectations peuvent être présentes dans la même ligne de commande.

$ x=coucou       y=bonjour         => la variable x contient la chaîne de caractères coucou
                                   => la variable y contient la chaîne bonjour
$

ATTENTION : les syntaxes d’affectation erronées les plus fréquentes contiennent

• un ou plusieurs caractères espace entre le nom de la variable et le symbole =.
  Le shell interprète b comme une commande à exécuter ; ne la trouvant pas, il signale une erreur.

$ b        =coucou
-bash: b: command not found
$

• un ou plusieurs caractères espace entre le symbole = et la valeur de la variable.
  La chaîne coucou est interprétée comme la commande à exécuter.

$ y=       coucou
-bash: coucou: command not found
$

Lorsque le shell rencontre la chaîne $x, il la remplace textuellement par la valeur de la variable x, c.-à-d. coucou ; la commande exécutée par bash est : echo x est coucou

$ echo x est $x
x est coucou
$

Il est important de remarquer que le nom d’un paramètre et la valeur de ce paramètre ne se désignent pas de la même manière.

$ x=$x$y                     => x : contenant, $x : contenu
$ echo $x
coucoubonjour
$

Elle s’effectue à l'aide de la commande interne read. Celle-ci lit une ligne entière sur l’entrée standard.

Syntaxe :      read [ var1 ... ]

$ read a b
bonjour Monsieur             => chaînes saisies par l’utilisateur et enregistrées
                             => respectivement dans les variables a et b
$ echo $b
Monsieur
$

Lorsque la commande interne read est utilisée sans argument, la ligne lue est enregistrée dans la variable prédéfinie du shell REPLY.

$ read
bonjour tout le monde
$
$ echo $REPLY
bonjour tout le monde
$

L’option –p de read affiche une chaîne d’appel avant d’effectuer la lecture ; la syntaxe à utiliser est :

read –p chaîne_d_appel [ var ... ]

$ read -p "Entrez votre prenom : " prenom
Entrez votre prenom : Eric
$ echo $prenom
Eric
$

Remarques sur la commande interne read

• S’il y a moins de variables que de mots dans la ligne lue, le shell affecte le premier mot à la première variable, le deuxième mot à la deuxième variable, etc., la dernière variable reçoit tous les mots restants.

$ read a b c
un bon jour coucou
$ echo $a
un
$ echo $c
jour coucou
$

• S’il y a davantage de variables que de mots dans la ligne lue, chaque variable reçoit un mot et après épuisement de ces derniers, les variables excédentaires sont vides (c.-à-d. initialisées à la valeur null).

$ read a b
Un
$ echo $a
Un
$ echo $b
                => valeur null
$

Exercice 1 :
Ecrire un programme shell deuxfois qui affiche le message "Entrez un mot : ", lit le mot saisi par l'utilisateur puis affiche ce mot deux fois sur la même ligne.

$ deuxfois
Entrez un mot : toto
toto toto
$

Exercice 2 :
Ecrire un programme shell untrois qui demande à l'utilisateur de saisir une suite de mots constituée d'au moins trois mots et qui affiche sur la même ligne le premier et le troisième mot saisis.

$ untrois
Entrez une suite de mots : un petit coucou de Rodez
un coucou
$

Pour définir une variable dont la valeur ne doit pas être modifiée (appelée constante dans d’autres langages de programmation), on utilise la syntaxe :

           declare –r nom=valeur [ nom=valeur ... ]

$ declare -r mess=bonjour
$

On dit que la variable mess possède l’attribut r. Une tentative de modification de la valeur d’une constante provoque une erreur.

$ mess=salut
-bash: mess: readonly variable
$

Pour connaître la liste des constantes définies : declare –r

$ declare -r
declare        -ar     BASH_VERSINFO='([0]="3"          [1]="1"      [2]="17"       [3]="1"
[4]="release" [5]="i486-pc-linux-gnu")'
declare -ir EUID="1002"
declare -ir PPID="25165"
declare -r SHELLOPTS="braceexpand:emacs:hashall:histexpand:history:
interactive-comments:monitor"
declare -ir UID="1002"
declare -r mess="bonjour"
$

Plusieurs constantes sont prédéfinies : le tableau BASH_VERSINFO (attribut a), les entiers EUID, PPID et UID (attribut i) et la chaîne SHELLOPTS.

Un paramètre de position est référencé par un ou plusieurs chiffres : 8 , 0 , 23 L’assignation de valeurs à des paramètres de position s’effectue :

• soit à l’aide de la commande interne set
• soit lors de l’appel d’un fichier shell ou d’une fonction shell.

on ne peut utiliser ni le symbole =, ni la commande interne read pour affecter directement une valeur à un paramètre de position.

$ 23=bonjour
-bash: 23=bonjour: command not found
$ read 4
aa
-bash: read: `4': not a valid identifier
$

Commande interne set : La commande interne set affecte une valeur à un ou plusieurs paramètres de position en numérotant ses arguments suivant leur position. La numérotation commence à 1.

Syntaxe :       set arg1 ...

$ set alpha beta gamma => alpha est la valeur du paramètre de position 1, beta la
                       => valeur du deuxième paramètre de position et gamma
                       => la valeur du paramètre de position 3
$

Pour obtenir la valeur d’un paramètre de position, il suffit de placer le caractère $ devant son numéro ; ainsi, $1 permet d’obtenir la valeur du premier paramètre de position, $2 la valeur du deuxième et ainsi de suite.

$ set ab be ga         => numérotation des mots ab, be et ga
$ echo $3 $2
ga be
$ echo $4
$

Tous les paramètres de position sont réinitialisés dès que la commande interne set est utilisée avec au moins un argument.

$ set coucou
$ echo $1
coucou
$ echo $2
           => les valeurs be et ga précédentes ont disparues
$

La commande set -- rend indéfinie la valeur des paramètres de position préalablement initialisés.

$ set alpha beta
$ echo $1
alpha
$
$ set --
$ echo $1
               => les valeurs alpha et beta sont perdues
$

Remarques :

• Utilisée sans argument, set a un comportement différent : elle affiche la (longue) liste des noms et valeurs des variables définies.

$ set
BASH=/bin/bash
...
$

• Si la valeur du premier argument de set commence par un caractère - ou +, une erreur se produit. En effet, les options de cette commande interne commencent par un de ces deux caractères. Pour éviter que ce type d’erreur ne se produise, on utilise la syntaxe : set -- arg ...

$ a=+qui
$ set $a
-bash: set: +q: invalid option
set: usage: set [--abefhkmnptuvxBCHP] [-o option] [arg ...]
$ set -- $a
$ echo $1
+qui
$

Un paramètre spécial est référencé par un caractère spécial. L’affectation d’une valeur à un paramètre spécial est effectuée par le shell. Pour obtenir la valeur d’un paramètre spécial, il suffit de placer le caractère $ devant le caractère spécial qui le représente.

Un paramètre spécial très utilisé est le paramètre # (à ne pas confondre avec le début d’un commentaire). Celui-ci contient le nombre de paramètres de position ayant une valeur.

$ set a b c

$ echo $#        => affichage de la valeur du paramètre spécial #
3                => il y a 3 paramètres de position ayant une valeur
$

Exercice 3 :
Ecrire un programme shell nbmots qui demande à l'utilisateur de saisir une suite quelconque de mots puis affiche le nombre de mots saisis.

$ nbmots
Entrez une suite de mots : un deux trois quatre cinq
5       => 5 mots ont été saisis
$

La commande interne shift décale la numérotation des paramètres de position ayant une valeur.

Syntaxe :      shift [ n ]

Elle renomme le n+1 ième paramètre de position en paramètre de position 1, le n+2 ième paramètre de position en paramètre de position 2, etc. : (n+1) => 1 , (n+2) => 2 , etc. Une fois le décalage effectué, le paramètre spécial # est mis à jour.

$ set a b c d e      =>     12345 
$ echo $1 $2 $#
ab5
$ shift 2    =>       abcde                  les mots a et b sont devenus inaccessibles
             =>         123
$ echo $1 $3
ce
$ echo $#
3
$

La commande interne shift sans argument est équivalente à shift 1.

shift ne modifie pas la valeur du paramètre de position 0 qui possède une signification particulière.

Dans un fichier shell, les paramètres de position sont utilisés pour accéder aux valeurs des arguments qui ont été passés lors de son appel : cela signifie qu’au sein du fichier shell, les occurrences de $1 sont remplacées par la valeur du premier argument, celles de $2 par la valeur du deuxième argument, etc. Le paramètre spécial $# contient le nombre d’arguments passés lors de l’appel.

Le paramètre de position 0 contient le nom complet du programme shell qui s’exécute.

Soit le programme shell copie :

#!/bin/bash
#        @(#)      copie
echo "Nom du programme : $0"
echo "Nb d'arguments : $#"
echo "Source : $1"
echo "Destination : $2"
cp $1 $2

Pour exécuter ce fichier shell :

$ chmod u+x copie
$ copie /etc/passwd X
Nom du programme : ./copie
Nb d'arguments : 2
Source : /etc/passwd
Destination : X
$

Dans le fichier copie, chaque occurrence de $1 a été remplacée par la chaîne de caractères /etc/passwd, celles de $2 par X.

Exercice 4 :
Ecrire un programme shell cp2fois prenant trois arguments : le premier désigne le nom du fichier dont on veut copier le contenu dans deux fichiers dont les noms sont passés comme deuxième et troisième arguments. Aucun cas d'erreur ne doit être considéré.

Lorsque la commande interne set est utilisée à l’intérieur d’un programme shell, la syntaxe $1 possède deux significations différentes : $1 comme premier argument du programme shell, et $1 comme premier paramètre de position initialisé par set au sein du fichier shell.

# !/bin/bash
echo '$1' est $1         => la chaîne $1 est remplacée par le premier argument
set hello                => set écrase la valeur précédente de $1
echo '$1' est $1

$ ecrase_arg bonjour coucou salut
$1 est bonjour
$1 est hello
$

Les paramètres spéciaux @ et * contiennent tous deux la liste des valeurs des paramètres de position initialisés.

$ set un deux trois quatre
$ echo $*
un deux trois quatre
$ echo $@
un deux trois quatre
$

Ces deux paramètres spéciaux ont des valeurs distinctes lorsque leur référence est placée entre des guillemets ("$*" et "$@") :

         "$*" est remplacée par        "$1 $2 ... "
         "$@" est remplacée par        "$1" "$2" ...

$ set un deux trois                   => trois paramètres de position sont initialisés
$ set "$*"                            => est équivalent à : set “un deux trois”
$ echo $#
1
$ echo $1
un deux trois
$

L’intérêt de la syntaxe "$*" est de pouvoir considérer l’ensemble des paramètres de position initialisés comme une unique chaîne de caractères. La syntaxe "$@" produit autant de chaînes que de paramètres de positions initialisés.

$ set un deux trois            => trois paramètres de position initialisés
$ set "$@"                     => est équivalent à : set “un” “deux” “trois”
$ echo $#
3
$ echo $1
un
$

Variable prédéfinie IFS et paramètre spécial "$*" :

La variable prédéfinie du shell IFS contient les caractères séparateurs de mots dans une commande. Par défaut, ce sont les caractères espace, tabulation et interligne. L’initialisation de IFS est effectuée par bash.

Le shell utilise le premier caractère mémorisé dans IFS (par défaut, le caractère espace) pour séparer les différents paramètres de position lorsque la syntaxe "$*" est utilisée. En modifiant la valeur de IFS, l’utilisateur peut changer ce caractère séparateur.

$ IFS=:                      => le caractère deux-points est maintenant le premier caractère de IFS
$ set un deux trois quatre
$ echo $*
un deux trois quatre
$ echo "$@"
un deux trois quatre
$ echo "$*"
un:deux:trois:quatre         => seule la forme "$*" provoque un changement
$