PHP 8.6 : l’éléphant continue de grandir

PHP 8.6 est prévu pour être publié le 19 novembre 2026. Comme chaque année, cette nouvelle version du langage arrive après plusieurs mois de versions de prépublication : Alpha, Beta, Release Candidate, puis la version finale.

La version Beta 3 est disponible depuis le 10 septembre, et le gel des fonctionnalités est prévu le 22 septembre, avant l'arrivée de la première Release Candidate le 24 septembre.

Si vous souhaitez vous amuser en testant les nouveautés de PHP 8.6, c'est donc le moment idéal !

On applique les fonctions à moitié

L'une des nouveautés les plus intéressantes de PHP 8.6 est l'arrivée de la Partial Function Application.

L'idée est assez simple : vous pouvez fournir seulement une partie des arguments d'une fonction afin d'obtenir une nouvelle closure qui attend les arguments restants.

Pour indiquer l'argument que l'on souhaite fournir plus tard, PHP introduit le placeholder ? :

1$makeSlug = str_replace(' ', '-', ?);
2 
3$makeSlug('Hello World');
4// Hello-World

On peut également l'utiliser avec les fonctions que l'on passe à array_map() :

1$titles = array_map(strtolower(?), $titles);

La closure créée conserve notamment les noms, types et valeurs par défaut des paramètres de la fonction originale.

C'est une fonctionnalité qui devrait notamment rendre certaines opérations de manipulation de tableaux et de collections beaucoup plus lisibles.

À noter que cette proposition avait déjà été refusée en 2021. Cette nouvelle version du RFC a finalement été adoptée avec 33 votes pour et aucun contre.

Une nouvelle fonction clamp()

PHP 8.6 apporte également une petite fonction qui risque de rapidement devenir un classique : clamp().

Elle permet de s'assurer qu'une valeur reste comprise entre une valeur minimale et une valeur maximale :

1clamp(10, min: 0, max: 100);
2// 10
3 
4clamp(101, min: 0, max: 100);
5// 100
6 
7clamp(-1, min: 0, max: 100);
8// 0

Jusqu'à présent, on écrivait généralement quelque chose comme :

1min(max($value, $min), $max);

Ce genre d'expression est efficace, mais peut rapidement devenir difficile à lire, et surtout, assez facile à inverser.

Avec clamp(), l'intention est beaucoup plus évidente :

1clamp($value, min: 0, max: 100);

La fonction fonctionne avec différents types comparables, notamment les chaînes de caractères et les objets DateTime.

PHP prend la mesure du temps

PHP 8.6 introduit une nouvelle classe Time\Duration permettant de représenter une durée, avec une précision pouvant aller jusqu'à la nanoseconde.

On peut créer une durée à partir de différentes unités :

1use Time\Duration;
2 
3$oneSecond = Duration::fromSeconds(1);
4 
5$halfSecond = $oneSecond->divideBy(2);
6 
7$total = $oneSecond->add($halfSecond);

Il devient également possible d'effectuer des calculs directement sur ces durées :

1$delay = Duration::fromMilliseconds(100)
2    ->multiplyBy(2 ** $attempt);

Et, chose intéressante, les comparaisons sont directement supportées :

1$total > $delay;

L'objectif est notamment de disposer d'un type commun que les fonctionnalités internes de PHP, mais aussi certaines APIs comme la nouvelle API de polling, pourront utiliser plutôt que de manipuler des int et des float dont la signification dépend du contexte.

Les propriétés readonly prennent enfin une valeur par défaut

Depuis PHP 8.1, les propriétés readonly sont très pratiques pour garantir qu'une valeur ne puisse pas être modifiée après son initialisation.

Mais jusqu'à PHP 8.5, leur attribuer une valeur par défaut était interdit.

PHP 8.6 lève cette restriction :

1final readonly class CreateBooksTable implements Migration
2{
3    public string $name = '2026_01_01_create_books_table';
4}

Cela peut sembler être un petit changement, mais il règle notamment certains cas où une propriété en lecture seule devait satisfaire une interface tout en ayant une valeur fixe.

Attention cependant : le comportement readonly ne change pas. La propriété ne pourra toujours pas être réassignée après son initialisation.

Les paramètres peuvent enfin avoir leur propre documentation

PHP 8.6 permet désormais de placer directement un commentaire de documentation au niveau d'un paramètre :

1function search(
2    /** Terms to search for in the database */
3    string $query,
4 
5    /** Maximum number of entries to return */
6    int $limit = 10,
7): array {
8    // ...
9}

Cela permet notamment d'éviter de devoir répéter le nom du paramètre dans un bloc @param situé au-dessus de la fonction :

1/**
2 * @param string $query Terms to search for in the database
3 * @param int $limit Maximum number of entries to return
4 */
5function search(string $query, int $limit = 10): array
6{
7    // ...
8}

Une petite évolution, mais qui devrait rendre certaines documentations PHP plus naturelles à écrire.

PHP apprend à attendre

PHP 8.6 introduit également une nouvelle API de polling avec le namespace Io\Poll.

Cette API fournit une interface commune aux différents mécanismes de polling disponibles selon les systèmes d'exploitation : epoll sous Linux, kqueue sous BSD et macOS, event ports sous Solaris ou encore WSAPoll sous Windows.

