Introduction à la programmation en Bash

Pour créer un tableau, on utilise généralement l'option -a (comme array) de la commande interne declare :

declare -a nomtab ...

Le tableau nomtab est simplement créé mais ne contient aucune valeur : le tableau est défini mais n'est pas initialisé.

Pour connaître les tableaux définis : declare -a

Ex : $ declare -a
declare -a BASH_ARGC='()'
declare -a BASH_ARGV='()'
declare -a BASH_LINENO='()'
declare -a BASH_SOURCE='()'
declare -ar BASH_VERSINFO='([0]="3" [1]="1" [2]="17" [3]="1" [4]="release" [5]="i486-pc-linux-gnu")'
declare -a DIRSTACK='()'
declare -a FUNCNAME='()'
declare -a GROUPS='()'
declare -a PIPESTATUS='([0]="0")'
$

Pour définir et initialiser un tableau :

declare -a nomtab=( val0 val1 ... )

Comme en langage C, l'indice d'un tableau débute toujours à 0 et sa valeur maximale est celle du plus grand entier positif représentable dans ce langage (bash a été écrit en C). L'indice peut être une expression arithmétique.

Pour désigner un élément d'un tableau, on utilise la syntaxe :

nomtab[indice]

Ex : $ declare -a tab => définition du tableau tab
$
$ read tab[1] tab[3]
coucou bonjour
$
$ tab[0]=hello
$

Il n'est pas obligatoire d'utiliser la commande interne declare pour créer un tableau, il suffit d'initialiser un de ses éléments :

Ex : $ array[3]=bonsoir => création du tableau array avec
$ => initialisation de l'élément d'indice 3

Trois autres syntaxes sont également utilisables pour initialiser globalement un tableau :

- nomtab=( val0 val1 ... )

- nomtab=( [indice]=val ... )

Ex : $ arr=([1]=coucou [3]=hello)
$

- l'option -a de la commande interne read ou readonly :

Ex : $ read -a tabmess
bonjour tout le monde
$

On obtient la valeur d'un élément d'un tableau à l'aide la syntaxe :

${nomtab[indice]}

bash calcule d'abord la valeur de l'indice puis l'élément du tableau est remplacé par sa valeur.

Il est possible d'utiliser toute expression arithmétique valide de la commande interne (( pour calculer l'indice d'un élément.

Ex : $ echo ${tabmess[1]}
tout
$
$ echo ${tabmess[RANDOM%4]} # ou bien ${tabmess[$((RANDOM%4))]}
monde
$
$ echo ${tabmess[1**2+1]}
le
$

Pour obtenir la longueur d'un élément d'un tableau :

${#nomtab[indice]}

Ex : $ echo ${tabmess[0]}
bonjour
$
$ echo ${#tabmess[0]}
7 => longueur de la chaîne bonjour
$

Lorsqu'un tableau sans indice est présent dans une chaîne de caractères ou une expression, bash utilise l'élément d'indice 0.

Ex : $ echo $tabmess
bonjour
$

Réciproquement, une variable non préalablement définie comme tableau peut être interprétée comme un tableau.

Ex : $ var=bonjour
$ echo ${var[0]} => var est interprétée comme un tableau à un seul élément
bonjour => d'indice 0
$ var=( coucou ${var[0]} )
$ echo ${var[1]} => var est devenu un véritable tableau
bonjour
$

Exercice : Ecrire un programme shell carte qui affiche le nom d'une carte tirée au hasard d'un jeu de 32 cartes. On utilisera deux tableaux : un tableau couleur et un tableau valeur.

Ex : $ carte
huit de carreau
$ carte
as de pique
$

Le nombre d'éléments d'un tableau est désigné par :

Seuls les éléments initialisés sont comptés.

${#nomtab[*]}

Ex : $ echo ${#arr[*]}
2
$

Tous les éléments d'un tableau sont accessibles à l'aide de la notation :

${nomtab[*]}

Seuls les éléments initialisés sont affichés

Ex : $ echo ${arr[*]}
coucou hello
$

Pour obtenir la liste de tous les indices conduisant à un élément défini d'un tableau, on utilise la syntaxe :

${ !nomtab[*]}

Ex : $ arr=([1]=coucou bonjour [5]=hello)
$
$ echo ${!arr[*]}
1 2 5
$

L'intérêt d'utiliser cette syntaxe est qu'elle permet de ne traiter que les éléments définis d'un tableau « à trous ».

Ex : $ for i in ${!arr[*]}
> do
> echo "$i => ${arr[i]}" => dans l'expression ${arr[i]}, bash interprète
> done => directement i comme un entier
1 => coucou
2 => bonjour
5 => hello
$

Pour ajouter un élément val à un tableau tab :

- à la fin : tab[${#tab[*]}]=val

- en tête : tab=( val ${tab[*]} )

Ex : $ tab=( un deux trois )
$ echo ${#tab[*]}
3
$ tab[${#tab[*]}]=fin => ajout en fin de tableau
$ echo ${tab[*]}
un deux trois fin
$ tab=( debut ${tab[*]} ) => ajout en tête de tableau
$ echo ${tab[*]}
debut un deux trois fin
$

Exercice : Ecrire un programme shell distrib qui crée un paquet de 5 cartes différentes tirées au hasard parmi un jeu de 32 cartes et affiche le contenu du paquet.

Exercice : Ecrire un programme shell tabnoms qui place dans un tableau les noms de tous les utilisateurs enregistrés dans le système, affiche le nombre total d'utilisateurs enregistrés, puis tire au hasard un nom d'utilisateur.

Si l'on souhaite créer un tableau d'entiers on utilise la commande declare –ai. L'ordre des options n'a aucune importance.

Ex : $ declare –ai tabent=( 2 45 -2 )
$

Pour créer un tableau en lecture seule, on utilise les options –ra :

Ex : $ declare -ra tabconst=( bonjour coucou salut ) => tableau en lecture seule
$
$ tabconst[1]=ciao
-bash: tabconst: readonly variable
$
$ declare -air tabInt=( 34 56 ) => tableau (d'entiers) en lecture seule
$ echo $(( tabInt[1] +10 ))
66
$ (( tabInt[1] += 10 ))
-bash: tabInt: readonly variable
$

Pour supprimer un tableau ou élément d'un tableau, on utilise la commande interne unset.

Suppression d'un tableau : unset nomtab ...

Suppression d'un élément d'un tableau : unset nomtab[indice] ...