Guide des tableaux bash

Dans ce guide dédié aux tableaux en Bash, nous allons explorer comment déclarer et manipuler les tableaux indexés et associatifs au sein de ce langage.

Bash offre la possibilité de créer des tableaux pour regrouper des ensembles d'éléments. Ces tableaux sont, par nature, unidimensionnels. Contrairement à des langages comme C ou C++ où les tableaux doivent contenir des éléments d'un même type de données, Bash permet de mélanger entiers et chaînes au sein d'un même tableau, selon les besoins spécifiques.

Ce tutoriel vous initiera à la déclaration de tableaux en Bash ainsi qu'à l'accès à leurs composants. Vous apprendrez aussi à parcourir les éléments, à en ajouter de nouveaux et, enfin, à comprendre le fonctionnement des tableaux associatifs dans Bash.

C'est parti!

⚙ Envie d'explorer le codage ? Voici les bases nécessaires :

Comment initialiser un tableau Bash

Cette section détaille la syntaxe requise pour la déclaration d'un tableau Bash, illustrée par des exemples concrets.

Syntaxe de base pour déclarer un tableau en Bash

La déclaration d'un tableau en Bash se fait selon le modèle suivant :

$ nomDuTableau=(element1 element2 ... elementN)

# nomDuTableau est le nom attribué au tableau
# element1 à elementN représentent les N éléments qui composent le tableau

Dans cette structure, "nomDuTableau" est l'identifiant du tableau qui contiendra les N éléments "element1" jusqu'à "elementN".

Les éléments d'un tableau sont placés entre parenthèses (). Il est crucial de noter que les éléments doivent être séparés par un espace. Tout comme pour les autres variables Bash, il est impératif de ne pas inclure d'espaces avant ou après l'opérateur d'affectation =.

📑 La plupart des langages de programmation séparent les éléments d'un tableau, ou d'une collection similaire, par des virgules. Cependant, Bash utilise l'espace blanc comme séparateur.

Ces types de tableaux, où chaque élément est identifié par un indice numérique, sont appelés tableaux indexés dans Bash.

Déclaration de tableaux indexés en Bash

Créons un tableau nommé "prix" pour y stocker des valeurs numériques :

$ prix=(24 27 18 30 15)

Conformément à la syntaxe, les nombres du tableau "prix" sont séparés par des espaces, placés entre parenthèses et sans espaces autour de l'opérateur =.

Dans Bash, la commande "echo" permet d'afficher la valeur d'une variable. L'utilisation de "$nomDeVariable" affiche le contenu de "nomDeVariable". Cependant, vous remarquerez que l'utilisation du nom du tableau seul n'affiche que son premier élément.

$ echo $prix
24

Les tableaux Bash utilisent une indexation qui commence à zéro. Le premier élément se trouve donc à l'indice 0, le deuxième à l'indice 1 et ainsi de suite. L'indexation négative est aussi admise; l'index -1 correspond au dernier élément.

Que se passe-t-il si nous tentons d'accéder et d'afficher un élément spécifique en utilisant son indice? Essayons d'afficher l'élément d'indice 1.

$ echo $prix[1]
24[1]

Pourquoi obtenons-nous "24[1]"? 🤔 C'est parce que Bash remplace "$prix" par "24", qui est le premier élément du tableau, et "[1]" est affiché tel quel.

Pour afficher l'élément à un indice donné, il faut employer l'expansion de paramètres sous la forme ${prix[indice]}.

$ echo ${prix[1]}
# 27
$ echo ${prix[2]}
# 18

Pour afficher tous les éléments du tableau, remplacez l'indice par @.

$ echo ${prix[@]}
24 27 18 30 15

Passons à la création d'un tableau de chaînes de caractères. L'instruction suivante permet de créer un tableau indexé :

$ declare -a fruits

L'option "-a" spécifie qu'il s'agit d'un tableau indexé. Il est maintenant possible de remplir le tableau, élément par élément, en assignant chaque élément à un indice précis, comme suit :

$ fruits[0]="cerise"
$ fruits[1]="myrtille"
$ fruits[2]="pomme"
$ fruits[3]="poire"
$ fruits[4]="melon"
$ fruits[5]="orange"

Pour afficher l'intégralité du tableau, utilisez ${fruits[@]}.

$ echo ${fruits[@]}
cerise myrtille pomme poire melon orange

Accéder aux éléments d'un tableau Bash

L'accès aux éléments d'un tableau peut se faire de deux façons :

En parcourant le tableau, et en accédant directement à chaque élément
En utilisant une boucle qui parcourt les indices pour accéder à l'élément correspondant

Parcourir le tableau et accéder aux éléments

Si vous avez déjà utilisé Python, vous connaissez probablement la boucle "for" dans sa forme suivante :

for element in une_liste:
    print(element)

Voyons comment transcrire cette boucle "for" en Bash.

Nous savons que "${prix[@]}" se développe en l'ensemble des éléments du tableau "prix". De fait, "${prix[@]}" représente les valeurs de tous les éléments.

La boucle "for" de Bash ressemble à celle de Python, mais les instructions à l'intérieur de la boucle doivent être encadrées par "do" et "done", comme illustré ci-dessous :

$ for prix in ${prix[@]}
> do
> echo $prix
> done

Puisque nous utilisons la commande "echo" pour afficher la valeur de la variable "prix", le résultat est :

# Résultat
24
27
18
30
15

Accéder aux éléments via leur indice

Une autre méthode pour parcourir un tableau est d'utiliser les indices des éléments. C'est une approche similaire à la fonction "range()" utilisée dans les boucles "for" de Python :

