Caoua

——————————————-
Gestion « classique » des tableaux avec bash
——————————————-

En Bash, la gestion des tableaux est un peu particulière par rapport à d’autres langages (comme JavaScript ou Python), mais elle est très puissante une fois qu’on a pigé la syntaxe.

Voici le guide complet pour déclarer, manipuler et parcourir des tableaux en Bash.

1. Déclarer un tableau

Il existe deux types de tableaux en Bash : les tableaux indexés (avec des numéros 0, 1, 2...) et les tableaux associatifs (avec des clés textuelles, comme un dictionnaire).

Tableaux indexés (Classiques)

On utilise des parenthèses () et les éléments sont séparés par des espaces (pas de virgules !).

Bash

# Méthode 1 : Déclaration directe
mon_tableau=("pomme" "banane" "orange")

# Méthode 2 : Élément par élément
autre_tableau[0]="voiture"
autre_tableau[1]="moto"

Tableaux associatifs (Clés / Valeurs)

Disponible à partir de Bash 4. Il faut impérativement le déclarer explicitement avec declare -A.

Bash

declare -A capitales
capitales[France]="Paris"
capitales[Espagne]="Madrid"
capitales[Italie]="Rome"

2. Lire les valeurs (La syntaxe essentielle)

C’est là que Bash devient un peu verbeux. Pour accéder au contenu, il faut toujours utiliser des accolades {} et le symbole $.

Accéder à un élément précis

Bash

echo "${mon_tableau[0]}"  # Affiche : pomme
echo "${capitales[France]}" # Affiche : Paris

Afficher TOUT le tableau

On utilise le symbole @ ou *.

Bash

echo "${mon_tableau[@]}"  # Affiche : pomme banane orange

Connaître la taille (le nombre d’éléments)

On ajoute un hashtag # devant le nom du tableau.

Bash

echo "${#mon_tableau[@]}" # Affiche : 3

3. Ajouter ou modifier des éléments

  • Modifier un élément existant : On réassigne simplement la valeur à l’index voulu.
  • Ajouter à la fin d’un tableau indexé : On utilise l’opérateur +=.

Bash

# Modifier le deuxième élément (index 1)
mon_tableau[1]="fraise"

# Ajouter un élément à la fin
mon_tableau+=("mangue") 

echo "${mon_tableau[@]}" # Affiche : pomme fraise orange mangue

4. Parcourir un tableau (Boucles)

C’est l’utilisation la plus fréquente. On utilise une boucle for.

Boucler sur les VALEURS

Bash

fruits=("pomme" "banane" "orange")

for fruit in "${fruits[@]}"; do
    echo "J'aime les ${fruit}s"
done

Boucler sur les CLÉS / INDEX

On ajoute un point d’exclamation ! devant le nom du tableau pour récupérer les index (ou les clés d’un tableau associatif).

Bash

declare -A capitales=([France]="Paris" [Italie]="Rome")

for pays in "${!capitales[@]}"; do
    echo "La capitale de : $pays est ${capitales[$pays]}"
done

5. Supprimer des éléments

On utilise la commande unset.

Bash

# Supprimer un élément précis (attention, cela crée un "trou" dans les index)
unset mon_tableau[1]

# Supprimer TOUT le tableau
unset mon_tableau

⚠️ Piège classique en Bash : Si tu oublies les guillemets autour de "${mon_tableau[@]}", Bash va découper tes éléments s’ils contiennent des espaces. Prends la bonne habitude de toujours mettre des guillemets doubles !

——————————————-
les faux tableaux en 3D avec BASH
——————————————-

Bash ne supporte pas nativement les tableaux multidimensionnels (2D, 3D, etc.). Un tableau en Bash est strictement à une seule dimension (une liste simple).

Cependant, les codeurs ont de la ressource. Pour simuler un tableau en 3 dimensions (par exemple pour stocker des coordonnées $X, Y, Z$ ou une matrice), on utilise une astuce : les tableaux associatifs avec des clés combinées.

Voici comment faire pour simuler et gérer de la 3D en Bash.

1. Déclarer et remplir le tableau 3D

Imaginons que l’on veuille stocker la température de plusieurs pièces d’un bâtiment à différents étages.

  • Dimension 1 : Le bâtiment (BatA, BatB)
  • Dimension 2 : L’étage (Etage0, Etage1)
  • Dimension 3 : La pièce (Room1, Room2)

