Les tableaux en PHP : indexés, associatifs et fonctions utiles
Le tableau en PHP est sans doute la structure de données la plus utilisée du langage. Résultats d’une requête SQL, données d’un formulaire, configuration, panier d’e-commerce : tout finit tôt ou tard dans un tableau. La bonne nouvelle, c’est que PHP en fait un outil extrêmement souple, avec des centaines de fonctions dédiées. Ce guide couvre l’essentiel, de la création aux fonctions les plus utiles au quotidien.
Créer un tableau en PHP
Il existe deux syntaxes pour créer un tableau. La syntaxe courte avec crochets [] est celle recommandée aujourd’hui ; la fonction array() reste valide et fréquente dans le code plus ancien.
<?php
// Syntaxe moderne recommandée
$fruits = ["pomme", "banane", "cerise"];
// Ancienne syntaxe équivalente
$fruits = array("pomme", "banane", "cerise");
// Un tableau vide, à remplir ensuite
$panier = [];
Les deux produisent exactement le même résultat. Dans la suite, nous utiliserons la syntaxe [].
Tableaux indexés vs tableaux associatifs
C’est la distinction fondamentale à comprendre en PHP.
Le tableau indexé
Un tableau indexé utilise des clés numériques automatiques, qui commencent à 0. Vous accédez à chaque valeur par sa position.
<?php
$couleurs = ["rouge", "vert", "bleu"];
echo $couleurs[0]; // rouge
echo $couleurs[1]; // vert
echo $couleurs[2]; // bleu
Le tableau associatif
Un tableau associatif utilise des clés textuelles que vous définissez vous-même. Il est parfait pour représenter une entité avec des propriétés nommées.
<?php
$utilisateur = [
"nom" => "Dupont",
"age" => 34,
"email" => "[email protected]",
];
echo $utilisateur["nom"]; // Dupont
echo $utilisateur["email"]; // [email protected]
En pratique, PHP ne fait pas de différence technique stricte entre les deux : un même tableau peut mélanger clés numériques et textuelles. Mais garder les deux usages séparés rend votre code beaucoup plus lisible.
Parcourir un tableau avec foreach
La boucle foreach est l’outil de référence pour parcourir un tableau, quel que soit son type.
<?php
// Tableau indexé : on récupère chaque valeur
$couleurs = ["rouge", "vert", "bleu"];
foreach ($couleurs as $couleur) {
echo $couleur . "<br>";
}
// Tableau associatif : on récupère clé ET valeur
$utilisateur = ["nom" => "Dupont", "age" => 34];
foreach ($utilisateur as $cle => $valeur) {
echo "$cle : $valeur <br>";
}
La forme as $cle => $valeur fonctionne aussi sur les tableaux indexés, où $cle vaut alors 0, 1, 2… La boucle for classique reste possible sur un tableau indexé, mais foreach est presque toujours plus clair.
Ajouter et supprimer des éléments
Ajouter une valeur
<?php
$fruits = ["pomme", "banane"];
// Ajouter à la fin, méthode la plus courante
$fruits[] = "cerise"; // ["pomme", "banane", "cerise"]
// Ajouter avec array_push (accepte plusieurs valeurs)
array_push($fruits, "kiwi", "mangue");
// Ajouter au début du tableau
array_unshift($fruits, "abricot");
// Ajouter une clé associative
$fruits["exotique"] = "ananas";
Supprimer une valeur
<?php
$fruits = ["pomme", "banane", "cerise"];
// Retirer le dernier élément (et le récupérer)
$dernier = array_pop($fruits); // "cerise"
// Retirer le premier élément
$premier = array_shift($fruits); // "pomme"
// Supprimer par sa clé précise
$data = ["a" => 1, "b" => 2, "c" => 3];
unset($data["b"]); // ["a" => 1, "c" => 3]
Attention avec unset sur un tableau indexé : il supprime la clé mais ne réindexe pas les suivantes. Pour renuméroter proprement de 0 à n, utilisez array_values($tableau).
Les fonctions de tableau indispensables
PHP propose des dizaines de fonctions array_*. Voici celles que vous utiliserez vraiment tous les jours.
array_map : transformer chaque élément
array_map applique une fonction à chaque valeur et renvoie un nouveau tableau.
<?php
$prix = [10, 20, 30];
$prixTTC = array_map(fn($p) => $p * 1.20, $prix);
// [12, 24, 36]
array_filter : ne garder que certains éléments
array_filter conserve les valeurs pour lesquelles la fonction renvoie true.
<?php
$nombres = [1, 2, 3, 4, 5, 6];
$pairs = array_filter($nombres, fn($n) => $n % 2 === 0);
// [1 => 2, 3 => 4, 5 => 6] (les clés sont préservées)
Notez que les clés d’origine sont conservées. Enveloppez le résultat dans array_values() si vous voulez repartir d’un index propre.
array_merge : fusionner des tableaux
<?php
$a = ["pomme", "banane"];
$b = ["cerise", "kiwi"];
$tout = array_merge($a, $b);
// ["pomme", "banane", "cerise", "kiwi"]
Pour les tableaux associatifs, en cas de clé identique, c’est la valeur du second tableau qui l’emporte.
sort et ses variantes : trier
<?php
$notes = [12, 5, 20, 8];
sort($notes); // tri croissant : [5, 8, 12, 20]
rsort($notes); // tri décroissant : [20, 12, 8, 5]
// Trier un tableau associatif en gardant les clés
$ages = ["Léa" => 28, "Max" => 19, "Zoé" => 45];
asort($ages); // trie par valeur : Max, Léa, Zoé
ksort($ages); // trie par clé : Léa, Max, Zoé
in_array et array_search : chercher
<?php
$fruits = ["pomme", "banane", "cerise"];
var_dump(in_array("banane", $fruits)); // bool(true)
$position = array_search("cerise", $fruits); // 2
Utilisez toujours ces fonctions avec le troisième argument true (comparaison stricte) quand vous cherchez dans un tableau contenant des nombres, pour éviter les surprises de comparaison de types.
Autres fonctions à connaître
<?php
$data = ["a" => 1, "b" => 2, "c" => 3];
count($data); // 3 — nombre d'éléments
array_keys($data); // ["a", "b", "c"]
array_values($data); // [1, 2, 3]
array_key_exists("a", $data); // true
implode(", ", [1, 2, 3]); // "1, 2, 3" — tableau vers chaîne
explode(",", "x,y,z"); // ["x", "y", "z"] — chaîne vers tableau
array_sum([10, 20, 30]); // 60
array_unique([1, 1, 2, 3, 3]); // [1, 2, 3]
Les tableaux multidimensionnels
Un tableau peut contenir d’autres tableaux : on parle alors de tableau multidimensionnel. C’est ainsi qu’on représente une liste d’enregistrements, par exemple des utilisateurs venus d’une base de données.
<?php
$utilisateurs = [
["nom" => "Dupont", "ville" => "Nantes"],
["nom" => "Martin", "ville" => "Lyon"],
["nom" => "Bernard", "ville" => "Paris"],
];
// Accéder à une valeur précise
echo $utilisateurs[1]["ville"]; // Lyon
// Parcourir la structure
foreach ($utilisateurs as $u) {
echo "{$u['nom']} habite {$u['ville']}<br>";
}
Pour manipuler ce genre de structure, array_map et array_filter restent vos meilleurs alliés :
<?php
// Extraire uniquement les noms
$noms = array_map(fn($u) => $u["nom"], $utilisateurs);
// ["Dupont", "Martin", "Bernard"]
// Ne garder que les habitants de Lyon
$lyonnais = array_filter($utilisateurs, fn($u) => $u["ville"] === "Lyon");
En résumé
Le tableau PHP couvre à lui seul une énorme partie des besoins courants : listes, dictionnaires clé-valeur, structures imbriquées. Retenez les réflexes essentiels : [] pour créer, foreach pour parcourir, $tab[] = pour ajouter, et les fonctions array_map, array_filter, array_merge et sort pour transformer sans écrire de boucles à la main. Une fois ces bases acquises, les données de vos applications deviennent bien plus simples à traiter.