PHP 8.5 est sorti le 20 novembre 2025. Il reste en support actif jusqu'à fin 2027, avec des correctifs de sécurité jusqu'en 2029. Ce n'est pas une release aussi marquante que les union types de 8.0 ou les enums de 8.1, mais plusieurs ajouts retirent de vrais points de friction du code backend au quotidien, surtout si vous écrivez du Laravel ou du Symfony.

L'opérateur pipe : |>

L'opérateur pipe chaîne des callables de gauche à droite sans variables intermédiaires ni appels imbriqués. Ça se lit comme un pipeline de données plutôt qu'une pile de parenthèses, et il se compose avec la syntaxe first-class callable (trim(...)). La partie gauche est une expression quelconque ; la droite, tout ce qui est appelable avec un argument.

// Avant : appels imbriqués, à lire de l'intérieur vers l'extérieur
$result = strtoupper(trim(str_replace('_', ' ', $rawInput)));

// PHP 8.5 : opérateur pipe, à lire de gauche à droite
$result = $rawInput
    |> fn ($s) => str_replace('_', ' ', $s)
    |> trim(...)
    |> strtoupper(...);

Parsing d'URI natif

PHP embarque désormais une extension URI native, vous arrêtez donc d'utiliser parse_url() et de gérer la normalisation à la main. Elle propose deux parseurs : Uri\Rfc3986\Uri pour la RFC 3986 stricte, et Uri\WhatWg\Url pour les règles WHATWG compatibles navigateur. Utiliser un vrai parseur plutôt que du travail sur chaîne ferme aussi une classe de bugs de sécurité autour de la confusion de host et de schéma dans les vérifications de redirection et de SSRF.

use Uri\Rfc3986\Uri;

$uri = Uri::parse('https://api.exemple.com/v1/users?page=2');

echo $uri->getHost();  // api.exemple.com
echo $uri->getPath();  // /v1/users
$uri->getQuery()->get('page'); // "2"

clone() avec modification de propriétés

Les classes readonly et les value objects avaient besoin d'une méthode "with" écrite à la main pour chaque mise à jour immuable : withStatus(), withEmail(), etc. La nouvelle syntaxe clone() clone un objet et surcharge des propriétés spécifiques en une seule expression, donc une chaîne de mises à jour reste lisible sans le boilerplate.

final readonly class Money
{
    public function __construct(
        public int $amount,
        public string $currency,
    ) {}
}

$price = new Money(1000, 'EUR');

// Avant : une méthode withAmount() écrite à la main sur chaque value object
// PHP 8.5 :
$discounted = clone($price, ['amount' => 800]);

L'attribut #[\NoDiscard]

Marquer une méthode avec #[\NoDiscard] fait émettre un avertissement PHP quand sa valeur de retour est ignorée. Ça attrape un bug courant : appeler une méthode qui retourne une nouvelle instance, comme le font les value objects immuables, sans utiliser le résultat en croyant qu'elle a muté sur place.

final readonly class Money
{
    #[\NoDiscard]
    public function add(Money $other): self
    {
        return new self($this->amount + $other->amount, $this->currency);
    }
}

$price->add($fee);          // avertissement : valeur de retour ignorée
$price = $price->add($fee); // usage correct

Petits gains utiles

• ✓array_first() et array_last() retournent le premier et le dernier élément sans reset() ou end() et leurs effets de bord sur le pointeur.
• ✓Les fatal errors incluent désormais un backtrace complet, donc un crash dans un log de prod vous donne la chaîne d'appels au lieu de juste la dernière ligne.
• ✓get_error_handler() et get_exception_handler() permettent d'inspecter les handlers actuellement enregistrés, utile dans les tests et le code de framework.
• ✓Les closures sont autorisées dans les expressions constantes, donc vous pouvez définir un callable par défaut sur une propriété ou une constante.
• ✓Les attributs peuvent s'appliquer aux constantes, ce que les frameworks utilisent pour attacher des metadata à des ensembles de constantes.

Quoi adopter maintenant

La mise à niveau

PHP 8.5 n'a pas de changement cassant pour le code applicatif typique, donc la mise à niveau est peu risquée. Lancez votre suite de tests, vérifiez la liste des déprécations pour ce que vos dépendances utilisent encore, et mettez à jour votre matrice CI. Laravel et Symfony le supportent tous les deux, donc côté framework c'est un bump de version.

PHP continue de prouver qu'un langage mature peut améliorer son ergonomie release après release sans casser la compatibilité ascendante. Aucune de ces fonctionnalités n'impose de réécriture ; ce sont des outils à utiliser la prochaine fois que vous touchez le code.