Un exemple simplifié :

 1use Io\Poll\{Context, Event, StreamPollHandle};
 2 
 3$poll = new Context();
 4 
 5$server = stream_socket_server('tcp://0.0.0.0:8080');
 6 
 7stream_set_blocking($server, false);
 8 
 9$poll->add(
10    new StreamPollHandle($server),
11    [Event::Read],
12    ['type' => 'server'],
13);
14 
15while (true) {
16    foreach ($poll->wait(1) as $watcher) {
17        if ($watcher->hasTriggered(Event::Read)) {
18            // Accept the connection
19        }
20    }
21}

L'objectif principal de cette API concerne les besoins internes de PHP, notamment la gestion des signaux et certaines améliorations de PHP-FPM.

Mais elle pourrait également intéresser les développeurs de runtimes asynchrones et les frameworks qui construisent des event loops en userland.

Un enum pour trier dans le bon sens

PHP 8.6 ajoute également un enum global SortDirection :

1SortDirection::Ascending;
2SortDirection::Descending;

Pour le moment, aucune fonctionnalité du cœur de PHP ne l'utilise directement.

L'idée est surtout de proposer un type commun que les bibliothèques puissent partager au lieu de définir chacune leur propre enum.

On peut par exemple imaginer son utilisation dans un query builder :

1$query->orderBy(
2    'created_at',
3    SortDirection::Descending,
4);

Pour l'écosystème PHP, ce genre de type partagé peut éviter la multiplication d'implémentations légèrement différentes d'une bibliothèque à l'autre.

Les enums peuvent maintenant personnaliser var_dump()

Depuis PHP 8.1, les enums ont rapidement trouvé leur place dans nos applications.

PHP 8.6 leur permet désormais d'implémenter __debugInfo() :

 1enum Status: int
 2{
 3    case Ok = 200;
 4 
 5    public function __debugInfo(): array
 6    {
 7        return [
 8            __CLASS__ . '::' . $this->name . ' = ' . $this->value,
 9        ];
10    }
11}

Il devient ainsi possible de contrôler ce qui est affiché lorsqu'un enum est inspecté avec var_dump().

Une petite amélioration, mais qui peut être pratique lorsqu'on travaille régulièrement avec des enums dans des outils de debug.

Les streams deviennent plus bavards

PHP 8.6 apporte également une nouvelle gestion des erreurs pour les streams.

Une nouvelle option error_mode permet de choisir entre le comportement actuel avec des warnings, les exceptions ou le silence.

Par exemple :

 1$context = stream_context_create([
 2    'stream' => [
 3        'error_mode' => StreamErrorMode::Exception,
 4    ],
 5]);
 6 
 7try {
 8    $stream = fopen(
 9        '/nonexistent/file.txt',
10        'r',
11        false,
12        $context,
13    );
14} catch (StreamException $e) {
15    foreach ($e->getErrors() as $error) {
16        echo $error->code->name . ': ' . $error->message;
17    }
18}

PHP introduit également stream_last_errors(), qui permet de récupérer des objets StreamError structurés correspondant aux dernières erreurs rencontrées.

Le RFC définit plus de 50 codes sémantiques différents via un nouvel enum StreamErrorCode.

Une évolution qui devrait rendre la gestion des erreurs liées aux streams beaucoup plus prévisible.

L'extension URI continue son petit bonhomme de chemin

L'extension URI introduite avec PHP 8.5 continue d'évoluer.

PHP 8.6 ajoute notamment des builders permettant de construire une URI sans devoir créer différents objets intermédiaires :

1$uri = new Uri\Rfc3986\UriBuilder()
2    ->setScheme('https')
3    ->setHost('example.com')
4    ->setPath('/foo/bar')
5    ->build();

De nouvelles méthodes comme getUriType() et getHostType() font également leur apparition, ainsi que des fonctions permettant de gérer l'encodage en pourcentage de composants individuels d'une URI.

PHP devient un peu plus sécurisé par défaut

Enfin, PHP 8.6 modifie plusieurs valeurs par défaut de php.ini pour les nouvelles installations :

Ces changements renforcent notamment la sécurité des sessions PHP natives.

Pour les applications Laravel, l'impact devrait être limité puisque Laravel gère ses propres cookies de session.

En revanche, si vous utilisez directement les sessions natives de PHP dans vos applications, il faudra vérifier que votre code ne dépend pas des anciennes valeurs par défaut.

Conclusion

Avec PHP 8.6, l'éléphant continue tranquillement son évolution.

Entre la Partial Function Application, clamp(), Time\Duration, les propriétés readonly avec une valeur par défaut, les DocComments sur les paramètres et les nouvelles APIs de polling et de gestion des streams, cette version apporte à la fois des petits raffinements syntaxiques et des briques plus importantes pour l'avenir de l'écosystème.

Comme souvent avec PHP, certaines fonctionnalités sont très visibles au quotidien, tandis que d'autres concernent davantage les développeurs de bibliothèques, de frameworks ou de runtimes.

Et côté Laravel, même si une partie de ces nouveautés restera probablement assez transparente pour les applications classiques, elles offrent de nouvelles possibilités aux packages et aux outils qui gravitent autour du framework.

PHP 8.6 sera officiellement disponible le 19 novembre 2026, mais il est déjà possible de tester la version Beta.

Écrit par

Ludovic Guénet

software engineer • mentor • bassist