Guide des tableaux bash

Dans ce guide sur les tableaux Bash, vous apprendrez à déclarer et à utiliser des tableaux indexés et associatifs dans Bash.

Dans Bash, vous pouvez créer des tableaux pour stocker une collection d’éléments. Les tableaux Bash sont des collections unidimensionnelles. Dans les langages de programmation tels que C et C++, les tableaux sont des collections d’éléments du même type de données. Cependant, dans Bash, selon le cas d’utilisation, vous pouvez stocker des entiers et des chaînes dans le même tableau.

Dans ce didacticiel, vous apprendrez à déclarer un tableau Bash et à accéder à ses éléments. Vous apprendrez ensuite à parcourir les éléments d’un tableau et à ajouter des éléments à un tableau. Enfin, vous découvrirez les tableaux associatifs dans Bash.

Commençons!

⚙ Intéressé par le codage ? Voici les prérequis :

Comment déclarer un tableau bash

Dans cette section, vous apprendrez la syntaxe pour déclarer un tableau Bash et des exemples de code.

Syntaxe de la déclaration de tableau bash

Vous pouvez déclarer un tableau dans Bash en utilisant la syntaxe suivante :

$ arrayName=(elt1 elt2 ... eltN)

# arrayName is the name of the array
# elt1 through eltN are the N elements in the array

Dans la syntaxe ci-dessus, arrayName indique le nom du tableau qui contient N éléments elt1…eltN.

Les éléments d’un tableau sont placés entre les parenthèses ouvrantes et fermantes (). Notez également que les éléments du tableau sont séparés par un espace. Comme pour toute variable Bash, il ne doit y avoir aucun espace avant ou après l’opérateur d’affectation =.

📑 Dans la plupart des autres langages de programmation, vous séparerez les éléments d’un tableau ou de collections similaires par des virgules. Mais dans Bash, l’espace blanc est le séparateur.

Dans Bash, de tels tableaux dans lesquels les éléments sont identifiés par leur index sont appelés tableaux indexés.

Déclarer des tableaux indexés dans Bash

Créons des prix, un tableau de nombres.

$ prices=(24 27 18 30 15)

Comme mentionné dans la syntaxe, les nombres dans le tableau des prix sont séparés par un espace blanc, entre parenthèses, sans espaces avant et après l’opérateur d’affectation =.

Dans Bash, vous pouvez utiliser la commande echo pour imprimer la valeur d’une variable. L’utilisation de $variableName imprime la valeur de variableName. Cependant, vous pouvez voir que l’utilisation du nom du tableau imprime uniquement le premier élément.

$ echo $prices
24

Les tableaux bash suivent l’indexation zéro. Ainsi, le premier élément est à l’indice 0, le deuxième élément est à l’indice 1, et ainsi de suite. Vous pouvez également utiliser l’indexation négative ; l’indice du dernier élément du tableau est -1.

Que se passe-t-il si vous essayez d’accéder à l’élément à un index particulier et de l’imprimer ? Essayons d’imprimer l’élément à l’index 1.

$ echo $prices[1]
24[1]

Pourquoi la sortie 24[1]? 🤔 C’est parce que Bash remplace $prices par 24, le premier élément du tableau et [1] est imprimé tel quel.

Pour imprimer l’élément à un index particulier, vous pouvez utiliser l’expansion des paramètres de la forme ${prices[index]}.

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

Pour imprimer tous les éléments du tableau, vous pouvez spécifier @ au lieu d’un index spécifique.

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

Ensuite, créons un tableau de chaînes. L’exécution de la commande suivante crée un tableau indexé :

$ declare -a fruits

L’option -a crée un tableau indexé. Vous pouvez maintenant remplir le tableau, un élément à la fois, en déclarant l’élément à un index spécifique, comme indiqué ci-dessous :

$ fruits[0]="cherry"
$ fruits[1]="berry"
$ fruits[2]="apple"
$ fruits[3]="pear"
$ fruits[4]="melon"
$ fruits[5]="orange"

Maintenant, pour imprimer tous les éléments du tableau, vous pouvez utiliser ${fruits[@]}.

$ echo ${fruits[@]}
cherry berry apple pear melon orange

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

Vous pouvez accéder aux éléments du tableau des manières suivantes :

• Parcourez le tableau et accédez directement à l’élément
• Boucle à travers l’ensemble des index et des éléments d’accès à un index spécifique

Boucle à travers le tableau et les éléments d’accès

Si vous avez codé en Python, vous aurez utilisé la boucle for en utilisant la syntaxe suivante :

for elt in some_list:
    print(elt)

Écrivons maintenant l’équivalent Bash de la boucle for ci-dessus.

Nous savons que {les prix[@]} s’étend à tous les éléments du tableau des prix. Et {prix $[@]} nous donne les valeurs de tous les éléments.

La boucle for de Bash est similaire à la syntaxe de la boucle for de Python, mais les instructions du corps de la boucle doivent être incluses dans do et done, comme indiqué :

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

Parce que nous utilisons la commande echo et imprimons la valeur du prix variable, nous obtenons la sortie suivante :

# output
24
27
18
30
15

Accéder aux éléments à l’aide de l’index du tableau

