Aller au contenu principal
Retour au blog

PHP 8.5 et l'i18n : IntlListFormatter, RTL et fin de l'implode(', ') bancal

PHP 8.5 ajoute IntlListFormatter et locale_is_right_to_left() : de quoi arrêter de concaténer des listes à la main et gérer l'arabe ou l'hébreu proprement.

Flavien Métivier · 9 min de lecture
Sommaire · 5 parties

Il y a un bug d'internationalisation qui traverse les décennies de PHP sans jamais vraiment être corrigé : la liste concaténée à la main. implode(', ', $items) produit une virgule mécanique entre chaque élément, sans jamais poser la question de savoir si la locale de l'utilisateur attend une virgule d'Oxford, une conjonction finale, ou même un sens de lecture inversé. Ce n'est pas un détail cosmétique — c'est un bug fonctionnel qui s'affiche devant chaque utilisateur non anglophone de ton application. PHP 8.5, sorti le 20 novembre 2025, referme enfin ce trou avec deux ajouts ciblés dans l'extension Intl : la classe IntlListFormatter et la paire locale_is_right_to_left() / Locale::isRightToLeft(). Ce sont deux petites API, mais elles suppriment une classe entière de bugs i18n qu'on corrige habituellement à coups de patchs ad hoc en fin de sprint.

Le bug caché derrière implode(', ', $items)

Prends un cas banal : afficher les tags d'un article, les destinataires d'une notification, ou les catégories associées à un produit. Le réflexe naturel est d'écrire implode(', ', $tags) et de passer à autre chose. Le problème apparaît dès que l'équipe internationalise l'application. En français, une liste de trois éléments s'écrit « PHP, Symfony et Docker » — avec un « et » avant le dernier élément, sans virgule devant. En anglais américain, la convention veut une virgule d'Oxford : « PHP, Symfony, and Docker ». En anglais britannique, cette virgule disparaît : « PHP, Symfony and Docker ». En japonais, le séparateur n'est même pas une virgule occidentale mais un caractère dédié, 「、」. Aucune de ces règles n'est capturée par un simple implode(), et corriger ça à la main pour chaque locale supportée revient à réinventer, application par application, ce que le consortium Unicode a déjà standardisé dans ICU.

  • Conjonction incorrecte — une liste « et » traitée comme une liste « ou » change le sens de la phrase (permissions requises vs. permissions suffisantes)
  • Ponctuation fautive — virgule d'Oxford imposée à un public britannique, ou absente pour un public américain qui l'attend
  • Ordre de lecture ignoré — une interface pensée pour un flux gauche-à-droite reste illisible pour un utilisateur arabophone ou hébréophone
  • Effort de maintenance dupliqué — chaque équipe réimplémente sa propre table de correspondance locale → séparateur, avec les mêmes angles morts

IntlListFormatter : le wrapper ICU qui manquait à PHP

IntlListFormatter est une classe final de l'extension Intl, disponible à partir de PHP 8.5. C'est un wrapper direct autour du ListFormatter d'ICU (International Components for Unicode) — la même bibliothèque qui alimente déjà IntlDateFormatter et NumberFormatter depuis des années. Le constructeur prend trois paramètres : la locale cible, un type de liste, et une largeur de rendu.

php
<?php
declare(strict_types=1);

// Constantes de type — la nature grammaticale de la liste
IntlListFormatter::TYPE_AND;   // conjonction : "A, B et C"
IntlListFormatter::TYPE_OR;    // disjonction : "A, B ou C"
IntlListFormatter::TYPE_UNITS; // juxtaposition d'unités : "3 m 20 cm"

// Constantes de largeur — la verbosité du rendu
IntlListFormatter::WIDTH_WIDE;   // forme complète (par défaut)
IntlListFormatter::WIDTH_SHORT;  // forme abrégée
IntlListFormatter::WIDTH_NARROW; // forme la plus compacte

// Constructeur
$formatter = new IntlListFormatter(
    locale: 'fr',
    type: IntlListFormatter::TYPE_AND,
    width: IntlListFormatter::WIDTH_WIDE,
);

echo $formatter->format(['PHP', 'Symfony', 'Docker']);
// "PHP, Symfony et Docker"

La méthode format(array $strings) accepte un tableau de chaînes (ou de valeurs convertibles en chaîne) et retourne la liste correctement ponctuée pour la locale demandée. C'est là que la magie opère vraiment : le même appel, avec la même liste d'entrée, produit un résultat différent selon la locale passée au constructeur — sans qu'une seule ligne de logique conditionnelle n'apparaisse dans ton code métier.

php
<?php
declare(strict_types=1);

$tags = ['PHP', 'Symfony', 'Docker'];

