uasort()

Trier des tableaux en PHP avec uasort()

La fonction PHP uasort() trie un tableau associatif par ses valeurs à l'aide d'une fonction de comparaison que vous écrivez vous-même, tout en conservant chaque valeur associée à sa clé d'origine. Le « u » signifie user-defined (vous fournissez la logique de comparaison) et le « a » signifie associative (les paires clé/valeur sont préservées).

Cette page explique ce que fait uasort(), sa syntaxe, comment écrire une fonction de comparaison correcte, ainsi que des exemples concrets pour les tableaux simples, associatifs et multidimensionnels — chaque résultat affiché est la vraie sortie de l'exécution du code.

Ce que fait uasort() et quand l'utiliser

La plupart des fonctions de tri de PHP ignorent les clés ou ne permettent de trier que selon les règles de comparaison intégrées. uasort() vous offre les deux à la fois :

• Vous contrôlez l'ordre. Vous passez un callback qui décide laquelle de deux valeurs vient en premier, vous pouvez donc trier par longueur, par un champ imbriqué, en ordre inverse, selon une liste de priorités personnalisée — tout ce que vous pouvez exprimer en code.
• Les clés restent liées à leurs valeurs. Après le tri, $array["John"] pointe toujours vers la valeur de John ; seul l'ordre dans lequel les paires sont itérées change.

Utilisez uasort() lorsque les deux conditions suivantes sont réunies : vous avez besoin d'une règle personnalisée et les clés sont significatives (un nom, un ID, un slug). Si les clés sont de simples positions 0, 1, 2… sans signification, usort() est plus simple car il réindexe automatiquement. Si vous souhaitez trier par les clés plutôt que par les valeurs, utilisez uksort(). Si vous n'avez besoin que d'un tri simple ascendant/descendant par valeur sans règle personnalisée, asort() et arsort() le font sans callback.

Syntaxe

uasort(array &$array, callable $callback): bool

• array &$array — le tableau à trier. Le & signifie qu'il est passé par référence : uasort() trie le tableau sur place et renvoie true/false, il ne retourne pas un nouveau tableau trié.
• callable $callback — votre fonction de comparaison. Elle reçoit deux valeurs, $a et $b, et doit renvoyer un entier indiquant à PHP leur ordre relatif.
• Valeur de retour — bool, toujours true (elle renvoie une valeur pour pouvoir être utilisée dans des expressions, mais vous l'appelez généralement pour son effet de bord sur $array).

Étant donné que le tableau est modifié sur place, écrivez uasort($array, ...); sur sa propre ligne — n'écrivez pas $array = uasort($array, ...), ce qui remplacerait vos données par true.

Écrire la fonction de comparaison

Le callback compare deux valeurs et renvoie un entier :

• un nombre négatif si $a doit venir avant $b,
• 0 si leur ordre n'a pas d'importance (ils sont considérés égaux),
• un nombre positif si $a doit venir après $b.

La façon la plus propre d'y parvenir est l'opérateur spaceship <=>, qui renvoie exactement -1, 0 ou 1 :

// ascending
fn($a, $b) => $a <=> $b;

// descending — just flip the operands
fn($a, $b) => $b <=> $a;

L'ancien style ($a < $b) ? -1 : 1 fonctionne aussi, mais il ne renvoie jamais 0, de sorte que les éléments égaux obtiennent un ordre arbitraire. Préférez <=>; il est plus court, correct pour le cas d'égalité, et fonctionne pour les nombres, les chaînes et les tableaux.

Exemple 1 : Trier les valeurs d'un tableau indexé (clés préservées)

Ici, uasort() trie les nombres par ordre croissant, mais remarquez que les clés d'origine voyagent avec les valeurs — c'est la différence avec sort(), qui les renuméroterrait 0…9.

Sortie :

Array
(
    [1] => 1
    [3] => 1
    [6] => 2
    [0] => 3
    [9] => 3
    [2] => 4
    [4] => 5
    [8] => 5
    [7] => 6
    [5] => 9
)

Exemple 2 : Trier un tableau associatif par valeur

C'est l'utilisation la plus courante : trier des personnes par âge en conservant leurs noms comme clés.

Sortie :

Array
(
    [Mary] => 28
    [Jane] => 28
    [John] => 32
    [David] => 37
    [Bob] => 45
)

Pour trier du plus âgé au plus jeune, inversez les opérandes : fn($a, $b) => $b <=> $a.

Exemple 3 : Trier un tableau multidimensionnel par un champ imbriqué

Lorsque chaque élément est lui-même un tableau, le callback reçoit le sous-tableau entier, vous pouvez donc l'indexer pour choisir le champ sur lequel trier. Ici, nous trions par âge ([1]).

Sortie :

Array
(
    [1] => Array
        (
            [0] => Mary
            [1] => 28
        )

    [3] => Array
        (
            [0] => Jane
            [1] => 28
        )

    [0] => Array
        (
            [0] => John
            [1] => 32
        )

    [4] => Array
        (
            [0] => David
            [1] => 37
        )

    [2] => Array
        (
            [0] => Bob
            [1] => 45
        )

)

Pour les lignes dont les clés sont un champ associatif, remplacez $a[1] par quelque chose comme $a['age'].

uasort() vs usort()

Les fonctions sont identiques à l'exception des clés. Passez les mêmes données à travers les deux :

<?php

$ages = ["John" => 32, "Mary" => 28, "Bob" => 45];

$copy = $ages;
usort($copy, fn($a, $b) => $a <=> $b);
echo "usort (keys lost):\n";
print_r($copy);

uasort($ages, fn($a, $b) => $a <=> $b);
echo "uasort (keys kept):\n";
print_r($ages);

Sortie :

usort (keys lost):
Array
(
    [0] => 28
    [1] => 32
    [2] => 45
)
uasort (keys kept):
Array
(
    [Mary] => 28
    [John] => 32
    [Bob] => 45
)

Pièges courants

• Elle renvoie true, pas le tableau. Lisez le résultat trié depuis la variable que vous avez passée, pas depuis la valeur de retour.
• Le tri n'est pas stable avant PHP 8.0. Si deux valeurs sont égales, leur ordre relatif était indéfini dans les anciennes versions. Depuis PHP 8.0, toutes les fonctions de tri (y compris uasort()) sont stables, donc les éléments égaux conservent leur ordre d'origine.
• Gérez toujours le cas d'égalité. Renvoyer 1 pour « pas inférieur à » (au lieu de 0) peut perturber les éléments égaux sur les anciennes versions de PHP et est tout simplement incorrect ; <=> le gère gratuitement.

Fonctions associées

• usort() — même tri avec règle personnalisée, mais réindexe les clés.
• uksort() — trier par clés avec un callback personnalisé.
• asort() / arsort() — tri par valeur, ascendant/descendant, sans callback.
• ksort() — trier par clés sans callback.
• Trier des tableaux en PHP — aperçu de chaque fonction de tri et de quand utiliser chacune.

Conclusion

uasort() est l'outil pour trier un tableau associatif par valeur avec votre propre règle de comparaison tout en conservant les clés intactes. Associez-le à l'opérateur spaceship pour des callbacks propres et corrects, rappelez-vous qu'il trie sur place, et choisissez-le plutôt que usort() chaque fois que les clés ont une signification.

Practice