PHP 8.6.0 est officiellement disponible depuis le 19 novembre 2026. Cette nouvelle branche du langage apporte plusieurs évolutions importantes pour les développeurs PHP : Partial Function Application, une nouvelle classe Time\Duration, une API de polling I/O, la fonction clamp(), l’enum SortDirection, les valeurs par défaut pour les propriétés readonly, une meilleure gestion des erreurs de streams et de nombreuses améliorations des extensions standard.
Pour les développeurs Drupal, la situation demande toutefois un peu plus de prudence : PHP 8.6 est stable côté PHP, mais son support officiel dans Drupal est encore en cours de finalisation au moment de la publication de cet article.
Dans cet article, nous allons voir les principales nouveautés de PHP 8.6, les changements de compatibilité, les dépréciations à surveiller et la stratégie de migration recommandée pour un projet PHP, Symfony ou Drupal.
PHP 8.6 en bref
| Élément | PHP 8.6 |
|---|---|
| Date de sortie | 19 novembre 2026 |
| Support actif | Jusqu’au 31 décembre 2028 |
| Support sécurité | Jusqu’au 31 décembre 2030 |
| Branche précédente | PHP 8.5 |
| Statut Drupal au 20 novembre 2026 | Support officiel PHP 8.6 encore en cours |
PHP 8.6 bénéficie de deux années de support actif, suivies de deux années supplémentaires consacrées aux correctifs de sécurité critiques.
Partial Function Application
L’une des nouveautés les plus visibles de PHP 8.6 est la Partial Function Application, souvent abrégée PFA.
Elle permet de fournir une partie des arguments d’une fonction à l’avance et de récupérer une Closure qui attend les arguments manquants.
PHP 8.6 utilise deux placeholders :
?représente exactement un argument à fournir ultérieurement ;...représente tous les arguments restants.
Avant PHP 8.6, on devait souvent écrire une fonction fléchée :
$versions = ['8.4', '8.5', '8.6'];
$supported = array_filter(
$versions,
fn (string $version): bool => version_compare($version, '8.6', '>='),
);Avec PHP 8.6 :
$versions = ['8.4', '8.5', '8.6'];
$supported = array_filter(
$versions,
version_compare(?, '8.6', '>='),
);On peut également préconfigurer plusieurs paramètres :
function formatPrice(float $amount, string $currency): string
{
return number_format($amount, 2) . ' ' . $currency;
}
$formatEuro = formatPrice(?, 'EUR');
echo $formatEuro(49.90);Cette fonctionnalité rend particulièrement élégants certains traitements fonctionnels, callbacks et pipelines de transformation. Elle réduit aussi le besoin d’écrire des closures uniquement destinées à transmettre des arguments à une autre fonction.
Une nouvelle classe Time\Duration
PHP 8.6 introduit Time\Duration, une classe immuable destinée à représenter une durée écoulée et non une date calendaire.
La différence avec DateInterval est importante. Un DateInterval peut contenir des notions telles que « un mois » ou « un jour », dont la durée réelle dépend du calendrier. Time\Duration représente au contraire une durée absolue avec une précision allant jusqu’à la nanoseconde.
use Time\Duration;
$timeout = Duration::fromSeconds(5);
$retryDelay = Duration::fromMilliseconds(250);
$total = $timeout->add($retryDelay);
var_dump($total->seconds);
var_dump($total->nanoseconds);Les durées peuvent être comparées et manipulées avec des méthodes comme add(), sub(), multiplyBy(), divideBy(), negate() ou absolute().
Cette nouvelle API est particulièrement intéressante pour les timeouts, les retries, les mesures de performances, les workers, les files de messages et les applications asynchrones.
Une nouvelle API Io\Poll pour les applications concurrentes
PHP 8.6 introduit une nouvelle API de polling destinée à surveiller efficacement plusieurs ressources I/O en parallèle.
L’API Io\Poll peut exploiter les mécanismes natifs disponibles selon le système, notamment epoll, kqueue ou WSAPoll. Elle vise à fournir une base commune plus scalable que stream_select() pour les bibliothèques d’event loop et les applications fortement concurrentes.
Le principe général est le suivant :
use Io\Poll\Context;
use Io\Poll\Event;
$poll = new Context();
$poll->add(
new StreamPollHandle($stream),
[Event::Read],
);
foreach ($poll->wait() as $watcher) {
$stream = $watcher->getHandle()->getStream();
// Traiter la ressource prête.
}Cette nouveauté intéressera principalement les runtimes asynchrones, serveurs applicatifs, event loops et bibliothèques telles que ReactPHP ou AMPHP. Pour un site Drupal traditionnel exécuté derrière PHP-FPM, l’impact direct à court terme sera limité.
La fonction clamp()
PHP dispose désormais nativement d’une fonction clamp() permettant de forcer une valeur à rester comprise entre une borne minimale et une borne maximale.
Avant PHP 8.6 :
$value = max(0, min($value, 100));Avec PHP 8.6 :
$value = clamp($value, 0, 100);Quelques exemples :
var_dump(clamp(-10, 0, 100));
// int(0)
var_dump(clamp(50, 0, 100));
// int(50)
var_dump(clamp(150, 0, 100));
// int(100)clamp() fonctionne avec des valeurs comparables et n’est donc pas limitée aux entiers.
Un enum SortDirection natif
PHP 8.6 fournit désormais l’enum global SortDirection avec deux valeurs :
SortDirection::Ascending
SortDirection::DescendingCela fournit enfin un type commun et explicite pour représenter une direction de tri.
function buildOrderBy(
string $field,
SortDirection $direction,
): string {
return $field . ' ' . match ($direction) {
SortDirection::Ascending => 'ASC',
SortDirection::Descending => 'DESC',
};
}
echo buildOrderBy('created', SortDirection::Descending);Les frameworks et bibliothèques utilisaient jusqu’ici leurs propres strings, constantes, booléens ou enums. Une primitive commune peut progressivement réduire ces différences d’API.
Des valeurs par défaut sur les propriétés readonly
PHP 8.6 assouplit une limitation des propriétés readonly : elles peuvent désormais avoir une valeur par défaut directement dans leur déclaration.
final readonly class ApiConfiguration
{
public string $version = 'v1';
public int $timeout = 30;
}La valeur par défaut compte comme l’initialisation de la propriété. Elle ne peut donc pas ensuite être remplacée depuis le constructeur.
Cette évolution est pratique pour les value objects, DTO et classes de configuration immuables contenant des valeurs fixes.
Les paramètres peuvent avoir leurs propres DocComments
PHP 8.6 permet de placer un DocComment directement sur un paramètre et ajoute ReflectionParameter::getDocComment().
function search(
/** Texte recherché */
string $query,
/** Nombre maximal de résultats */
int $limit = 10,
): array {
return [];
}
$parameter = new ReflectionParameter('search', 'query');
var_dump($parameter->getDocComment());Cela peut être utile aux frameworks reposant fortement sur Reflection, aux générateurs de documentation, aux systèmes d’injection de dépendances ou aux outils de génération automatique de schémas.
Reflection devient plus précise
Avec les propriétés readonly, les hooks de propriétés et la visibilité asymétrique, tester uniquement si une propriété est publique ne suffit plus toujours à savoir si elle est réellement accessible en lecture ou en écriture.
PHP 8.6 ajoute :
ReflectionProperty::isReadable()
ReflectionProperty::isWritable()Ces méthodes prennent en compte le contexte réel de la propriété, notamment sa visibilité, son état d’initialisation et ses hooks.
Une meilleure gestion des erreurs sur les streams
PHP 8.6 introduit une gestion structurée des erreurs sur les opérations utilisant des streams.
Les applications peuvent notamment demander qu’une erreur de stream déclenche une StreamException au lieu de se limiter à un warning PHP.
$context = stream_context_create([
'stream' => [
'error_mode' => StreamErrorMode::Exception,
],
]);
try {
$contents = file_get_contents(
'/path/to/file.txt',
context: $context,
);
} catch (StreamException $exception) {
foreach ($exception->getErrors() as $error) {
error_log($error->message);
}
}PHP ajoute également stream_last_errors() et stream_clear_errors().
Pour du code applicatif ou des bibliothèques, cette approche est plus robuste que l’ancien pattern @file_get_contents() suivi d’un error_get_last().
Des sessions plus sûres par défaut
PHP 8.6 renforce certains paramètres de session par défaut :
session.use_strict_modeest activé ;session.cookie_httponlyest activé ;session.cookie_samesiteutilise désormaisLax.
Le strict mode aide notamment à limiter les attaques de fixation de session.
Attention si votre application utilise un gestionnaire de session personnalisé : les handlers qui ne fournissent pas correctement create_sid() et validateId() déclenchent désormais des dépréciations.
Nouveautés cryptographiques avec Sodium
PHP 8.6 enrichit considérablement l’extension Sodium avec de nouvelles primitives.
Lorsque PHP est compilé avec libsodium 1.0.22 ou supérieur, il expose notamment X-Wing, un mécanisme hybride combinant ML-KEM-768 et X25519, ainsi que ML-KEM-768. PHP ajoute également des fonctions SHAKE, TurboSHAKE et IPcrypt.
Ces APIs concernent surtout les bibliothèques cryptographiques et protocoles qui souhaitent commencer à intégrer des primitives post-quantiques.
URI, Intl, MySQLi et Zip
Parmi les autres nouveautés importantes de PHP 8.6 :
- les classes
Uri\Rfc3986\UriBuilderetUri\WhatWg\UrlBuilderfacilitent la construction d’URI ; ZipArchive::openString()etZipArchive::closeString()permettent de travailler avec des archives en mémoire ;grapheme_strrev()inverse une chaîne par cluster de graphèmes ;IntlNumberRangeFormatterpermet de formater des plages de nombres ;mysqli::quote_string()ajoute une API analogue àPDO::quote().
Améliorations de performances
PHP 8.6 intègre plusieurs optimisations internes. PHP.net cite notamment :
- la compilation de certains appels
array_map()en boucles internes lorsqu’ils utilisent un callable de première classe ou une Partial Function Application ; - des appels
printf()plus rapides ; - la mise en cache de closures sans état ;
- des améliorations de l’encodage JSON.
Il faut toutefois éviter d’annoncer un gain global du type « PHP 8.6 est X % plus rapide ». PHP.net ne publie pas de pourcentage universel de gain pour une application web réelle. Les bénéfices dépendront fortement du workload et devront être mesurés sur le projet concerné.
Les principales dépréciations de PHP 8.6
Comme chaque nouvelle version, PHP 8.6 prépare aussi les suppressions futures de PHP 9.
return dans finally
Un return dans un bloc finally est désormais déprécié.
function load(): array
{
try {
return loadData();
} finally {
return [];
}
}Ce pattern est dangereux parce qu’il peut masquer une exception ou remplacer silencieusement la valeur retournée par le bloc try.
spl_object_hash()
spl_object_hash() est dépréciée au profit de :
spl_object_id($object);Cette dépréciation est particulièrement pertinente pour Drupal : l’issue de compatibilité PHP 8.6 de Drupal a déjà identifié des occurrences de spl_object_hash() dans Drupal Core qui doivent être adaptées.
Les fonctions mbregex
Les fonctions basées sur le moteur mbregex sont dépréciées et destinées à disparaître en PHP 9, notamment :
mb_ereg()
mb_ereg_match()
mb_ereg_replace()
mb_ereg_replace_callback()
mb_split()
...La recommandation générale est de migrer vers les fonctions PCRE telles que preg_match(), preg_replace() et preg_split() avec le modificateur Unicode u lorsque cela correspond au besoin.
Alias de types historiques
Les alias suivants sont dépréciés :
is_double() → is_float()
is_long() → is_int()
is_integer() → is_int()
doubleval() → floatval()strcoll() et SORT_LOCALE_STRING
strcoll() et SORT_LOCALE_STRING sont dépréciés. PHP recommande l’utilisation de Collator via l’extension Intl pour les tris linguistiques.
Objets passés comme tableaux
PHP déprécie progressivement plusieurs comportements où un objet était implicitement interprété comme un tableau, notamment avec :
array_walk()
array_walk_recursive()
http_build_query()
mb_convert_variables()Lorsqu’un tel comportement est réellement voulu, il faut convertir explicitement l’objet, par exemple avec get_object_vars().
Breaking changes et changements de comportement
Toutes les nouveautés de PHP 8.6 ne sont pas de simples ajouts.
trim(), ltrim() et rtrim() retirent désormais aussi par défaut le caractère form feed \f.
var_dump(trim("\f hello \f"));
// PHP 8.6 : "hello"Plusieurs fonctions lèvent désormais une ValueError lorsqu’elles reçoivent des flags invalides, des valeurs hors plage ou des chaînes contenant des octets NUL, plutôt que de tronquer ou d’ignorer silencieusement les valeurs.
fclose(), file_put_contents() et copy() peuvent également retourner false si le flush ou la fermeture du stream échoue.
Ces changements sont généralement plus sûrs, mais peuvent révéler des hypothèses incorrectes dans du code ancien.
PHP 8.6 et Drupal : peut-on déjà migrer ?
Pour un site Drupal en production, je déconseille de basculer immédiatement vers PHP 8.6 tant que Drupal ne l’a pas officiellement ajouté à sa matrice de versions PHP supportées.
Au 20 novembre 2026, la documentation officielle Drupal renvoie encore vers l’issue #3608511 consacrée au support de PHP 8.6.
Les travaux sont déjà bien avancés : Drupal teste PHP 8.6 en CI et plusieurs incompatibilités ont été identifiées dans Drupal Core et dans certaines dépendances. Cela ne signifie toutefois pas encore que la combinaison est officiellement supportée pour un site de production.
Pour Drupal, il faut distinguer trois niveaux :
| État | Recommandation |
|---|---|
| PHP 8.6 stable | Oui, côté projet PHP |
| Tests Drupal avec PHP 8.6 | Oui, en environnement de développement ou CI |
| Production Drupal sous PHP 8.6 | Attendre la validation officielle de Drupal et de vos dépendances |
La situation devrait évoluer rapidement avec Drupal 11.5 et Drupal 12, dont les travaux de compatibilité PHP 8.6 font partie du cycle de développement en cours.
Et Symfony ?
Symfony 7.4 LTS requiert PHP 8.2 ou supérieur et Symfony 8.1 requiert PHP 8.4 ou supérieur.
Ces contraintes minimales ne bloquent pas mécaniquement PHP 8.6, mais elles ne garantissent pas que toutes les bibliothèques installées dans votre projet soient déjà exemptes de dépréciations ou de problèmes de compatibilité.
Il faut donc tester l’ensemble du graphe Composer du projet, pas seulement Symfony.
Composer : vérifier les dépendances avant la migration
Avant de tester PHP 8.6, commencez par utiliser une version récente de Composer. Composer 2.11.1 a notamment corrigé une dépréciation liée à PHP 8.6 et Composer 2.11.2 est la version stable disponible au moment de la rédaction de cet article.
Pour identifier les packages qui bloquent PHP 8.6 :
composer prohibits php 8.6ou :
composer why-not php 8.6Après installation dans un environnement réellement exécuté sous PHP 8.6 :
composer check-platform-reqsEt pour vérifier les vulnérabilités connues :
composer auditÉvitez autant que possible de contourner les incompatibilités avec --ignore-platform-reqs. Cette option peut être utile ponctuellement pour diagnostiquer un projet, mais elle ne transforme pas une dépendance incompatible en dépendance compatible.
Stratégie de migration vers PHP 8.6
- Mettre à jour Composer et les dépendances du projet sur la version PHP actuellement supportée.
- Lancer
composer prohibits php 8.6. - Créer un environnement de développement ou de CI exécutant réellement PHP 8.6.
- Activer l’affichage des
E_DEPRECATEDdans les tests et les logs. - Exécuter PHPUnit et les autres tests automatisés.
- Tester les commandes CLI, workers, cron, files de messages et traitements asynchrones.
- Contrôler les extensions PHP et lancer
composer check-platform-reqs. - Analyser les logs pour détecter les nouvelles dépréciations PHP 8.6.
- Mesurer les performances de l’application avant et après migration au lieu de supposer un gain.
- Pour Drupal, attendre que la version utilisée soit officiellement déclarée compatible avant le passage en production.
PHP 8.6 vaut-il la peine d’être adopté rapidement ?
Pour un projet PHP autonome ou une application dont les dépendances sont déjà compatibles, PHP 8.6 constitue une évolution intéressante : le langage gagne en expressivité avec Partial Function Application, en précision avec Time\Duration, en robustesse avec les nouvelles erreurs de streams et en capacité pour les architectures concurrentes grâce à Io\Poll.
Pour Drupal, la réponse est différente : PHP 8.6 mérite d’être intégré dès maintenant dans les environnements de test afin d’identifier les dépréciations et incompatibilités, mais le passage en production doit rester aligné avec la matrice de support officielle de Drupal.
FAQ sur PHP 8.6
Quand PHP 8.6 est-il sorti ?
PHP 8.6.0 est sorti officiellement le 19 novembre 2026.
Jusqu’à quand PHP 8.6 sera-t-il supporté ?
Le support actif de PHP 8.6 court jusqu’au 31 décembre 2028. Le support réservé aux correctifs de sécurité critiques se poursuit ensuite jusqu’au 31 décembre 2030.
Quelle est la principale nouveauté de PHP 8.6 ?
Il n’y en a pas une seule. Parmi les nouveautés les plus importantes figurent Partial Function Application, Time\Duration, l’API Io\Poll, clamp(), l’enum SortDirection et les valeurs par défaut pour les propriétés readonly.
Drupal supporte-t-il PHP 8.6 ?
Au 20 novembre 2026, le support officiel est encore en cours de finalisation dans Drupal Core. Il est possible et recommandé de commencer les tests en développement et en CI, mais il est préférable d’attendre la validation officielle avant une migration de production.
Symfony fonctionne-t-il avec PHP 8.6 ?
Les versions récentes de Symfony imposent des versions minimales de PHP compatibles avec PHP 8.6 du point de vue des contraintes de version. Il faut néanmoins vérifier toutes les dépendances Composer du projet et effectuer les tests applicatifs.
Comment savoir si un projet Composer bloque PHP 8.6 ?
Utilisez :
composer prohibits php 8.6puis testez l’environnement réel avec :
composer check-platform-reqsConclusion
PHP 8.6 est une version riche, davantage orientée vers l’expressivité du langage, la robustesse et les fondations nécessaires aux applications modernes.
Partial Function Application devrait simplifier de nombreux callbacks. Time\Duration apporte enfin une représentation standardisée des durées. Io\Poll ouvre la voie à une meilleure infrastructure pour les event loops et les applications concurrentes. Les évolutions autour des streams, des sessions et de Reflection renforcent en parallèle la sécurité et la cohérence des APIs.
Comme toujours, une nouvelle version PHP ne doit toutefois pas être déployée en production uniquement parce qu’elle est disponible. La bonne approche consiste à tester tôt, corriger les dépréciations, vérifier les dépendances Composer et respecter le calendrier de compatibilité du framework ou du CMS utilisé.
Pour Drupal en particulier, PHP 8.6 est aujourd’hui une excellente cible de tests, mais il faut encore attendre la validation officielle de la branche Drupal utilisée avant de généraliser son usage en production.