$fr = new IntlListFormatter('fr', IntlListFormatter::TYPE_AND);
echo $fr->format($tags);
// "PHP, Symfony et Docker"

$enUS = new IntlListFormatter('en_US', IntlListFormatter::TYPE_AND);
echo $enUS->format($tags);
// "PHP, Symfony, and Docker" (virgule d'Oxford)

$enGB = new IntlListFormatter('en_GB', IntlListFormatter::TYPE_AND);
echo $enGB->format($tags);
// "PHP, Symfony and Docker" (pas de virgule d'Oxford)

$permissions = ['lire', 'écrire', 'administrer'];
$disjonction = new IntlListFormatter('fr', IntlListFormatter::TYPE_OR);
echo $disjonction->format($permissions);
// "lire, écrire ou administrer"

Un point de vigilance à noter avant de déployer ça en production : les largeurs WIDTH_SHORT et WIDTH_NARROW, ainsi que le type TYPE_UNITS, dépendent des données CLDR embarquées dans la version d'ICU liée à ton PHP. Sur une version d'ICU antérieure à la 67, seuls TYPE_AND combiné à WIDTH_WIDE sont garantis disponibles partout — utiliser les autres combinaisons peut déclencher une exception selon l'environnement. Vérifie la version d'ICU de ton image Docker (php -i | grep ICU) avant de t'appuyer sur les largeurs abrégées en production, et prévois un test qui échoue fort plutôt qu'un fallback silencieux si l'environnement ne suit pas.

Détecter le RTL : locale_is_right_to_left() et Locale::isRightToLeft()

Le second ajout Intl de PHP 8.5 répond à un problème différent mais complémentaire : savoir si une locale s'écrit de droite à gauche. Historiquement, cette détection se faisait via une table de correspondance maintenue à la main — un tableau statique ['ar', 'he', 'fa', 'ur', ...] recopié d'un projet à l'autre, jamais tout à fait exhaustif, jamais mis à jour quand une nouvelle locale RTL apparaît. PHP 8.5 expose désormais cette information directement depuis les données ICU, via une fonction procédurale et une méthode statique équivalentes.

php
<?php
declare(strict_types=1);

// Fonction procédurale
function locale_is_right_to_left(string $locale): bool {}

// Méthode statique équivalente
Locale::isRightToLeft(string $locale): bool;

// Exemples
locale_is_right_to_left('fr');    // false
locale_is_right_to_left('en');    // false
locale_is_right_to_left('ar');    // true
locale_is_right_to_left('ar-US'); // true — le pays ne change rien au script
locale_is_right_to_left('he_IL'); // true

Locale::isRightToLeft('ur');      // true (ourdou)

// Comportement sur entrée invalide
locale_is_right_to_left('');            // false, pas d'exception
locale_is_right_to_left('xx-invalide'); // false, pas d'exception
locale_is_right_to_left();              // ArgumentCountError — paramètre obligatoire

Migration Symfony en vue ?

Bear Upgrade migre votre codebase 2,5× à 4,5× moins cher qu'une ESN, selon sa maturité.

Estimer ma migration →

Le comportement est volontairement permissif sur les entrées incertaines : une locale vide ou invalide retourne false plutôt que de lever une exception, ce qui évite de faire planter un rendu de page pour une locale mal formée en amont. En revanche, appeler la fonction sans argument reste une erreur de programmation détectée par ArgumentCountError — la distinction est cohérente avec le reste des fonctions locale_* de l'extension.

Concrètement, ce booléen sert à piloter l'attribut dir du HTML et les classes CSS logiques (margin-inline-start plutôt que margin-left, par exemple) sans construire ni maintenir sa propre table de langues RTL :

php
<?php
declare(strict_types=1);

final class DocumentDirection
{
    public static function forLocale(string $locale): string
    {
        return locale_is_right_to_left($locale) ? 'rtl' : 'ltr';
    }
}

// Dans un template Twig, exposé via un service ou une fonction globale
// <html lang="{{ app.request.locale }}" dir="{{ direction }}">

Intégration avec Symfony Translation et le composant Intl

Le composant symfony/intl embarque déjà une partie des données ICU sous forme de polyfills pour les environnements sans extension native, mais il ne réimplémente pas IntlListFormatter — il s'appuie sur l'extension PHP dès qu'elle est disponible. Concrètement, sur une stack Symfony qui cible PHP 8.5, tu peux exposer un service applicatif qui encapsule IntlListFormatter en respectant la locale courante de la requête, résolue par LocaleAwareInterface ou le RequestStack :

php
<?php
declare(strict_types=1);

namespace App\Service\Intl;

use Symfony\Contracts\Translation\LocaleAwareInterface;

