Aller au contenu principal

Les fonctions de manipulation de tableaux

Notions théoriques​

Dans la séance précédente, vous avez appris à créer un tableau, à ajouter un élément, à compter les éléments et à parcourir un tableau avec foreach. Après avoir vu comment créer et parcourir un tableau, découvrons les fonctions qui permettent de le transformer efficacement, sans avoir à écrire une boucle à chaque fois.

PHP fournit de nombreuses fonctions natives pour manipuler les tableaux. Elles permettent de transformer, filtrer, agréger, rechercher, fusionner et trier des tableaux en une seule instruction.

Transformer chaque élément avec array_map()​

La fonction array_map() applique une fonction à chaque élément d'un tableau et retourne un nouveau tableau contenant les résultats. Le tableau d'origine n'est pas modifié.

$nombres = [1, 2, 3, 4];

$carres = array_map(function ($n) {
    return $n * $n;
}, $nombres);

print_r($carres); // [1, 4, 9, 16]
info

Depuis PHP 7.4, on peut écrire une fonction anonyme plus courte avec fn(), appelée fonction fléchée :

$carres = array_map(fn($n) => $n * $n, $nombres);

Une fonction fléchée retourne automatiquement le résultat de son expression, sans avoir besoin du mot-clé return.

Filtrer les éléments avec array_filter()​

La fonction array_filter() conserve uniquement les éléments d'un tableau pour lesquels une condition retourne true.

$nombres = [1, 2, 3, 4, 5, 6];

$pairs = array_filter($nombres, function ($n) {
    return $n % 2 === 0;
});

print_r($pairs); // [1 => 2, 3 => 4, 5 => 6]
attention

array_filter() conserve les index d'origine : le tableau résultat n'est donc pas forcément réindexé à partir de 0. Pour obtenir un tableau propre réindexé, utiliser array_values() :

$pairs = array_values(array_filter($nombres, fn($n) => $n % 2 === 0));
print_r($pairs); // [0 => 2, 1 => 4, 2 => 6]

Agréger en une seule valeur avec array_reduce()​

La fonction array_reduce() parcourt un tableau pour le réduire à une seule valeur, en accumulant un résultat au fur et à mesure.

$nombres = [1, 2, 3, 4];

$somme = array_reduce($nombres, function ($accumulateur, $n) {
    return $accumulateur + $n;
}, 0);

echo $somme; // 10

Le troisième paramètre (0 ici) est la valeur initiale de l'accumulateur.

Tester la présence d'une valeur avec in_array()​

La fonction in_array() permet de savoir si une valeur existe déjà dans un tableau. Elle retourne true ou false.

$fruits = ["pomme", "banane", "cerise"];

if (in_array("banane", $fruits)) {
    echo "Il y a une banane dans le panier.";
} else {
    echo "Pas de banane.";
}
info

Par défaut, in_array() compare les valeurs sans tenir compte du type ("5" == 5 est considéré vrai). Pour une comparaison stricte (valeur ET type), ajouter true en troisième paramètre : in_array("5", $tableau, true).

Fusionner des tableaux avec array_merge()​

La fonction array_merge() combine plusieurs tableaux en un seul.

$fruits1 = ["pomme", "banane"];
$fruits2 = ["cerise", "kiwi"];

$tous = array_merge($fruits1, $fruits2);
print_r($tous); // ["pomme", "banane", "cerise", "kiwi"]
attention

Avec des tableaux associatifs, si deux tableaux partagent la même clé, la valeur du dernier tableau écrase celle du premier :

$a = ["nom" => "Dupont"];
$b = ["nom" => "Martin", "age" => 30];

print_r(array_merge($a, $b)); // ["nom" => "Martin", "age" => 30]

Trier un tableau avec sort() et usort()​

