Le 20 novembre 2025 marque la sortie officielle de PHP 8.5, une mise à jour majeure du langage PHP. Cette version apporte de nouvelles fonctionnalités importantes, notamment l’extension URI, l’opérateur Pipe pour chaîner les opérations de manière fonctionnelle, ainsi que le support pour modifier les propriétés lors du clonage d’objets immuables. PHP 8.5 améliore également la lisibilité du code, les performances, et la sécurité, tout en introduisant des dépréciations pour encourager le nettoyage du code legacy.

Voici un tour d’horizon avec comparatifs PHP 8.4 pour mieux comprendre les changements.

Les nouveautés

L’opérateur Pipe (|>)

Le pipe operator permet de chaîner les traitements de gauche à droite de manière claire et fonctionnelle.

<?php

$text = strtolower(str_replace(' ', '-', trim(' Hello-World '))) ;

echo $text ;
// hello world

<?php

$text = ' Hello-World '
        |> trim(...)
        |> (fn($s) => str_replace('-', ' ', $s))
        |> strtolower(...);

echo $text ;
// hello world

Cela réduit les variables temporaires et d’améliore la lisibilité du code.

Clone avec modification (“with‑er” pattern)

En PHP 8.5, il est possible de modifier directement des propriétés lors du clonage d’un objet.

Avant, il fallait récupérer toutes les propriétés et créer une nouvelle instance manuellement.

Cette nouveauté simplifie le pattern “with”, le rendant plus lisible et compact, surtout pour les objets immuables (readonly).

<?php


readonly class Vehicle
{
    public function __construct(
        public string $brand,
        public int $power = 200
    ) {}

    public function withPower(int $power): self
    {
        // On récupère toutes les propriétés de l'objet
        $values = get_object_vars($this);
        // On modifie la propriété souhaitée
        $values['power'] = $power;

        // On crée une nouvelle instance avec les valeurs modifiées
        return new self(...$values);
    }
}

$car = new Vehicle('Tesla', 200);
$fastCar = $car->withPower(250);

echo "{$car->brand} - {$car->power} ch\n";     // Tesla - 200 ch
echo "{$fastCar->brand} - {$fastCar->power} ch\n"; // Tesla – 250 ch

<?php

readonly class Vehicle
{
    public function __construct(
        public string $brand,
        public int $power = 200
    ) {}

    public function withPower(int $power): self
    {
        // Nouveau : clone avec modifications directes
        return clone($this, [
            'power' => $power,
        ]);
    }
}

$car = new Vehicle('Tesla', 200);
$fastCar = $car->withPower(250);

echo "{$car->brand} - {$car->power} ch\n";     // Tesla - 200 ch
echo "{$fastCar->brand} - {$fastCar->power} ch\n"; // Tesla – 250 ch

Extension URI native

Cela permet de standardiser la manipulation des URLs.

<?php

$url = 'https://webnet.fr/path?foo=1#bar';
$parts = parse_url($url);

echo $parts['host'];
// "webnet.fr"

<?php

use Uri\Rfc3986\Uri;

$uri = new Uri('https://webnet.fr/path?foo=1#bar');
echo $uri->getHost();
// "webnet.fr"

Nouvelles fonctions array_first() et array_last()

Introduction de deux nouvelles fonctions pratiques pour travailler avec les tableaux : array_first() et array_last(). Ces fonctions simplifient la récupération de la première ou de la dernière valeur d’un tableau, en remplaçant l’usage plus ancien de reset() et end().

Comportement

• array_first(array $array): mixed : retourne le premier élément du tableau.
• array_last(array $array): mixed : retourne le dernier élément du tableau.
• Si le tableau est vide, ces fonctions retournent null, ce qui les rend plus simple l’utilisation de l’opérateur ??.

<?php

$arr = [10, 20, 30];

$first = reset($arr); // renvoie 10
$last  = end($arr);   // renvoie 30

<?php

$arr = [10, 20, 30];

$first = array_first($arr); // renvoie 10
$last  = array_last($arr);  // renvoie 30

