Blog / Article #214
PHP 8.6 : ces nouveautés qui vont vous faire aimer les montées de version

star

19 Novembre 2026
Illustration technique : Stylized illustration of PHP 8.6 logo with code snippets and performance graphs in the background, depicting 'Partial Function Application' and 'Io/Poll API' concepts. Vibrant, modern tech style, no text.

Alors, les montées de version de PHP... Un mélange d'excitation pour les nouveautés et d'une légère anxiété à l'idée de ce qui pourrait casser. Mais avec PHP 8.6, dont la version GA (General Availability) est prévue pour le 19 novembre 2026, je dois avouer que l'excitation prend largement le dessus. Cette mouture promet non seulement de nous faciliter la vie avec des outils syntaxiques malins, mais aussi de donner un coup de fouet à nos applications, notamment celles sous Symfony.

Alors, pourquoi cette version est-elle essentielle pour votre stack de développement ? Eh bien, au-delà des habituelles corrections de bugs et des dépréciations (on y reviendra, comme toujours), PHP 8.6 introduit une fonctionnalité qui va changer la donne pour l'écriture de code plus propre et plus expressif : la Partial Function Application. Et ce n'est pas tout, car sous le capot, de nombreuses optimisations invisibles mais réelles promettent de rendre nos applications plus véloces. Accrochez-vous, on explore ça ensemble.

La Partial Function Application : le chaînon manquant des callbacks

Imaginez pouvoir pré-remplir certains arguments d'une fonction et obtenir en retour une Closure prête à l'emploi, qui n'attend plus que les arguments manquants. C'est exactement ce que propose la Partial Function Application (PFA). Fini les Closure verbeuses pour encapsuler un appel simple avec un ou deux arguments fixés !

La PFA utilise un marqueur ? pour un argument unique et ... pour tous les arguments restants. Les arguments que vous fournissez sont évalués une seule fois, au moment de la création de la Closure. C'est simple, élégant et ça ouvre des portes pour des callbacks beaucoup plus lisibles. Voyons quelques exemples concrets :

<?php
// Cas simple : remplacer les espaces par des underscores
$underscore = str_replace(' ', '_', ?);
echo $underscore('Ma chaîne de caractères'); // Affiche 'Ma_chaîne_de_caractères'

// Avec array_map et in_array
$legal = ['admin', 'moderator'];
$input = ['admin', 'user', 'moderator'];
$result = array_filter($input, in_array(?, $legal, strict: true));
print_r($result); // Affiche ['admin', 'moderator']

// Filtrer un tableau avec is_numeric
$data = ['123', 'abc', '456', 'def'];
$filterNumbers = array_filter(?, is_numeric(...));
print_r($filterNumbers($data)); // Affiche ['123', '456']

// Différer l'exécution d'une requête (exemple conceptuel)
// Imaginez une fonction 'query' qui prend la requête et les paramètres
function query(string $sql, mixed ...$params): callable
{
    return function() use ($sql, $params) {
        echo "Exécution de la requête : '$sql' avec les paramètres : " . implode(', ', $params) . "
";
        // Logique réelle d'exécution de la base de données
    };
}

$performUpdate = query('UPDATE table SET status = ? WHERE id = ?', 'active', 42, ...);

$needToUpdate = true;
if ($needToUpdate) {
    $performUpdate();
}

C'est un véritable gain en lisibilité, surtout quand on manipule des fonctions de haut niveau comme array_map, array_filter ou même dans la construction de services avec Symfony. Plus besoin de passer par des fn ($arg) => maFonction(ARG_FIXE, $arg), la PFA s'en charge élégamment.

Attention tout de même : la PFA ne peut pas être utilisée avec les appels de constructeur, compact(), extract(), func_get_args() ou get_defined_vars(). De plus, le paramètre correspondant de la Closure résultante sera toujours requis, même si le paramètre original de la fonction était optionnel. Des détails à garder en tête, mais qui n'enlèvent rien à son utilité.

