Opérations sur le tableau Bash : longueur, recherche, tranche et inverse

Une fois que vous savez comment déclarer un tableau Bash, les tâches suivantes consistent généralement à trouver sa longueur, à vérifier s’il contient une valeur, à extraire une tranche ou à modifier l’ordre des éléments. Bash prend en charge toutes ces opérations, mais la syntaxe d’expansion peut être difficile à retenir.

Ce guide couvre les opérations sur les tableaux indexés que vous utiliserez le plus souvent dans les scripts. Pour la déclaration de tableau, l’accès aux éléments et les tableaux associatifs, commencez par le guide des tableaux Bash.

Exemple de tableau #

Les exemples utilisent le tableau suivant :

fruits=("apple" "banana" "dragon fruit" "date" "elderberry")

Chaque valeur citée est un élément, y compris dragon fruitet les indices vont de 0 à travers 4.

Obtenir la longueur du tableau #

Utiliser ${#name(@)} pour obtenir le nombre d’éléments :

echo "${#fruits(@)}"

5

Le résultat est 5 car le tableau contient cinq éléments. ${#name(*)} renvoie le même décompte, mais @ est la valeur par défaut la plus sûre pour les autres opérations sur les tableaux car elle préserve les éléments individuels lorsqu’ils sont cités.

Pour obtenir la longueur des caractères d’un élément, incluez son index :

echo "${#fruits(1)}"

6

Cela compte les six caractères dans bananapas le nombre d’éléments du tableau.

Vérifier si un tableau contient une valeur #

Bash n’a pas de module intégré contains opérateur. L’approche fiable consiste à parcourir les éléments et à comparer chacun d’eux avec la valeur cible :

contains() {
 local target=$1
 shift

 local element
 for element in "$@"; do
 if (( $element == "$target" )); then
 return 0
 fi
 done

 return 1
}

if contains "dragon fruit" "${fruits(@)}"; then
 echo "found"
else
 echo "not found"
fi

found

La fonction renvoie le statut 0 quand il trouve une correspondance et un statut exacts 1 sinon. Passage "${fruits(@)}" conserve intactes les valeurs contenant des espaces.

Évitez de joindre le tableau en une seule chaîne et de le tester avec une expression régulière. Ce raccourci peut signaler de fausses correspondances lorsqu’un terme de recherche apparaît à l’intérieur d’un autre élément ou lorsque des éléments contiennent le séparateur choisi.

Découper un tableau #

Le découpage de tableau utilise l’expansion suivante :

${name(@):offset:length}

offset sélectionne l’endroit où commence la tranche, et length est le nombre d’éléments à retourner. Cet exemple prend trois éléments commençant à l’index 1:

slice=("${fruits(@):1:3}")
printf '<%s>\n' "${slice(@)}"

<banana>
<dragon fruit>
<date>

L’attribution du résultat à un autre tableau préserve les trois valeurs en tant qu’éléments distincts.

Un décalage négatif compte à partir de la fin. Ajoutez un espace avant le nombre négatif pour que Bash n’analyse pas :- comme opérateur de valeur par défaut :

last_two=("${fruits(@): -2}")
printf '<%s>\n' "${last_two(@)}"

<date>
<elderberry>

Omettre length pour prendre chaque élément restant du décalage jusqu’à la fin.

Inverser un tableau #

Bash ne fournit pas d’opérateur inverse. La boucle suivante lit les indices du tableau à partir de la fin et ajoute chaque valeur à un nouveau tableau :

indices=("${!fruits(@)}")
reversed=()

for ((i=${#indices(@)} - 1; i >= 0; i--)); do
 reversed+=("${fruits(${indices(i)})}")
done

printf '<%s>\n' "${reversed(@)}"

<elderberry>
<date>
<dragon fruit>
<banana>
<apple>

L’utilisation de la liste d’index réelle permet à ce modèle de fonctionner à la fois avec des tableaux contigus et des tableaux clairsemés qui présentent des espaces entre les indices.

Des outils tels que rev et tac résoudre différents problèmes. rev inverse les caractères sur chaque ligne d’entrée, tandis que tac inverse l’ordre des lignes. Ni l’un ni l’autre n’opère directement sur les éléments du tableau Bash.

Itérer sur les valeurs et les indices #

Lorsque vous n’avez besoin que des valeurs, développez le tableau avec "${name(@)}":

for fruit in "${fruits(@)}"; do
 echo "$fruit"
done

Citer l’expansion garantit que dragon fruit reste un élément de boucle.

Lorsque vous avez besoin à la fois de l’index et de la valeur, utilisez ${!name(@)} pour développer la liste d’index :

for i in "${!fruits(@)}"; do
 echo "$i: ${fruits(i)}"
done

0: apple
1: banana
2: dragon fruit
3: date
4: elderberry

L’itération sur les index est utile lorsque vous devez mettre à jour des éléments en place ou préserver les espaces dans un tableau clairsemé.

Ajouter et ajouter des éléments #

Ajoutez un ou plusieurs éléments avec le += opérateur:

fruits+=("fig" "grape")

Les nouvelles valeurs reçoivent les prochains indices disponibles à la fin du tableau.

Pour ajouter une valeur au début, créez d’abord une nouvelle extension de tableau avec le nouvel élément :

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

Cette affectation reconstruit le tableau avec des indices contigus commençant à 0.

Vous pouvez également attribuer une valeur à un index spécifique :

fruits(10)="kiwi"

Cela crée un tableau clairsemé si les indices 7 à travers 9 n’existent pas.

Supprimer des éléments du tableau #

Utiliser unset avec un index pour supprimer un élément :

unset 'fruits(2)'

Citez l’argument afin que les crochets ne soient pas traités comme un modèle de nom de fichier. Les éléments restants conservent leurs indices d’origine, ce qui laisse un espace où l’index 2 a été supprimé.

Pour reconstruire le tableau avec des indices contigus, réaffectez-lui ses valeurs actuelles :

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

Cela préserve les valeurs et les renumérote de 0.

Pour supprimer l’intégralité du tableau, transmettez uniquement son nom :

unset fruits

Référence rapide #

Pour une référence rapide imprimable, consultez l’aide-mémoire Bash .

Pièges courants #

Utilisez toujours des accolades lorsque vous accédez à un élément indexé. $fruits(1) se développe $fruits puis imprime le texte littéral (1)alors que ${fruits(1)} développe l’élément à l’index 1.

Entre guillemets doubles, "${fruits(@)}" développe chaque élément sous la forme d’un mot distinct. "${fruits(*)}" joint tous les éléments en une seule chaîne en utilisant le premier caractère de IFS. Utilisez le @ formulaire pour les boucles, les arguments de fonction, les copies et la plupart des autres opérations sur les tableaux.

Ne présumez pas que les indices de tableau sont contigus après avoir utilisé unset ou attribuer un index distant. Répéter "${!fruits(@)}" lorsque les valeurs réelles de l’indice comptent.

Conclusion #

Les extensions de tableau Bash couvrent les vérifications de longueur, les tranches, l’itération d’index et la plupart des mises à jour quotidiennes. Utilisation citée @ extensions pour préserver les limites des éléments et parcourir la liste d’index réelle lorsqu’un tableau peut contenir des espaces.