La fonction sort() trie un tableau indexé par ordre croissant, directement (elle modifie le tableau d'origine).

$notes = [12, 8, 15, 10];
sort($notes);
print_r($notes); // [8, 10, 12, 15]

Quand le tri par défaut ne suffit pas (par exemple pour trier un tableau de tableaux associatifs), on utilise usort() avec une fonction de comparaison personnalisée.

$eleves = [
    ["nom" => "Bob",   "note" => 12],
    ["nom" => "Alice", "note" => 15],
    ["nom" => "Carol", "note" => 9],
];

usort($eleves, function ($a, $b) {
    return $a["note"] <=> $b["note"];
});

print_r($eleves); // Carol (9), Bob (12), Alice (15)
info

L'opérateur <=> (appelé spaceship operator) compare deux valeurs et retourne -1, 0 ou 1. C'est le moyen le plus simple d'écrire une fonction de comparaison pour usort().

Exemple pratique​

<?php
// Un panier de produits avec leur prix hors taxe
$produits = [
    ["nom" => "Clavier",  "prixHT" => 40, "stock" => 12],
    ["nom" => "Souris",   "prixHT" => 15, "stock" => 0],
    ["nom" => "Écran",    "prixHT" => 120, "stock" => 5],
    ["nom" => "Casque",   "prixHT" => 60, "stock" => 3],
];

// 1) array_map : calculer le prix TTC (TVA 20%) pour chaque produit
$produitsTTC = array_map(function ($produit) {
    $produit["prixTTC"] = round($produit["prixHT"] * 1.2, 2);
    return $produit;
}, $produits);

// 2) array_filter : garder uniquement les produits en stock
$enStock = array_filter($produitsTTC, function ($produit) {
    return $produit["stock"] > 0;
});

// 3) array_reduce : calculer la valeur totale du stock TTC
$valeurTotale = array_reduce($enStock, function ($total, $produit) {
    return $total + ($produit["prixTTC"] * $produit["stock"]);
}, 0);

echo "Valeur totale du stock : " . $valeurTotale . " euros\n";

// 4) in_array : vérifier la présence d'un nom de produit
$noms = array_map(fn($p) => $p["nom"], $produits);
if (in_array("Écran", $noms)) {
    echo "L'écran fait partie du catalogue.\n";
}

// 5) usort : trier les produits en stock du moins cher au plus cher
usort($enStock, function ($a, $b) {
    return $a["prixTTC"] <=> $b["prixTTC"];
});

foreach ($enStock as $produit) {
    echo $produit["nom"] . " : " . $produit["prixTTC"] . " euros\n";
}
astuce

Ces fonctions se combinent très bien entre elles : on peut enchaîner array_filter() puis array_map() puis array_reduce() pour filtrer, transformer, puis agréger des données en quelques lignes seulement.

Test de mémorisation/compréhension​


Que fait la fonction array_map() ?


Que fait la fonction array_filter() ?


Que fait la fonction array_reduce() ?


Quelle fonction PHP permet de tester si une valeur est présente dans un tableau ?


Quelle fonction PHP fusionne plusieurs tableaux en un seul ?


Quelle fonction trie un tableau indexé par ordre croissant en le modifiant directement ?


Pourquoi utilise-t-on usort() plutôt que sort() pour trier un tableau de tableaux associatifs ?


Que retourne l'opérateur <=> quand on compare 5 <=> 10 ?


Avec array_merge(['nom' => 'Dupont'], ['nom' => 'Martin', 'age' => 30]), quelle est la valeur de la clé 'nom' dans le résultat ?


Pourquoi array_values() est-il souvent utilisé après un array_filter() ?


TP pour réfléchir et résoudre des problèmes​

Dans ce TP, vous allez gérer un petit panier de produits en utilisant les fonctions de manipulation de tableaux vues dans cette séance.

  • Dans votre répertoire "Documents" créez le répertoire tp_fonctions_tableaux.
  • Dans ce répertoire créez le fichier main.php : 
    <?php
    // Les fonctions de manipulation de tableaux
    print("Les fonctions de manipulation de tableaux \n\n");

    $produits = [
        ["nom" => "Clavier", "prixHT" => 40, "stock" => 12],
        ["nom" => "Souris",  "prixHT" => 15, "stock" => 0],
        ["nom" => "Écran",   "prixHT" => 120, "stock" => 5],
        ["nom" => "Casque",  "prixHT" => 60, "stock" => 3],
    ];
  • Testez le fonctionnement de ce fichier : 
    php main.php

Étape 1 — Calculer le prix TTC de chaque produit​

En utilisant array_map(), créez un tableau $produitsTTC qui contient les mêmes produits, avec en plus une clé "prixTTC" égale au prix HT multiplié par 1.2.


Bonne pratique - Ne pas modifier le tableau d'origine

array_map() retourne toujours un nouveau tableau et ne modifie pas $produits. C'est une bonne pratique : cela évite les effets de bord et permet de garder les données d'origine intactes pour les réutiliser ailleurs.

Étape 2 — Ne garder que les produits en stock​

En utilisant array_filter(), créez un tableau $enStock qui contient uniquement les produits dont le "stock" est supérieur à 0.


Bonne pratique - Filtrer avant de calculer

Filtrer les données inutiles (ici les produits sans stock) avant de faire des calculs plus lourds permet d'économiser du temps de traitement, surtout sur de grands tableaux.

Étape 3 — Calculer la valeur totale du stock​

En utilisant array_reduce(), calculez la valeur totale du stock (somme de prixTTC * stock pour chaque produit en stock).


Bonne pratique - Toujours donner une valeur initiale

Le troisième paramètre de array_reduce() (la valeur initiale de l'accumulateur) évite les erreurs si le tableau est vide : sans lui, array_reduce() retournerait null sur un tableau vide au lieu de 0.

Étape 4 — Vérifier la présence d'un produit​

En utilisant in_array(), vérifiez si le produit "Écran" fait partie de la liste des noms de produits.


Bonne pratique - Comparaison stricte

Pour éviter les mauvaises surprises avec des types différents (par exemple "0" et 0), pensez à utiliser la comparaison stricte : in_array($valeur, $tableau, true).

Étape 5 — Fusionner un nouvel arrivage​

Un nouvel arrivage de produits arrive : $nouveauxProduits = [["nom" => "Tapis de souris", "prixHT" => 8, "stock" => 20]];. Fusionnez-le avec $produits en utilisant array_merge().


Bonne pratique - array_merge() avec des tableaux indexés

Avec des tableaux indexés numériquement (comme ici), array_merge() renumérote les index à partir de 0 pour éviter tout conflit. C'est différent du comportement avec des tableaux associatifs, où les clés textuelles peuvent s'écraser.

Étape 6 — Trier le catalogue par prix​

En utilisant usort(), triez $enStock du produit le moins cher au plus cher (sur prixTTC).


Bonne pratique - Trier sans perdre les autres données

usort() trie le tableau en place mais conserve toutes les clés de chaque élément. C'est très pratique pour trier une liste d'enregistrements (produits, élèves, commandes…) sans perdre d'informations.

Une solution du TP​

📌 Une solution