PHP 8.6 SortDirection : des API de tri plus claires et plus sûres pour PHP

PHP a toujours proposé plusieurs façons de trier des tableaux et des structures de données, mais toutes les API ne sont pas aussi expressives. Avec PHP 8.6, le nouvel enum SortDirection améliore la lisibilité et la sécurité du type lorsque vous devez indiquer un ordre croissant ou décroissant.

Il s’agit d’un petit ajout au langage, mais il s’inscrit dans une tendance plus large du PHP moderne : passer de flags faiblement typés et d’entiers "magiques" à des API explicites et auto-documentées.

Pourquoi SortDirection est important

Traditionnellement, les fonctions de tri de PHP utilisent des flags comme SORT_ASC et SORT_DESC, ou des callbacks de comparaison personnalisés. Même si elles sont familières, ces constantes ne sont en réalité que des entiers, ce qui rend le code moins explicite qu’il ne pourrait l’être.

SortDirection permet aux développeurs d’exprimer leur intention de manière plus claire :

• SortDirection::Ascending

• SortDirection::Descending

Le code devient ainsi plus facile à lire, plus simple à refactorer et moins vulnérable aux erreurs d’utilisation accidentelles.

Un aperçu rapide du nouvel enum

Dans PHP 8.6, vous pouvez travailler directement avec l’enum au lieu de passer des flags entiers bruts là où l’API le prend en charge.

Exemple : comment utiliser SortDirection dans votre code

use SortDirection;

function sortUsers(array $users, SortDirection $direction): array
{
    usort($users, function (array $a, array $b) use ($direction): int {
        $comparison = $a['name'] <=> $b['name'];

        return match ($direction) {
            SortDirection::Ascending => $comparison,
            SortDirection::Descending => -$comparison,
        };
    });

    return $users;
}

$users = [
    ['name' => 'Zoe'],
    ['name' => 'Anna'],
    ['name' => 'Mike'],
];

print_r(sortUsers($users, SortDirection::Ascending));
print_r(sortUsers($users, SortDirection::Descending));

Cet exemple illustre l’un des principaux avantages du nouvel enum : la direction fait partie du système de types et n’est pas seulement une convention.

Comparaison avec les approches antérieures

Avant SortDirection, votre code aurait ressemblé à celui-ci :

function sortUsers(array $users, int $direction): array
{
    usort($users, function (array $a, array $b) use ($direction): int {
        $comparison = $a['name'] <=> $b['name'];

        if ($direction === SORT_DESC) {
            return -$comparison;
        }

        return $comparison;
    });

    return $users;
}

Cela fonctionne, mais présente quelques inconvénients :

• int $direction ne transmet pas le sens aussi bien qu’un enum

• n’importe quel entier peut être passé par erreur

• l’API oblige à retenir quelle constante correspond à quel comportement

Avec SortDirection, le compilateur et l’exécution peuvent vous aider à exprimer l’intention plus clairement.

Cas d’usage concrets

Vous bénéficierez le plus de SortDirection pour du code qui expose le tri comme fonctionnalité configurable, par exemple :

• des tableaux de bord d’administration avec ordre de tri sélectionnable par l’utilisateur

• des endpoints d’API avec sort=asc|desc

• des helpers de collections réutilisables

• une logique de tri dans des services métier

Exemple : convertir une entrée de requête en SortDirection

use SortDirection;

function directionFromString(string $value): SortDirection
{
    return strtolower($value) === 'desc'
        ? SortDirection::Descending
        : SortDirection::Ascending;
}

$direction = directionFromString($_GET['direction'] ?? 'asc');

Cela permet de maintenir la frontière entre l’entrée utilisateur et la logique interne de manière explicite. Analysez les chaînes une seule fois, puis travaillez avec un enum fortement typé dans le reste de l’application.

Une meilleure adéquation avec les codebases PHP modernes

L’introduction de SortDirection peut sembler anodine, mais elle s'inscrit dans l’évolution du PHP dans les versions récentes :

• plus d’enums

• plus de types explicites

• moins de constantes ambiguës

• un modèle de domaine plus clair

Pour les équipes qui maintiennent de grandes applications Symfony ou PHP, ces changements réduisent la charge de travail. Une petite amélioration de la clarté de l’API peut faire gagner du temps chaque fois qu’un futur développeur revient sur le code.

Ce que cela signifie pour Symfony et le développement d’applications

Même si votre framework n’expose pas encore directement SortDirection, vous pouvez adopter ce pattern dans votre propre application.

Par exemple, lors de la création d’un contrôleur ou d’un service Symfony qui gère le tri, vous pouvez :

1. accepter une chaîne provenant de la requête

2. la valider et la normaliser

3. la convertir en SortDirection

4. utiliser l’enum dans votre couche domaine ou service

Cette séparation aide à garder des contrôleurs légers et une logique métier lisible.

use SortDirection;

final class UserSorter
{
    public function sort(array $users, SortDirection $direction): array
    {
        usort($users, function (array $a, array $b) use ($direction): int {
            $result = $a['createdAt'] <=> $b['createdAt'];

            return $direction === SortDirection::Ascending ? $result : -$result;
        });

        return $users;
    }
}

Ce type de code est facile à tester et simple à faire évoluer.

Les points à garder à l’esprit

Quelques notes pratiques quand vous adoptez le nouvel enum :

• vérifiez votre version minimale de PHP avant de l’utiliser

• conservez l’analyse des entrées à la périphérie de l’application

• privilégiez les enums dans votre code métier, même si l’interface externe utilise encore des chaînes

• utilisez match ou des branches explicites lorsque la direction influence la logique métier

Conclusion

SortDirection est un petit ajout, mais il reflète un principe important du PHP moderne : rendre l’intention explicite.

Si vous développez des applications maintenables, en particulier dans des codebases basées sur Symfony, adopter ce type d’enums peut rendre vos API plus claires et votre code plus facile à comprendre.

À mesure que PHP continue d’évoluer, ce sont souvent ces améliorations incrémentales qui ont l’impact le plus fort au quotidien pour les équipes de développement.