final class LocalizedListFormatter implements LocaleAwareInterface
{
    private string $locale = 'fr';

    public function setLocale(string $locale): void
    {
        $this->locale = $locale;
    }

    public function getLocale(): string
    {
        return $this->locale;
    }

    /**
     * @param list<string> $items
     */
    public function conjunction(array $items): string
    {
        $formatter = new \IntlListFormatter(
            $this->locale,
            \IntlListFormatter::TYPE_AND,
        );

        return $formatter->format($items);
    }

    /**
     * @param list<string> $items
     */
    public function disjunction(array $items): string
    {
        $formatter = new \IntlListFormatter(
            $this->locale,
            \IntlListFormatter::TYPE_OR,
        );

        return $formatter->format($items);
    }
}

Injecté comme n'importe quel service Symfony taggé kernel.locale_aware, ce wrapper synchronise automatiquement sa locale avec celle de la requête courante grâce au LocaleListener du framework. Le résultat : un service métier unique — LocalizedListFormatter — appelé depuis un contrôleur, un message Messenger ou un rendu Twig, qui produit toujours la ponctuation correcte pour l'utilisateur en cours, sans jamais dupliquer de logique de formatage à travers l'application. C'est exactement le type de brique qui distingue une équipe qui traite l'i18n comme une contrainte structurelle d'une équipe qui la corrige au fil de l'eau, ticket par ticket, quand un client signale une virgule mal placée.

Ce que ça change concrètement pour ton équipe

Ces deux ajouts sont volontairement modestes en surface — une classe, une fonction, une méthode statique — mais leur portée dépasse la simple commodité syntaxique. Ils déplacent une responsabilité qui reposait sur la discipline individuelle des développeurs (« penser à ne pas faire d'implode() bête ») vers une garantie fournie par le runtime et alignée sur les données CLDR maintenues par le consortium Unicode. C'est le même mouvement que Symfony a engagé depuis longtemps avec son composant Translation : sortir l'i18n du code métier ad hoc pour en faire une infrastructure partagée, testée une seule fois et réutilisée partout.

  • Audit rapide — grep sur implode(', ' et implode(', ', array_slice( dans la codebase pour repérer les listes concaténées manuellement, candidates à la migration vers IntlListFormatter
  • Tests de régression i18n — un test PHPUnit qui vérifie la ponctuation exacte pour chaque locale supportée, plutôt qu'un test qui vérifie juste la présence des éléments dans la chaîne produite
  • Vérification RTL en CI — un test qui parcourt les locales activées et vérifie que dir="rtl" s'applique bien aux locales attendues (arabe, hébreu) sans régression silencieuse lors d'un ajout de langue
  • Vérification ICU — avant d'exploiter WIDTH_SHORT/WIDTH_NARROW en production, valider la version d'ICU de l'image Docker cible pour éviter une exception en environnement réel

Si tu gères une application Symfony qui s'exporte à l'international — ou qui envisage de le faire — ce genre de détail se paie cher a posteriori : une fois que des dizaines de vues concatènent des listes à la main, la migration devient un chantier transversal plutôt qu'un simple choix d'API au démarrage du projet. Notre équipe accompagne justement les studios PHP/Symfony sur ce type d'audit d'architecture — repérer les dettes i18n avant qu'elles ne deviennent visibles pour les utilisateurs, et cadrer les migrations vers les nouvelles API du langage sans casser ce qui tourne déjà en production. Si le sujet te parle, on peut regarder ensemble où en est ton application. Pour aller plus loin sur PHP 8.5 côté outillage bas niveau, on avait détaillé les nouveaux array helpers, les backtraces sur erreurs fatales et le diff d'ini, ainsi que le pipe operator, le parsing d'URI natif et l'attribut #[NoDiscard]. Et si tu veux resituer ces évolutions dans la trajectoire plus large du langage, notre rétrospective sur 20 ans de PHP et son écosystème enterprise donne le contexte historique de ces choix de conception.

Cet article vous a été utile ? Partagez-le.

Portrait de Flavien Métivier, fondateur de The Bearded Bear : barbe longue, lunettes, sur fond sombre

Écrit par

Flavien Métivier

Expert PHP/Symfony indépendant depuis 2014, ancien CTO de Kartable et d'Extrabat. Plus de 80 projets menés, de l'audit à la migration.

Mon parcours

À lire ensuite

Migration Symfony en vue ?

Bear Upgrade migre votre codebase 2,5× à 4,5× moins cher qu'une ESN, selon sa maturité.

Newsletter Bear Bytes

Veille Claude Code, Symfony et PHP, retours d'expérience terrain et conseils techniques, directement dans votre boîte mail.