> Maîtriser les tableaux en PHP : création, tableaux indexés et associatifs, parcours avec foreach, ajout, suppression et les fonctions array indispensables. Guide complet avec exemples.

*Source : https://coder-studio.com/tutoriels/tableaux-php/*

---

[// PHP](https://coder-studio.com/tutoriels/)

# Les tableaux en PHP : indexés, associatifs et fonctions utiles

Par **Kévin Papot** · publié le 8 janvier 2026

**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" => "contact@exemple.fr",
];

echo $utilisateur["nom"];   // Dupont
echo $utilisateur["email"]; // contact@exemple.fr
```

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.

## À lire ensuite

-   [PHP : le guide pour bien débuter](https://coder-studio.com/tutoriels/php-guide-debutant/)
-   [Les sessions en PHP : gérer l’état utilisateur](https://coder-studio.com/tutoriels/sessions-php/)
-   [Symfony : découvrir le framework PHP de référence](https://coder-studio.com/tutoriels/symfony-framework-php/)