Des performances invisibles mais réelles : la Polling API et le JIT en renfort

Au-delà des nouveautés syntaxiques, PHP 8.6 apporte son lot d'optimisations sous le capot. Et ça, c'est le genre de chose qu'on aime dans nos homelabs et en production : de la vitesse sans changer une ligne de code !

La Polling API (Io\Poll API)

C'est LA grande nouveauté côté performance. Cette API permet de surveiller efficacement de nombreux flux simultanément en utilisant les mécanismes natifs de chaque système d'exploitation (epoll sous Linux, kqueue sous BSD/macOS, etc.). Elle lève les limitations de l'ancienne stream_select(), qui devenait un goulot d'étranglement pour les applications asynchrones ou celles gérant beaucoup de connexions. Conçue pour être la fondation de bibliothèques comme ReactPHP ou AMPHP, elle devrait avoir un impact significatif sur PHP-FPM et la gestion des signaux, rendant nos serveurs plus réactifs.

Optimisations diverses

La liste est longue, mais voici quelques pépites qui contribuent à un PHP plus rapide :

  • Compilation de array_map() en boucles quand on utilise des callables de première classe ou la PFA.
  • Appels printf() et encodage JSON plus rapides.
  • Mise en cache des closures sans état.
  • Des fonctions comme intval() avec des bases binaires, DOMText::splitText(), array_fill_keys() ou array_column() ont été optimisées.
  • Le passage d'arguments aux constructeurs connus au moment de la compilation est plus rapide.

Ces micro-optimisations, mises bout à bout, peuvent rendre une application PHP 8.6 significativement plus rapide qu'une application PHP 7.4 (jusqu'à 22% plus rapide avec le JIT activé !).

Le JIT (Just-In-Time) : le coup de boost ultime

Si vous ne l'avez pas encore activé, c'est le moment d'y penser. Le compilateur JIT, introduit en PHP 8.0, n'est toujours pas activé par défaut en 8.6, mais il peut transformer les performances de votre application, surtout pour les calculs intensifs. Pour l'activer, ajoutez ces lignes dans votre php.ini :

opcache.jit=tracing
opcache.jit_buffer_size=100M

La valeur de opcache.jit_buffer_size peut être ajustée selon vos besoins, mais 100M est un bon point de départ. En homelab, j'ai vu des gains impressionnants sur certains scripts lourds.

Les autres douceurs et les dépréciations à surveiller

PHP 8.6 ne se limite pas à la PFA et aux performances. Il y a aussi des ajouts utiles et, bien sûr, des dépréciations qui nécessitent notre attention.

Nouveautés syntaxiques et fonctions utilitaires

  • La classe \Time\Duration : Une première étape vers une meilleure gestion du temps, avec une précision à la nanoseconde.
  • La fonction clamp() : Très pratique pour s'assurer qu'une valeur reste dans une plage définie, évitant ainsi des if/else if fastidieux.
  • L'Enum SortDirection : Un moyen standardisé et typé pour définir l'ordre de tri (ascendant/descendant).
  • Les propriétés readonly peuvent désormais avoir des valeurs par défaut.
  • L'attribut #[Override] s'étend aux constantes de classe et aux cas d'enum, améliorant la clarté et la robustesse du code.
  • La fonction grapheme_strrev() pour inverser les chaînes par cluster de graphèmes, un plus pour l'internationalisation.

Les dépréciations et changements à ne pas rater