Bash

#!/bin/bash

# 1. On déclare un tableau associatif
declare -A matrice3D

# 2. On remplit en combinant les 3 dimensions dans la clé, séparées par un caractère (ici un haricot/pipe '|')
matrice3D["BatA|Etage0|Room1"]=19
matrice3D["BatA|Etage0|Room2"]=21
matrice3D["BatA|Etage1|Room1"]=20
matrice3D["BatB|Etage0|Room1"]=17

# 3. Accéder à une valeur précise
echo "Température BatA, Etage 1, Room 1 : ${matrice3D["BatA|Etage1|Room1"]}°C"

2. Parcourir ce tableau « 3D »

Pour lire toutes les données, on va boucler sur les clés, puis utiliser la commande cut (ou les expressions régulières de Bash) pour « séparer » nos trois dimensions.

Bash

for cle in "${!matrice3D[@]}"; do
    # On extrait chaque dimension grâce au séparateur "|"
    batiment=$(echo "$cle" | cut -d'|' -f1)
    etage=$(echo "$cle" | cut -d'|' -f2)
    piece=$(echo "$cle" | cut -d'|' -f3)
    
    valeur=${matrice3D[$cle]}
    
    echo "Au $batiment, à l'$etage, la $piece a une température de $valeur°C."
done

Alternative : La boucle imbriquée classique

Si tu veux créer un cube de données (par exemple de taille 3x3x3 u peux utiliser trois boucles for imbriquées pour générer tes clés automatiquement :

Bash

declare -A cube

# Remplissage automatique du cube 3D (3x3x3)
for x in {1..3}; do
    for y in {1..3}; do
        for z in {1..3}; do
            # On stocke une valeur (ici la somme des coordonnées)
            cube["$x,$y,$z"]=$((x + y + z))
        done
    done
done

# Lire une coordonnée spécifique
echo "Valeur en position (2,3,1) : ${cube["2,3,1"]}"

————————————–
Fonction avec 3 paramètres : nom du fichier à créer, caractère à remplir, nombre d’octets
—————————————

Bash

create_filler_file() {
    # 1. Récupération et validation des paramètres
    local fichier="$1"
    local caractere="$2"
    local taille="$3"

    # Petite sécurité : on vérifie que les 3 paramètres sont là
    if [ -z "$fichier" ] || [ -z "$caractere" ] || [ -z "$taille" ]; then
        echo "Erreur : Paramètres manquants."
        echo "Usage: create_filler_file <nom_fichier> <caractère> <taille_en_octets>"
        return 1
    fi

    # 2. Génération du fichier
    # printf va générer une suite de zéros (\0) de la taille demandée
    # tr va remplacer tous ces zéros par le caractère choisi
    printf '\0%.0s' $(seq 1 "$taille") | tr '\0' "$caractere" > "$fichier"

    echo "Fichier '$fichier' ($taille octets remplis de '$caractere') créé."
}

Comment l’utiliser ?

Une fois la fonction chargée dans ton terminal (ou dans ton script), tu l’appelles exactement dans l’ordre que tu as demandé :

Bash

# Crée un fichier "test.txt" de 10 octets rempli de 'A'
create_filler_file "test.txt" "A" 10

# Crée un fichier de 2 Mo (2097152 octets) rempli de 'X'
create_filler_file "gros_test.dat" "X" 2097152

Comment ça fonctionne sous le capot ?

L’astuce réside dans la ligne centrale :

  1. seq 1 "$taille" : Génère une liste de nombres de 1 jusqu’à la taille demandée (par exemple 10). Cela sert juste de « compteur ».
  2. printf '\0%.0s' : C’est une feinte de sioux. Pour chaque nombre généré par seq, printf va afficher un octet nul (\0). Le %.0s sert à masquer le nombre lui-même pour ne garder que l’octet vide. On obtient donc une chaîne invisible de $X$ octets nuls.
  3. | tr '\0' "$caractere" : Le « pipe » (|) envoie ces octets nuls à la commande tr (Translate), qui remplace instantanément chaque octet nul par ton caractère (le « A » ou le « X »).
  4. > "$fichier" : Redirige le résultat final dans le fichier.

C’est très propre, et contrairement à d’autres méthodes, ça n’ajoute pas de saut de ligne (\n) invisible à la fin du fichier. Le fichier fera exactement le nombre d’octets demandé.