Comprendre les tableaux multidimensionnels en PHP

Un tableau multidimensionnel en PHP est un tableau dont les éléments sont eux-mêmes des tableaux. Alors qu'un tableau classique (indexé ou associatif) associe chaque clé à une valeur unique, un tableau multidimensionnel associe chaque clé à tout un tableau imbriqué — ce qui permet de modéliser des données en lignes et colonnes, des grilles, des arbres et des enregistrements groupés.

Ce chapitre explique comment créer des tableaux à deux dimensions et au-delà, comment lire et mettre à jour des cellules individuelles, comment les parcourir avec foreach, et les fonctions les plus courantes pour les transformer. Il signale également les pièges qui guettent ceux qui passent des tableaux plats aux tableaux imbriqués.

Qu'est-ce qu'un tableau multidimensionnel ?

Un tableau devient multidimensionnel dès qu'une de ses valeurs est elle-même un tableau. La dimension (ou profondeur) correspond au nombre d'opérations d'indexation nécessaires pour atteindre une valeur scalaire :

• $a[0] atteint une valeur → unidimensionnel
• $a[0][1] atteint une valeur → bidimensionnel
• $a[0][1][2] atteint une valeur → tridimensionnel, et ainsi de suite.

Un tableau à deux dimensions est souvent représenté comme un tableau : le tableau externe contient les lignes, et chaque tableau interne contient les colonnes de cette ligne. Ce modèle mental est utile, mais rappelons que les tableaux PHP sont des maps ordonnées, pas des grilles rigides — les lignes peuvent avoir des longueurs différentes et les clés peuvent être des chaînes plutôt que 0, 1, 2. Il n'y a pas de limite fixe à la profondeur, même si des données fortement imbriquées indiquent généralement qu'il vaudrait mieux utiliser des objets ou une base de données.

Créer un tableau multidimensionnel

La façon la plus courante est d'imbriquer des littéraux de tableaux. Chaque tableau interne est un élément du tableau externe.

Un tableau 2D de chaînes (une grille)

$grid = [
    ["value1", "value2", "value3"],
    ["value4", "value5", "value6"],
    ["value7", "value8", "value9"],
];

Dans du code réel, les tableaux internes sont généralement associatifs, de sorte que chaque ligne ressemble à un enregistrement :

Une liste d'enregistrements

$employees = [
    ["name" => "Ann",  "title" => "Engineer", "salary" => 65000],
    ["name" => "Bob",  "title" => "Designer", "salary" => 58000],
    ["name" => "Cara", "title" => "Manager",  "salary" => 72000],
];

Vous pouvez également le construire de façon incrémentale, ce qui est pratique lorsque les données proviennent d'une boucle ou d'une requête de base de données :

$matrix = [];
$matrix[0][0] = 1;
$matrix[0][1] = 2;
$matrix[1][0] = 3;
$matrix[1][1] = 4;
// $matrix is now [[1, 2], [3, 4]]

Accéder aux éléments

Ajoutez un jeu de crochets par dimension. Le premier index sélectionne l'élément externe (la ligne) ; le second sélectionne l'élément interne (la colonne) :

echo $grid[1][2];          // "value6" — row 1, column 2
echo $employees[2]["name"]; // "Cara"

PHP est indexé à partir de zéro, donc la deuxième ligne est [1] et la troisième colonne est [2]. La lecture d'une clé inexistante génère un avertissement et renvoie null ; utilisez isset() ou l'opérateur de fusion null pour rester en sécurité :

$salary = $employees[5]["salary"] ?? 0; // no warning if the row is missing

Parcourir un tableau multidimensionnel

Les boucles foreach imbriquées sont la méthode idiomatique pour parcourir un tableau 2D — la boucle externe visite chaque ligne, la boucle interne visite les valeurs de cette ligne :

$employees = [
    ["name" => "Ann",  "salary" => 65000],
    ["name" => "Bob",  "salary" => 58000],
];

foreach ($employees as $row) {
    foreach ($row as $key => $value) {
        echo "$key: $value\n";
    }
    echo "---\n";
}

Pour les enregistrements tabulaires, il est souvent plus lisible de déstructurer directement les clés internes :

foreach ($employees as $emp) {
    echo "{$emp['name']} earns {$emp['salary']}\n";
}
// Ann earns 65000
// Bob earns 58000

Modifier des éléments

Assignez via le chemin d'index complet pour mettre à jour une cellule, et ajoutez une nouvelle ligne avec [] ou array_push() :

$employees[0]["salary"] = 70000;        // update one field
$employees[] = ["name" => "Dan", "salary" => 60000]; // add a row
array_pop($employees);                   // remove the last row

array_pop() supprime et retourne la dernière ligne, donc les deux opérations ci-dessus s'annulent.

Transformer avec array_map et array_column

array_map() applique un callback à chaque élément. Pour transformer chaque cellule, mappez un array_map interne sur chaque ligne :

Mettre en majuscules toutes les valeurs d'un tableau 2D

$grid = [["a", "b"], ["c", "d"]];

$upper = array_map(function ($row) {
    return array_map("strtoupper", $row);
}, $grid);
// $upper is [["A", "B"], ["C", "D"]]

Lorsque les tableaux internes sont des enregistrements, array_column() extrait un seul champ de chaque ligne dans un tableau plat — idéal pour extraire une colonne :

$employees = [
    ["name" => "Ann", "salary" => 65000],
    ["name" => "Bob", "salary" => 58000],
];

$names = array_column($employees, "name"); // ["Ann", "Bob"]
$total = array_sum(array_column($employees, "salary")); // 123000

Pièges courants

• Indices décalés d'un. $grid[1][2] est la deuxième ligne, troisième colonne — les deux indices sont à base zéro.
• Confusion dans l'ordre des indices. $employees[0]["name"] fonctionne ; $employees["name"][0] non, car le tableau externe est indexé par des entiers.
• Clés indéfinies. L'accès à une ligne ou colonne manquante émet un avertissement et retourne null. Protégez-vous avec isset() ou ?? valeur_par_défaut.
• Fonctions nécessitant la récursion. count($arr) ne compte que le premier niveau — utilisez count($arr, COUNT_RECURSIVE). Pour parcourir chaque feuille, utilisez array_walk_recursive() plutôt que array_walk().
• Sémantique de copie. Les tableaux PHP sont copiés par valeur, donc $copy = $original; suivi d'une modification de $copy[0][0] ne change pas $original — contrairement aux références d'objets.

Conclusion

Les tableaux multidimensionnels vous permettent de représenter des tables, des grilles et des enregistrements groupés en imbriquant un tableau dans un autre. Lisez et écrivez des cellules individuelles avec des indices [] chaînés, itérez avec des boucles foreach imbriquées, et restructurez les données avec array_map(), array_column() et les fonctions de tableau récursives. Pour un tour d'horizon plus complet des outils de tableau PHP, consultez PHP Arrays.

Pratique