$users = [];

$firstUser = array_first($users) ?? 'Aucun utilisateur';
$lastUser  = array_last($users)  ?? 'Aucun utilisateur';

echo $firstUser; // Affiche : Aucun utilisateur
echo $lastUser;  // Affiche : Aucun utilisateur

L’attribut : #[\NoDiscard]

En ajoutant l’attribut #[\NoDiscard] à une fonction, PHP vérifie si la valeur retournée est utilisée et émet un avertissement si ce n’est pas le cas.

Cela permet d’améliorer la sécurité des API dont la valeur de retour est importante, mais où il est facile d’oublier de l’utiliser par accident.

La conversion explicite en (void) peut être utilisée pour indiquer qu’une valeur est volontairement ignorée.

<?php

function getTotal(float $subtotal, float $tax): float
{
    return $subtotal + $tax;
}
getTotal(10.5, 2);
//Pas de warning

<?php

#[\NoDiscard]
function getTotal(float $subtotal, float $tax): float
{
    return $subtotal + $tax;
}

getTotal(10.5, 2);
//Warning: The return value of function getTotal() should either be used or intentionally ignored by casting it as (void) in php shell code on line 7

Closures & First-Class Callables dans les expressions constantes

Jusqu’à PHP 8.4, tu ne pouvais pas utiliser de closures (fonctions anonymes) ou de first-class callables à des endroits qui exigent des expressions constantes :

• les paramètres d’attributs,
• les valeurs par défaut de propriétés ou de paramètres,
• les constantes de classe.

En PHP 8.5, on autorise l’utilisation de :

• closures statiques (static function () { … })
• first-class callables (foo(…), ClassName::method(…))

dans des expressions considérées comme constantes, y compris dans les attributs.

<?php

#[ApiResource(
    security: new Expression("user.id === object.getAuthor().id")
)]
class Post
{
    public string $title;
}

<?php

#[ApiResource(
    security: static fn ($object, $user): bool =>
        $user->id === $object->getAuthor()->id
)]
class Post
{
    public string $title;
}

Fonctionnalités et améliorations supplémentaires

Persistent cURL Share Handles

Contrairement à curl_share_init(), les handles créés par curl_share_init_persistent() ne seront pas détruits à la fin de la requête PHP.
Si un handle de partage persistant possédant le même ensemble d’options de partage est trouvé, il sera réutilisé, ce qui évite le coût d’initialisation des handles cURL à chaque fois.

Amélioration des erreurs fatales

Les erreurs fatales (comme un dépassement du temps d’exécution maximum) incluent désormais une trace complète.

Attributs étendus

• Les attributs peuvent désormais cibler les constantes.
• L’attribut #[\Override] peut maintenant être appliqué aux propriétés.
• L’attribut #[\Deprecated] peut maintenant être utilisé sur les traits et les constantes.
• Nouvel attribut #[\DelayedTargetValidation] : permet de supprimer les erreurs à la compilation pour les attributs utilisés sur des cibles invalides.

Propriétés statiques et finales

• Les propriétés statiques supportent désormais une visibilité asymétrique.
• Les propriétés peuvent être marquées comme finales via le constructor property promotion.

Fonctions et méthodes supplémentaires

• Ajout de la méthode Closure::getCurrent() pour simplifier la récursion dans les fonctions anonymes.
• setcookie() et setrawcookie() supportent désormais la clé partitionnée.
• Les 2 nouvelles fonctions get_error_handler() et get_exception_handler() permettent de récupérer dynamiquement les gestionnaires en cours
• Nouvelles méthodes DOM : Dom\Element::getElementsByClassName() et Dom\Element::insertAdjacentHTML().
• Nouvelle fonction grapheme_levenshtein().

Dépréciations et ruptures de compatibilité

Cycle de vie

Date de sortie : 20 novembre 2025

Fin du support actif (bug fixes + sécurité) : 31 décembre 2027

Fin du support de sécurité (EOL) : 31 décembre 2029

Pour en savoir plus sur nos expertises rendez-vous sur webnet.fr.