Comment travailler avec des tableaux dans les scripts Bash

Si vous travaillez avec une grande quantité de données dans vos scripts Bash, les tableaux vous faciliteront grandement la vie. Certaines personnes sont intimidées par la syntaxe. Mais une fois appris, cela rendra vos scripts plus puissants, avec moins de variables à prendre en compte.

Déclarer un tableau

Les tableaux dans Bash vous permettent de stocker plusieurs éléments de données dans une seule variable, un peu comme une liste Python. Cela en fait des outils puissants pour gérer des ensembles de valeurs associées telles que les noms de fichiers, les noms d'utilisateur, les options de configuration ou les arguments de ligne de commande.

Contrairement à de nombreux autres langages de programmation, Bash ne vous oblige pas à déclarer explicitement un type de tableau. Vous attribuez simplement des valeurs en utilisant une syntaxe spécifique et Bash sait qu'il s'agit d'un tableau. La méthode de déclaration varie en fonction du type de tableau (abordé plus tard.)

Pour déclarer un tableau indexé, qui est le type de tableau le plus courant, il vous suffit de taper le nom, un signe égal et des parenthèses.

arr=()

C'est ça. Vous venez de déclarer un tableau vide. Vous pouvez voir ses éléments en utilisant la commande echo, comme ceci :

echo $arr

Puisqu’il n’y a aucun élément, vous ne verrez rien sauf une ligne vide. Vous pouvez attribuer des valeurs au tableau sur la même ligne. Pour ce faire, tapez les éléments séparés par des espaces entre parenthèses.

fruits=("apple" "banana" "cherry")

Chaque valeur séparée par des espaces devient un élément du tableau. Vous pouvez le vérifier avec :

echo "${fruits(@)}"

Vous pouvez également déclarer un tableau vide et ajouter des éléments ultérieurement.

fruits=()
fruits+=("apple")
fruits+=("banana" "cherry")

L'impression du tableau affichera les éléments nouvellement ajoutés.

Cette approche est pratique si vous devez remplir le tableau de manière dynamique. Vous pouvez également attribuer des éléments individuels par index.

fruits(0)="apple"
fruits(1)="banana"
fruits(2)="cherry"

Une autre façon de déclarer un tableau consiste à utiliser le declare intégré pour définir explicitement un tableau indexé.

declare -a colors=("red" "green" "blue")

Cela montre clairement aux autres que « couleurs » est conçu comme un tableau, ce qui peut être utile dans des scripts plus volumineux. Pour confirmer si une variable Bash est un tableau (et de quel type), utilisez le declare -p commande.

Ceci est particulièrement utile lors du débogage de scripts.

Parcourir un tableau

Une fois que vous avez déclaré un tableau, vous souhaiterez généralement faire quelque chose avec ses éléments : les imprimer, les traiter ou les transmettre aux commandes. Dans Bash, il existe plusieurs façons de parcourir les tableaux, et la compréhension de ces approches est essentielle pour écrire des scripts flexibles et sans bugs.

Le moyen le plus courant de parcourir chaque élément d’un tableau consiste à utiliser une simple boucle Bash for.

fruits=("apple" "banana" "cherry")
for fruit in "${fruits(@)}"; do
echo "I like $fruit"
done

C’est idéal pour passer en revue les valeurs. Mais que se passe-t-il si vous avez également besoin des indices ? Pour cela, vous pouvez utiliser une boucle for de style C, comme ceci :

