Tri des tableaux

Introduction au tri des tableaux PHP

Un tableau en PHP est une collection d'éléments stockés et accessibles via un index (une position numérique) ou une clé (un libellé). Trier signifie réorganiser ces éléments dans un ordre défini — croissant, décroissant, par valeur, par clé, ou selon votre propre règle.

Cette page couvre les fonctions de tri intégrées de PHP, le comportement de chacune, et — tout aussi important — laquelle choisir selon que vous vous souciez des clés, des valeurs ou d'un ordre personnalisé.

Différences entre les fonctions de tri

Deux questions déterminent quelle fonction vous convient :

1. Trier par valeur ou par clé ? Les listes simples (tableaux indexés) sont triées par valeur ; les tableaux associatifs peuvent être triés selon l'un ou l'autre.
2. Conserver l'association clé→valeur ? sort()/rsort() suppriment les clés d'origine et réindexent à partir de 0. La famille a* et k* préserve l'association.

Chacune de ces fonctions trie le tableau en place (elle modifie la variable passée en argument) et retourne true en cas de succès plutôt qu'un nouveau tableau — une source de confusion fréquente pour les débutants.

Trier des tableaux en ordre croissant

La fonction sort() trie un tableau en ordre croissant : les chaînes alphabétiquement, les nombres numériquement. Elle modifie le tableau d'origine en place et le réindexe à partir de 0, de sorte que toutes les clés d'origine sont perdues. Évitez de mélanger des types de données dans un même tableau, car les comparaisons entre des chaînes et des nombres, par exemple, peuvent produire des résultats surprenants.

$fruits = ['lemon', 'orange', 'banana', 'apple'];
sort($fruits);
print_r($fruits);
// Output: Array ( [0] => apple [1] => banana [2] => lemon [3] => orange )

Trier des tableaux en ordre décroissant

La fonction rsort() est l'inverse de sort() — elle ordonne les éléments du plus grand au plus petit. Comme sort(), elle opère en place et réindexe le tableau.

$numbers = [5, 2, 9, 1, 7];
rsort($numbers);
print_r($numbers);
// Output: Array ( [0] => 9 [1] => 7 [2] => 5 [3] => 2 [4] => 1 )

Trier des tableaux associatifs par valeur

Lorsque les clés ont une signification (noms, identifiants, libellés), utilisez les fonctions a* pour que les paires clé→valeur restent associées. La fonction asort() trie par valeur en ordre croissant ; arsort() fait de même en ordre décroissant.

$ages = ['Peter' => 35, 'John' => 28, 'Mary' => 32];
asort($ages);
print_r($ages);
// Output: Array ( [John] => 28 [Mary] => 32 [Peter] => 35 )

Remarquez que chaque nom reste lié à son âge — c'est la différence avec sort(), qui supprimerait les noms.

Trier des tableaux associatifs par clé

La fonction ksort() trie par clé en ordre croissant tout en conservant chaque clé liée à sa valeur ; krsort() trie par clé en ordre décroissant.

$colors = ['red' => '#FF0000', 'blue' => '#0000FF', 'green' => '#008000'];
ksort($colors);
print_r($colors);
// Output: Array ( [blue] => #0000FF [green] => #008000 [red] => #FF0000 )

Tri en ordre naturel

Un tri de chaînes classique compare caractère par caractère, de sorte que 'img10' est placé avant 'img2' (parce que '1' < '2'). La fonction natsort() utilise un algorithme d'« ordre naturel » qui compare les nombres intégrés en tant que nombres — comme un humain ordonnerait des noms de fichiers. Elle préserve les clés.

$files = ['img12.png', 'img10.png', 'img2.png', 'img1.png'];
natsort($files);
print_r($files);
// Output: Array ( [3] => img1.png [2] => img2.png [1] => img10.png [0] => img12.png )

Utilisez natcasesort() pour le même comportement en ignorant la casse.

Tri personnalisé avec usort()

Lorsque les ordres intégrés ne suffisent pas — tri d'objets, de tableaux multidimensionnels, ou selon une valeur dérivée — usort() vous permet de fournir votre propre fonction de comparaison. Le callback reçoit deux éléments et doit retourner un nombre négatif, 0, ou un nombre positif selon que le premier doit venir avant, à égalité avec, ou après le second.

$people = [
    ['name' => 'Mary', 'age' => 32],
    ['name' => 'Peter', 'age' => 35],
    ['name' => 'John', 'age' => 28],
];

usort($people, function ($a, $b) {
    return $a['age'] <=> $b['age']; // spaceship operator: ascending by age
});

foreach ($people as $person) {
    echo $person['name'] . ': ' . $person['age'] . "\n";
}
// Output:
// John: 28
// Mary: 32
// Peter: 35

L'opérateur « vaisseau spatial » <=> retourne exactement le -1 / 0 / 1 dont le callback a besoin, ce qui en fait le choix idiomatique ici. Si vous devez conserver les clés, utilisez uasort() ; pour trier selon une règle de clé personnalisée, utilisez uksort().

Choisir la bonne fonction

• Liste simple, les clés n'ont pas d'importance → sort() / rsort().
• Tableau associatif, tri par valeur, conservation des clés → asort() / arsort().
• Tableau associatif, tri par clé → ksort() / krsort().
• Noms de fichiers ou chaînes de type version → natsort() / natcasesort().
• Objets, tableaux imbriqués ou toute règle personnalisée → usort() / uasort() / uksort().

Si vous avez seulement besoin d'inverser l'ordre existant sans re-trier, array_reverse() est moins coûteux qu'un tri complet. Pour trier plusieurs tableaux ensemble ou selon plusieurs colonnes, consultez array_multisort().

Conclusion

PHP fournit une boîte à outils complète pour ordonner les tableaux, et le bon choix se résume à deux questions : triez-vous par valeur ou par clé, et avez-vous besoin de conserver les clés associées ? sort() et rsort() gèrent les listes simples, la famille a*/k* gère les données associatives, natsort() gère l'ordonnancement convivial, et la famille u* gère tout ce qui est personnalisé. Rappelez-vous que toutes ces fonctions trient en place et retournent un booléen — pas un nouveau tableau.

Pratique