Les shells Unix (comme bash, zsh, sh) n'ont pas de tableaux de la même manière que les langages de niveau supérieur comme Python ou C++. Ils gèrent les tableaux d'une manière moins structurée, généralement en utilisant des chaînes séparées par des espaces ou des techniques spéciales. Voici comment travailler avec des structures de type tableau dans différents contextes de shell Unix :
1. Chaînes séparées par des espaces :
C'est la méthode la plus simple. Vous stockez essentiellement les éléments sous forme de chaîne unique, séparés par des espaces (ou d'autres délimiteurs de votre choix). L'accès à des éléments individuels nécessite une manipulation de chaîne.
```bash
my_array="pomme banane cerise"
Accès au premier élément (en supposant une séparation des espaces) :
first_element="${my_array%% *}" #Supprime tout à partir du premier espace.
echo "$first_element" # Sortie :pomme
Accéder au deuxième élément :
second_element="${my_array#* }" #Supprime tout jusqu'au premier espace.
second_element="${second_element%% *}" #Supprime tout à partir du premier espace
echo "$second_element" # Sortie :banane
#Itération (moins efficace) :
pour les fruits dans $my_array ; faire
écho "$fruit"
fait
```
Limites : Cette approche est sujette aux erreurs si les éléments du tableau contiennent eux-mêmes des espaces.
2. Utilisation de tableaux dans bash (et d'autres shells prenant en charge les tableaux) :
Bash (et certains autres shells modernes) offrent une prise en charge de tableau plus robuste.
```bash
Déclarer un tableau
my_array=("pomme" "banane" "cerise")
Accéder aux éléments :
echo "${my_array[0]}" # Sortie :pomme
echo "${my_array[1]}" # Sortie :banane
Obtenir la longueur du tableau :
echo "${#my_array[@]}" # Sortie :3
Itération :
pour moi dans "${!my_array[@]}" ; faire #Itérer à travers les indices
echo "${my_array[i]}"
fait
Ou parcourez directement les éléments :
pour les fruits dans "${my_array[@]}" ; faire
écho "$fruit"
fait
#Ajout d'éléments :
mon_array+=("date")
echo "${my_array[3]}" #Sortie :date
#Ajout au tableau :
my_array+=(raisin orange)
#Suppression d'éléments (moins simple, nécessite un déplacement) :
unset 'my_array[1]' #supprime l'élément à l'index 1 (banane)
#Notez que les indices ne diminuent pas automatiquement. Il n'y a pas de décalage intégré après la suppression.
Imprimer le tableau modifié :
pour les fruits dans "${my_array[@]}" ; faire
écho "$fruit"
fait
```
Considérations importantes :
* Citation : Citez toujours les variables du tableau (par exemple, `"${my_array[@]}"`) pour éviter le fractionnement et la globalisation des mots, ce qui peut entraîner un comportement inattendu. Ceci est particulièrement critique lorsque les éléments du tableau peuvent contenir des espaces ou des caractères spéciaux.
* Indice 0 : Les tableaux dans bash sont indexés 0, ce qui signifie que le premier élément est à l'index 0.
* Spécifique au Shell : La syntaxe et les fonctionnalités disponibles pour les tableaux peuvent varier légèrement en fonction du shell spécifique que vous utilisez (bash, zsh, ksh, etc.).
3. Utilisation d'outils de ligne de commande pour les opérations de type tableau :
Pour des manipulations de tableaux plus complexes (tri, filtrage, etc.), vous trouverez souvent plus efficace d'utiliser des utilitaires de ligne de commande externes comme « awk », « sed » ou « sort ». Ces outils excellent dans le traitement de texte, qui peut être adapté pour fonctionner avec des données structurées sous forme de chaînes délimitées.
Par exemple, pour trier les éléments d'une chaîne séparée par des espaces :
```bash
my_array="pomme banane cerise"
echo "$mon_tableau" | tr ' '\n' | trier | tr '\n' ' '
```
En résumé, bien que les shells Unix n'aient pas de structures de tableaux riches et intégrées comme d'autres langages, la prise en charge des tableaux par bash est adéquate pour de nombreuses tâches. Pour les manipulations complexes, envisagez de tirer parti de la puissance des utilitaires de traitement de texte. N'oubliez pas de toujours citer correctement les variables de votre tableau pour éviter les erreurs potentielles.
|