Une autre façon de parcourir les tableaux consiste à utiliser l’index des éléments. Ceci est similaire à la construction de la boucle for en Python qui utilise la fonction range() :

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

Pour obtenir une liste d’index à parcourir, vous pouvez placer un point d’exclamation (!) avant le nom du tableau dans l’expansion du paramètre. Cela vous donnera la liste de tous les index valides pour le tableau, comme indiqué :

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

Le tableau des prix contient 5 éléments, donc l’indice commence à 0 et monte jusqu’à 4.

Ensuite, nous pouvons parcourir la liste des index et accéder à l’élément à chaque index. Pour l’indice i, ${prices[i]} est l’élément à l’indice i.

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

La boucle ci-dessus affiche tous les éléments du tableau.

# output
24
27
18
30
15

💬 Ici, après avoir accédé à chaque élément, nous effectuons une simple opération d’impression de sa valeur. En général, nous pouvons avoir n’importe quel traitement valide sur les éléments.

Ajouter des éléments à un tableau bash

Dans le tableau des prix, nous avons cinq éléments (aux indices 0,1,2,3 et 4). Si vous souhaitez ajouter un élément à la fin du tableau à l’index 5, vous pouvez le faire comme suit :

$ prices[5]=21

Nous voyons que 21 a été ajouté à la fin du tableau des prix.

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

Cependant, il est plus pratique d’ajouter à la fin du tableau, sans s’en souvenir, l’index du dernier élément ajouté ou le nombre d’éléments actuellement dans le tableau.

Vous pouvez utiliser arrayName+=(elements(s)) pour ajouter un ou plusieurs éléments à un tableau, comme indiqué :

$ prices+=(10)

Maintenant, si nous imprimons le tableau des prix, nous voyons que 10 a été ajouté à la fin du tableau.

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

Ensuite, apprenons à déclarer des tableaux associatifs dans Bash.

Tableaux associatifs dans Bash

Si vous souhaitez définir une relation en termes de paires clé-valeur, vous pouvez utiliser un tableau associatif. Vous pouvez déclarer un tableau associatif en utilisant la syntaxe générale suivante. Notez que nous utilisons l’option -A au lieu de -a.

$ declare -A fruits_prices

Vous pouvez ajouter des éléments au tableau associatif en spécifiant la clé et la valeur correspondante. Ici, nous avons ajouté les noms des fruits comme clés et les nombres du tableau des prix comme valeurs.

$ fruits_prices[cherry]=24
$ fruits_prices[berry]=27
$ fruits_prices[apple]=18
$ fruits_prices[pear]=30
$ fruits_prices[melon]=15
$ fruits_prices[orange]=21

Alors, comment accéder aux éléments d’un tableau associatif ?

De la même manière que vous recherchez la valeur à l’aide de la clé correspondante dans un dictionnaire Python, vous pouvez accéder aux valeurs dans un tableau associatif à l’aide des clés.

$ echo ${fruits_prices[berry]}
# 27

Nous voyons que ${fruits_prices[@]} s’étend aux valeurs et ${!fruits_prices[@]} s’étend aux clés.

$ echo ${fruits_prices[@]}
# Output: 18 27 21 24 30 15
$ echo ${!fruits_prices[@]}
# Output: apple berry orange cherry pear melon

Remarque : L’ordre des éléments n’est pas le même que l’ordre dans lequel nous les avons ajoutés. En effet, contrairement aux tableaux indexés, les tableaux associatifs ne sont pas des collections ordonnées. Ils travaillent plutôt sur l’association entre les clés et les valeurs. Par conséquent, les clés sont aux tableaux associatifs ce que les index sont aux tableaux d’index.

Vous pouvez également parcourir le tableau associatif et accéder aux clés, comme indiqué :

$ for key in ${!fruits_prices[@]}
> do
> echo $key
> done

# Output
apple
berry
orange
cherry
pear
melon

La boucle suivante montre comment vous pouvez accéder aux valeurs.

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

# Output
18
27
21
24
30
15

Bien qu’il soit recommandé d’utiliser arrayName[key]=value, vous pouvez aussi le déclarer comme une séquence comme ceci :

declare -A arrayName
arrayName=(key1 value1 key2 value2 ... keyN valueN)

De cette façon, Bash déduit le premier élément comme première clé, le deuxième élément comme première valeur, et ainsi de suite.

Résumé

J’espère que vous comprenez maintenant comment créer et travailler avec des tableaux Bash. Voici un bref aperçu de ce que vous avez appris.

• Vous pouvez déclarer un tableau indexé dans Bash en utilisant la syntaxe arrayName=(elt1 elt2 elt3 … eltN) ou exécuter declare -a arrayName et ajouter des éléments au tableau.
• Pour accéder aux éléments, vous pouvez effectuer une boucle en utilisant ${arrayName[@]}. Alternativement, vous pouvez obtenir la liste de tous les index valides en utilisant l’extension de paramètre ${!arrayName[@]}.
• Enfin, vous avez également appris à déclarer un tableau associatif pour stocker des paires clé-valeur dans Bash.

Ensuite, consultez le didacticiel sur les boucles dans Bash.