Comme à chaque version majeure, il y a du ménage. Voici les points les plus importants pour une migration sereine :

  • Noms réservés : L'utilisation de let ou is comme noms de classe, fonction ou constante est dépréciée. Idem pour _ comme nom de constante, namespace comme constante de classe, ou readonly comme nom de fonction.
  • Fonctions mbstring : Les fonctions d'expression régulière mb_ereg() et mb_split() sont dépréciées car la bibliothèque Oniguruma n'est plus maintenue. Il faudra passer aux fonctions PCRE avec le modificateur u.
  • Alias de types : Les alias is_double(), is_long(), is_integer(), doubleval() sont dépréciés. Utilisez is_float(), is_int() et floatval().
  • Gestion des erreurs : De nombreuses fonctions lèvent désormais une ValueError pour les valeurs hors limites ou les drapeaux invalides, au lieu d'ignorer silencieusement. C'est plus strict, mais plus sûr.
  • Sessions personnalisées : Les gestionnaires de session personnalisés doivent désormais implémenter create_sid() et validateId().
  • Retour dans finally, __construct() ou __destruct() : Retourner une valeur dans ces contextes est déprécié car cela peut masquer des exceptions ou écraser des valeurs.
  • spl_object_hash() : Déprécié au profit de spl_object_id().

Ces changements, bien que parfois contraignants, visent à rendre PHP plus cohérent et robuste. Un bon jeu de tests unitaires et fonctionnels sera votre meilleur ami pour les détecter.

Préparer votre environnement pour PHP 8.6

La transition vers PHP 8.6, surtout pour un projet Symfony, demande un peu de préparation. Mais avec Docker, c'est généralement une formalité.

Mise à jour de l'environnement

Pour Docker, les images officielles seront rapidement disponibles après la sortie de la GA. Vous pourrez facilement basculer votre Dockerfile :

# Pour une application FPM
FROM php:8.6-fpm
# Pour une image CLI de développement/tests
# FROM php:8.6-cli
# Installation d'extensions PHP
RUN docker-php-ext-install zip pdo_mysql
# Installation de Composer
COPY --from=composer/composer:latest-bin /composer /usr/bin/composer

Si vous êtes sur un système Debian/Ubuntu, il faudra attendre que les dépôts tiers (comme Ondrej) mettent à disposition les paquets php8.6-fpm, php8.6-cli, etc. La commande d'installation sera alors classique :

sudo apt update
sudo apt install -y php8.6-fpm php8.6-cli php8.6-pdo-mysql

N'oubliez pas les paramètres PHP par défaut pour la sécurité des sessions : session.use_strict_mode = 1, session.cookie_httponly = 1, session.cookie_samesite = Lax. Ils sont activés par défaut, mais vérifiez qu'aucun ancien paramètre ne vient les écraser.

Compatibilité Symfony

Symfony est généralement très réactif aux nouvelles versions de PHP. La future version Symfony 8.2 devrait être entièrement compatible avec PHP 8.6, mais il est crucial de vérifier la compatibilité de vos bundles tiers et de vos extensions PHP. Un composer update suivi d'un composer install --no-dev et d'une série de tests est la première étape.

Pour les performances, en plus du JIT, pensez aux bonnes pratiques Symfony :

  • Restreindre les locales activées.
  • Dumper le conteneur de services en un seul fichier.
  • Utiliser le préchargement des classes OPcache.
  • Configurer OPcache pour des performances maximales (opcache.validate_timestamps=0 en production).
  • Optimiser l'autoloader Composer.

Le mot de la fin

PHP 8.6 est clairement une version qui consolide les acquis des versions 8.x tout en apportant des améliorations significatives. La Partial Function Application est, à mon sens, la fonctionnalité la plus excitante pour le quotidien du développeur, offrant une syntaxe plus concise et expressive pour les callbacks. Les optimisations de performance, notamment la Polling API, vont se faire sentir sans effort de notre part, ce qui est toujours appréciable.

La migration vers PHP 8.6, comme toute mise à jour majeure, demandera un peu d'attention pour les dépréciations, mais les bénéfices en termes de code plus propre, plus moderne et plus rapide en valent largement la peine. C'est une excellente opportunité pour dépoussiérer un peu nos bases de code et profiter d'un environnement PHP toujours plus robuste et performant. Alors, prêts à sauter le pas ?

Publié le 19/11/2026 · 9 min de lecture Partager X LinkedIn

← Précédent Kanzo : le kanban minimaliste qui parle aux humains et aux bots