for ((i=0; i<${#fruits(@)}; i++)); do
echo "Fruit #$i is ${fruits($i)}"
done

C’est idéal si vous avez besoin à la fois de position et de valeur. Pour obtenir uniquement les indices, vous pouvez utiliser l'extension spéciale ${!array(@)}comme ça:

for index in "${!fruits(@)}"; do
echo "Index $index = ${fruits($index)}"
done

Cette technique est également pratique lorsque le tableau n'est pas séquentiel (par exemple, si certains éléments ont été supprimés). Si votre tableau provient de la sortie d'une commande, un while read la boucle peut être plus efficace ou plus propre.

printf '%sn' "${lines(@)}" | while read -r file; do
echo "Processing $file"
done

Cette approche est excellente lors de la lecture dynamique de données à partir de commandes ou de fichiers. Une autre astuce intéressante est que vous pouvez parcourir plusieurs tableaux ensemble. Voici un exemple :

names=("Alice" "Bob" "Charlie")
ages=(25 30 35)
for ((i=0; i echo "${names($i)} is ${ages($i)} years old"
done

Lorsque vous bouclez plusieurs tableaux ensemble, assurez-vous toujours qu’ils ont la même longueur.

Différents types de tableaux dans Bash

Les tableaux Bash existent en plusieurs variétés, et comprendre leurs différences vous aide à choisir le bon outil pour votre script. Bash prend en charge deux types de tableaux principaux :

1. Tableaux indexés : listes standards indexées par des nombres.

2. Tableaux associatifs : paires clé-valeur indexées par des chaînes.

Il existe également un type spécial à noter appelé tableaux clairsemés, dans lesquels les indices numériques ne sont pas séquentiels. Passons en revue chaque type.

Tableaux indexés

Les tableaux indexés sont le type le plus courant, parfaits lorsque vous souhaitez stocker des listes ordonnées telles que des noms de fichiers, des identifiants utilisateur ou des nombres. Chaque élément est identifié par un index entier commençant à 0.

fruits=("apple" "banana" "cherry")
echo "${fruits(0)}"
echo "${fruits(1)}"

Vous pouvez visualiser tous les éléments en même temps ou vérifier le nombre d'éléments :

echo "${fruits(@)}"
echo "${#fruits(@)}"

Les tableaux indexés sont utiles lorsque vous avez une liste avec un ordre naturel ou que vous souhaitez parcourir les résultats des commandes.

Tableaux associatifs

Les tableaux associatifs agissent comme des dictionnaires ou des cartes de hachage dans de nombreux autres langages. Ils vous permettent d'attribuer des valeurs à des clés de chaîne au lieu d'index numériques.

declare -A capitals=(
(France)="Paris"
(Italy)="Rome"
(Japan)="Tokyo"
)
echo "${capitals(France)}"

Vous pouvez les parcourir facilement :

for country in "${!capitals(@)}"; do
echo "$country → ${capitals($country)}"
done

Notez que l'ordre des clés dans les tableaux associatifs n'est pas défini. Si l'ordre est important, vous devrez les trier manuellement. Les tableaux associatifs sont utiles lorsque vous devez mapper des relations ou gérer des données au format JSON.

Tableaux clairsemés

Les tableaux clairsemés sont une fonctionnalité moins connue mais intéressante. Ce sont des tableaux indexés avec des lacunes dans leur numérotation. Vous pouvez attribuer des éléments à des index arbitraires. Bash ne nécessite pas qu'ils soient séquentiels.

numbers=()
numbers(2)=200
numbers(10)=1000
numbers(42)=4200
echo "${!numbers(@)}"

L'accès aux index non définis ne renverra rien :

echo "${numbers(5)}"

Vous pouvez toujours parcourir les éléments existants en toute sécurité. Si vous disposez d'un grand ensemble de données dans lequel tous les index ne sont pas utilisés, ou si vous travaillez avec des résultats qui comportent naturellement des « trous », alors la fonctionnalité clairsemée peut souvent être utile.

Accéder, modifier et supprimer des éléments de tableau

Une fois que vous avez déclaré et rempli un tableau, l'étape suivante consiste à apprendre à extraire les valeurs, à les mettre à jour et à les supprimer si nécessaire. Travailler avec des éléments de tableau dans Bash est simple, mais il convient de rappeler quelques comportements subtils.

Vous pouvez accéder à un élément par son index (pour les tableaux indexés) ou sa clé (pour les tableaux associatifs.) Pour les tableaux indexés :

fruits=("apple" "banana" "cherry")
echo "${fruits(0)}"
echo "${fruits(2)}"

Pour les tableaux associatifs :

declare -A capitals=(
(France)="Paris"
(Italy)="Rome"
(Japan)="Tokyo"
)
echo "${capitals(Japan)}"

Dans les deux cas, si l'index ou la clé n'a pas de valeur, vous obtenez une chaîne vide en sortie. Si vous souhaitez accéder à tous les éléments ou index en même temps, il existe des syntaxes spéciales. Voici une aide-mémoire que vous pouvez suivre.

Toutes les valeurs (fusionnées dans une chaîne) "${array(@)}"Citez toujours vos extensions :

. Les extensions sans guillemets peuvent être interrompues lorsque des éléments contiennent des espaces ou des caractères génériques.

fruits(1)="blackberry"
echo "${fruits(1)}"
fruits(1)="blueberry"
echo "${fruits(1)}"

Pour modifier un élément du tableau, il suffit de le réaffecter :

fruits+=("dragonfruit")

Vous pouvez également ajouter de nouveaux éléments :

capitals("France")="Paris"
echo "${capitals(France)}"
capitals("France")="Marseille"
echo "${capitals(France)}"

Pour les tableaux associatifs, vous réattribuez des valeurs aux clés.

La réattribution d'une valeur écrase l'ancienne, soyez donc prudent lorsque vous l'exécutez. unset Pour supprimer un élément, vous pouvez utiliser le

unset 'fruits(1)'
echo "${fruits(@)}"

commande. Il peut supprimer des éléments spécifiques ou l'ensemble du tableau.

unset 'fruits(0)' 'fruits(2)'

Pour supprimer plusieurs éléments :

unset fruits

Pour supprimer l'intégralité du tableau, transmettez simplement le nom du tableau :

unset 'capitals(France)'

Il en va de même pour les tableaux associatifs. Utilisez la commande unset et la clé (au lieu de l'index) pour supprimer cet élément.

Si vous souhaitez modifier ou supprimer plusieurs valeurs, utiliser une boucle for pour parcourir le tableau est une bonne idée.

Quelques astuces avancées en matière de tableaux

À présent, vous savez comment déclarer, parcourir et manipuler des tableaux. Cependant, Bash peut faire bien plus avec eux. Examinons quelques techniques de tableau avancées qui peuvent rendre vos scripts plus intelligents et plus faciles à maintenir.

Tranchage

${array(@):start:length}

Vous pouvez extraire des sous-ensembles de tableaux à l’aide de la syntaxe slice.

numbers=(10 20 30 40 50)
echo "${numbers(@):1:3}"

Ici, start fait référence au premier élément de la tranche, tandis que length fait référence au nombre d'éléments que vous souhaitez conserver dans le sous-ensemble. Notez que les tableaux Bash ont une indexation basée sur 0. Exemple:

Nous avons les trois éléments du milieu puisque nous avons découpé à partir de l'index un. Ceci est utile lorsque vous souhaitez traiter une partie des résultats d'une commande.

Copier et combiner

copy=("${fruits(@)}")

Copier un tableau nécessite simplement d'attribuer les éléments du tableau à un autre nouveau tableau.

Bash copie les tableaux par valeur et non par référence. Ainsi, modifier « copie » n’affectera pas l’original.

numbers=(1 2 3)
more_numbers=(4 5 6)
combined=("${numbers(@)}" "${more_numbers(@)}")
echo "${combined(@)}"

Pour fusionner deux ou plusieurs tableaux en un seul, vous transmettez leurs éléments à un nouveau tableau en utilisant la syntaxe d'expansion.

Tri

fruits=("banana" "apple" "cherry" "date")
IFS=$'n' sorted=($(sort unset IFS
echo "${sorted(@)}"

Trier un tableau signifie le réorganiser dans un ordre spécifique. Cela peut être numérique ou alphabétique (selon le type d'élément), croissant ou décroissant. Bash n'a pas de fonction de tri intégrée, mais elle est facile à réaliser avec la substitution de commande et la commande de tri. IFS=$'n' Ici, la commande sort trie les éléments par ordre alphabétique.

garantit que les éléments contenant des espaces ne sont pas divisés de manière incorrecte. Nous stockons la sortie triée dans un nouveau tableau.

IFS=$'n' sorted=($(sort -r unset IFS

De même, nous pouvons également effectuer un tri inversé. sort -nDans le cas de données numériques, vous pouvez utiliser

numbers=(42 5 19 100 3)
IFS=$'n' sorted_nums=($(sort -n unset IFS
echo "${sorted_nums(@)}"

.

Supprimer les doublons

numbers=(1 2 2 3 4 3 5)
unique=($(printf "%sn" "${numbers(@)}" | sort -u))
echo "${unique(@)}"

Un problème classique. Supprimez tous les éléments en double dans le tableau afin que tous les éléments restants soient uniques. Nous pouvons à nouveau bénéficier de l’aide de la commande sort.

Cette approche fonctionne en imprimant tous les éléments, en les triant et en supprimant les doublons avec -u. Cependant, cette méthode dépend de l'ordre. Il trie votre tableau au cours du processus. Si vous devez conserver l'ordre d'origine, vous devrez boucler et suivre manuellement les éléments vus.

Filtrage des tableaux

files=("data.txt" "image.png" "notes.txt" "script.sh")
txt_files=()
for f in "${files(@)}"; do
(( $f == *.txt )) && txt_files+=("$f")
done
echo "${txt_files(@)}"

La dernière astuce que j'aimerais aborder consiste à filtrer les éléments d'un tableau. Nous ferons cela en utilisant la correspondance de modèles et l’expansion des paramètres.

---

Cette astuce est simple mais puissante lors de la gestion de listes de fichiers ou d'ensembles de données mixtes.