for i in range(len(une_liste)):
    print(i)

Pour obtenir la liste des indices à parcourir, il suffit de placer un point d'exclamation (!) devant le nom du tableau dans l'expansion de paramètre. Cela retourne la liste de tous les indices valides du tableau, comme suit :

$ echo ${!prix[@]}
0 1 2 3 4

Le tableau "prix" contenant 5 éléments, les indices débutent à 0 et vont jusqu'à 4.

On peut ensuite parcourir cette liste d'indices et accéder à l'élément correspondant à chaque indice. Pour un indice "i", "${prix[i]}" correspond à l'élément à l'indice "i".

$ for i in ${!prix[@]}
> do
> echo ${prix[i]}
> done

Cette boucle affichera tous les éléments du tableau.

# Résultat
24
27
18
30
15

💬 Ici, après avoir accédé à chaque élément, nous nous contentons de l'afficher. Cependant, il est possible d'appliquer toutes sortes de traitements aux éléments accédés.

Ajouter des éléments à un tableau Bash

Notre tableau "prix" contient 5 éléments (aux indices 0, 1, 2, 3 et 4). Si nous voulons ajouter un élément à la fin du tableau, à l'indice 5, voici comment faire :

$ prix[5]=21

On constate que la valeur 21 a bien été ajoutée à la fin du tableau "prix".

$ echo ${prix[@]}
24 27 18 30 15 21

Cependant, il est plus pratique d'ajouter des éléments à la fin du tableau sans avoir à se souvenir de l'indice du dernier élément ajouté ou du nombre d'éléments actuel du tableau.

Pour cela, utilisez la syntaxe "nomDuTableau+=(element(s))" afin d'ajouter un ou plusieurs éléments à un tableau, comme suit :

$ prix+=(10)

En affichant le tableau "prix", on constate que la valeur 10 a été ajoutée à la fin du tableau.

$ echo ${prix[@]}
24 27 18 30 15 21 10

Voyons maintenant comment déclarer des tableaux associatifs en Bash.

Tableaux associatifs en Bash

Pour définir des relations basées sur des paires clé-valeur, il est préférable d'utiliser des tableaux associatifs. La déclaration d'un tableau associatif se fait via la syntaxe générale suivante. Notez l'utilisation de l'option "-A" au lieu de "-a".

$ declare -A prix_fruits

Il est possible d'ajouter des éléments au tableau associatif en spécifiant une clé et la valeur qui lui est associée. Ici, nous allons utiliser les noms de fruits comme clés et les prix comme valeurs.

$ prix_fruits[cerise]=24
$ prix_fruits[myrtille]=27
$ prix_fruits[pomme]=18
$ prix_fruits[poire]=30
$ prix_fruits[melon]=15
$ prix_fruits[orange]=21

Comment accéder aux éléments d'un tableau associatif?

De la même façon qu'on recherche une valeur à partir d'une clé dans un dictionnaire Python, on accède aux valeurs d'un tableau associatif en utilisant leurs clés.

$ echo ${prix_fruits[myrtille]}
# 27

Nous remarquons que "${prix_fruits[@]}" permet d'accéder aux valeurs et "${!prix_fruits[@]}" aux clés.

$ echo ${prix_fruits[@]}
# Résultat: 18 27 21 24 30 15
$ echo ${!prix_fruits[@]}
# Résultat: pomme myrtille orange cerise poire melon

Attention : L'ordre des éléments n'est pas le même que celui dans lequel nous les avons ajoutés. Contrairement aux tableaux indexés, les tableaux associatifs ne sont pas des collections ordonnées. Ils sont plutôt basés sur l'association entre les clés et les valeurs. Ainsi, dans un tableau associatif, les clés jouent le rôle des indices dans les tableaux indexés.

Il est également possible de parcourir le tableau associatif et d'accéder aux clés, comme illustré ci-dessous :

$ for cle in ${!prix_fruits[@]}
> do
> echo $cle
> done

# Résultat
pomme
myrtille
orange
cerise
poire
melon

La boucle suivante montre comment accéder aux valeurs :

$ for valeur in ${prix_fruits[@]}
> do
> echo $valeur
> done

# Résultat
18
27
21
24
30
15

Bien qu'il soit recommandé d'utiliser la syntaxe "nomDuTableau[cle]=valeur", il est aussi possible de déclarer le tableau sous forme d'une séquence, comme ceci :

declare -A nomDuTableau
nomDuTableau=(cle1 valeur1 cle2 valeur2 ... cleN valeurN)

De cette façon, Bash interprète le premier élément comme la première clé, le second comme la première valeur, et ainsi de suite.

Résumé

J'espère que vous comprenez désormais comment créer et utiliser des tableaux en Bash. Voici un récapitulatif de ce que vous avez appris.

Vous pouvez déclarer un tableau indexé dans Bash en utilisant la syntaxe "nomDuTableau=(element1 element2 element3 … elementN)" ou bien en exécutant "declare -a nomDuTableau" et en ajoutant les éléments au tableau par la suite.
Pour accéder aux éléments, vous pouvez utiliser une boucle avec "${nomDuTableau[@]}". Alternativement, vous pouvez obtenir la liste de tous les indices valides grâce à l'extension de paramètre "${!nomDuTableau[@]}".
Enfin, vous avez aussi appris à déclarer un tableau associatif afin de stocker des paires clé-valeur dans Bash.

Pour aller plus loin, consultez notre tutoriel sur les boucles en Bash.