PHP 8.5 : Liste des nouveautés, amélioration et performance

PHP 8.5, dont la sortie officielle est le 20 novembre 2025, est une étape charnière pour les développeurs web. Chaque nouvelle version de PHP apporte son lot d’améliorations, mais celle-ci se distingue par une orientation encore plus nette vers la performance, la sécurité et la simplification du code.

Si vous avez déjà connu le grand virage qu’avait représenté PHP 7, ou la modernisation apportée par PHP 8.0 avec ses attributs et son compilateur JIT, vous allez retrouver cette même sensation d’évolution majeure. En coulisse, la communauté PHP s’active depuis des mois pour livrer une version plus fluide, plus stable et plus adaptée aux besoins modernes du développement web.

L’objectif de PHP 8.5 est clair : permettre aux développeurs de coder plus vite, plus proprement et plus efficacement. Mais au-delà des chiffres de performance, c’est aussi une version pensée pour rendre le langage encore plus agréable à utiliser au quotidien. Que vous soyez développeur confirmé ou débutant curieux, vous allez découvrir ce que cette nouvelle version change concrètement dans vos projets.

Préparez-vous, car PHP 8.5 n’est pas une simple mise à jour technique : c’est un pas de plus vers un PHP moderne, élégant et robuste — bref, un compagnon de développement toujours plus fiable.

Mettre à jour la version de PHP 8.5

Mettre à jour PHP peut sembler anodin, mais c’est souvent une étape décisive dans la vie d’un site web. Une nouvelle version, comme PHP 8.5, apporte son lot de nouveautés : meilleure vitesse d’exécution, sécurité renforcée, et compatibilité accrue avec les frameworks modernes. Pourtant, derrière cette promesse de performance, une mise à jour mal préparée peut transformer un site fonctionnel en un écran d’erreur.

Pour commencer, nous allons voir ensemble comment mettre à jour PHP 8.5 correctement, sans rien casser. Mais avant de plonger dans le côté technique, prenons un instant pour comprendre pourquoi cette mise à jour est cruciale.

Chaque version de PHP arrive avec des améliorations majeures :

• Des correctifs de failles de sécurité qui protègent votre serveur.
• Des optimisations du moteur interne (comme JIT, introduit en PHP 8).
• Des fonctionnalités qui simplifient votre code et évitent les erreurs logiques.

Rester sur une version obsolète, c’est un peu comme continuer à rouler avec un vieux navigateur qui ne supporte plus les nouveaux sites : ça fonctionne, mais jusqu’à quand ? et avec quels risques ?

Étape 1 : Vérifier la version actuelle de PHP

Avant toute chose, il faut savoir où vous en êtes. Si vous travaillez en local, ouvrez votre terminal et tapez :

php -v

Cela vous affichera la version actuellement installée. Si vous êtes sur un hébergement mutualisé, créez un petit fichier nommé version.php avec ce contenu :

<?php
  phpinfo();
?>

Envoyez-le à la racine de votre site et ouvrez-le dans votre navigateur :
https://votresite.fr/version.php

Une page s’affichera avec toutes les informations techniques de votre environnement. Vous pourrez ensuite la supprimer une fois la vérification faite.

Étape 2 : Sauvegarder avant tout

Avant de toucher à quoi que ce soit, sauvegardez votre site et votre base de données. On ne le répétera jamais assez : une mise à jour, même mineure, peut entraîner des incompatibilités avec certaines extensions ou lignes de code anciennes.

Si vous êtes sur un hébergeur comme OVH, Ionos, o2switch… leur interface propose souvent une sauvegarde automatique (souvent appelée snapshot ou sauvegarde intégrale). Conservez-en une copie sur votre ordinateur avant de continuer.

Étape 3 : Vérifier la compatibilité du code avec PHP 8.5

Avant de passer à PHP 8.5, il faut s’assurer que votre code (ou vos CMS et plugins) est compatible. Pour WordPress, par exemple, connectez-vous à votre tableau de bord et vérifiez :

Tableau de bord → Mises à jour → Compatibilité PHP

Les extensions non maintenues depuis plusieurs années peuvent poser problème. Dans ce cas, cherchez une alternative plus récente.

Si vous codez à la main, vous pouvez utiliser un outil comme PHP Compatibility Checker (un package Composer) :

composer require --dev phpcompatibility/php-compatibility

Il analysera vos fichiers et vous indiquera les fonctions obsolètes à corriger.

Vous ne connaissez pas Composer ? Consultez notre guide : Composer, le tutoriel complet : Installation et utilisation.

Étape 4 : Mettre à jour PHP selon votre environnement

La méthode dépend du contexte :

1. Sur un serveur mutualisé
La plupart des hébergeurs vous laissent choisir la version PHP via leur panneau de configuration. Par exemple, chez OVH :

Hébergement → Configuration → Version PHP → 8.5 (ou la plus récente disponible)

L’opération prend généralement quelques minutes.

2. En local (XAMPP, MAMP, Laragon, etc.)
Téléchargez la dernière version depuis php.net. Remplacez l’ancien dossier php par le nouveau (après sauvegarde), puis redémarrez Apache ou Nginx.

3. Sur un serveur dédié ou VPS (Linux)
Sous Debian ou Ubuntu :

sudo apt update
sudo apt install php8.5

Sous CentOS ou Fedora :

sudo dnf install php8.5

Enfin, redémarrez votre serveur web :

sudo systemctl restart apache2

ou

sudo systemctl restart nginx

Étape 5 : Tester votre site après la mise à jour

Une fois la mise à jour faite, retournez sur votre site et testez : les pages principales, les formulaires, les connexions, les envois de mail… tout ce qui repose sur PHP.

Si tout fonctionne, félicitations ! Sinon, consultez les journaux d’erreur (souvent dans /var/log/apache2/error.log ou /logs/error.log selon votre hébergement).

Un message comme “Deprecated function” n’est pas forcément grave : il s’agit souvent d’une fonction ancienne qu’il faudra simplement remplacer plus tard.

Mettre à jour sa version de PHP n’est pas un luxe, c’est une nécessité. C’est un peu comme entretenir le moteur de votre voiture : invisible au quotidien, mais vital pour votre sécurité et vos performances. Chez certains hébergeurs, le maintient d’anciennes versions de PHP sont payantes, c’est donc aussi une économie.

En prenant le temps de sauvegarder, de vérifier la compatibilité et de suivre les étapes avec méthode, vous éviterez les mauvaises surprises et profiterez pleinement des avantages de PHP 8.5.

L’opérateur pipe (|>) avec PHP 8.5

Vous avez sans doute déjà écrit des appels imbriqués de fonctions à la manière de :

$result = trim(strtoupper(htmlentities($input)));

C’est parfois lisible, mais dès qu’on ajoute plus d’étapes, ça devient vite un casse-tête. Avec PHP 8.5, l’opérateur pipe (|>) va permettre de chaîner les appels de gauche à droite, ce qui améliore la lisibilité et donne un code plus « fluide ».

Imaginons que vous traitiez une chaîne utilisateur avant affichage :

$clean = "  Bonjour à tous !  "
    |> trim(...)
    |> strtolower(...)
    |> htmlentities(...);
echo $clean;  
// Affiche "bonjour à tous !"

Dans cet exemple :

• On commence par trim(...) pour enlever les espaces.
• Puis strtolower(...) pour mettre en minuscules.
• Enfin htmlentities(...) pour échapper les caractères HTML.

Le résultat est plus clair qu’avec des appels imbriqués.

À noter : L’opérateur pipe impose que chaque fonction accepte au moins un paramètre, et que ce paramètre soit le résultat de l’expression précédente. Certaines fonctions très spécifiques ne sont pas compatibles directement.

Fonctions d’array : array_first() et array_last()

Depuis longtemps, pour obtenir la première ou la dernière valeur d’un tableau, on utilisait des fonctions comme reset()/end() ou on jouait avec array_values() et array_key_last(). Cela rendait parfois le code lourd ou moins évident à lire. Avec PHP 8.5, on gagne deux fonctions très simples pour ces cas courants.

$users = ['Alice', 'Bob', 'Charlie'];

$firstUser = array_first($users);  // 'Alice'
$lastUser  = array_last($users);   // 'Charlie'

$data = ['name' => 'John', 'age' => 30, 'city' => 'Paris'];
echo array_first($data); // 'John'
echo array_last($data);  // 'Paris'

Si le tableau est vide, array_first() ou array_last() retourneront null.

Meilleure gestion d’erreurs et d’exceptions

Quand un script plante, vous voulez avoir le maximum d’informations pour diagnostiquer. PHP 8.5 introduit l’affichage de la stack trace (trace d’appel) pour les erreurs fatales, et deux fonctions pour récupérer les gestionnaires d’erreurs/exceptions en cours. Ceci est très utile notamment pour déboguer des applications complexes ou des frameworks.

3.1 : Récupérer le gestionnaire d’erreurs

set_error_handler(fn($errno, $errstr) => false);
var_dump(get_error_handler()); // Affiche le callback actuellement défini
restore_error_handler();

3.2 : Afficher une trace lors d’une erreur fatale
Dans php.ini :

fatal_error_backtraces = On

Lorsqu’une erreur fatale survient, la trace complète sera affichée, ce qui vous permet de voir toutes les fonctions appelées jusqu’au plantage.

À noter : Même si cela ne change pas la logique de vos fonctions métier, ça change la qualité de votre débogage, ce qui signifie moins de temps perdu à deviner « quel appel a cassé ». Un vrai gain pour vos projets travaux sur votre site code.crea-troyes.fr.

Nouveautés pour l’internationalisation (i18n)

Si vous développez des sites multilingues ou avec des utilisateurs dans des langues à écriture de droite à gauche (RTL, par exemple l’arabe ou l’hébreu), vous savez combien ça peut être pénible de détecter le bon sens d’écriture ou de formater correctement les listes. PHP 8.5 apporte des outils pour ça.

use Locale;

$locale = 'ar-EG';
if (Locale::isRightToLeft($locale)) {
    echo "Le script s’écrit de droite à gauche.";
}
if (locale_is_right_to_left('he-IL')) {
    echo "Hébreu détecté, sens RTL.";
}

// Exemple de liste formatée
$formatter = new IntlListFormatter('en', IntlListFormatter::TYPE_CONJUNCTION);
echo $formatter->format(['pommes', 'bananes', 'oranges']); // "pommes, bananes et oranges"

Savoir que PHP 8.5 propose une fonction dédiée fait presque soupirer de soulagement.

Nouvelle constante : PHP_BUILD_DATE

Pour vos pipelines de déploiement ou vos logs d’infrastructure, il est souvent utile de connaître quand la version PHP a été construite. Cette constante permet de le savoir directement depuis le code.

echo 'Cette version de PHP a été construite le : ' . PHP_BUILD_DATE;
// Affiche par exemple : "Sep 16 2025 10:44:26"

À noter : C’est une addition légère mais utile pour les environnements de production ou de staging, notamment pour traquer des divergences entre serveurs.

Closures & « first-class callables » dans les expressions de constantes avec PHP 8.5

Désormais il est possible d’utiliser des closures (static function …) ou des “first-class callables” dans la définition de constantes (avec certaines limitations) — ce qui ouvre la voie à plus de flexibilité dans la déclaration d’API ou de constantes d’un module. Par exemple :

class Exemple {
    public const UPPER = static function(string $v): string {
        return strtoupper($v);
    };
    public const LOWER = 'strtolower'(...);
}

Cette possibilité permet de “pré-définir” des comportements constants au lieu d’avoir à les coder dans des fonctions séparées.

Promotion de propriété finale (final property promotion)

Dans la version 8.5 de PHP, vous pouvez combiner promotion de propriétés dans le constructeur et la qualifier en final, ce qui empêche que cette propriété soit modifiée dans une classe enfant. Par exemple :

class User {
    public function __construct(
        final public readonly string $name
    ) {}
}

Cela simplifie la définition d’objets immuables et améliore la clarté de l’intention (vous définissez une propriété qui ne peut pas être redéfinie).

L’ajout de la promotion finale permet directement de déclarer dans le constructeur que la propriété ne sera jamais modifiée — plus besoin d’ajouter des commentaires ou des méthodes “private set”.

Nouvelle fonction Unicode-aware grapheme_levenshtein

Cette fonction permet de calculer la “distance” (nombre d’opérations d’édition) entre deux chaînes de caractères en tenant compte des graphemes (unités visuelles de texte, par exemple “é” est souvent traité comme un seul grapheme) plutôt que des simples caractères. Exemple :

echo grapheme_levenshtein('café', 'cafe'); // 1 par exemple

C’est utile quand vous travaillez avec des textes multilingues ou accentués.

La fonction pour la distance de Levenshtein Unicode permet d’éviter des bugs subtils quand on compare des mots accentués ou des langues complexes.

La classe Directory modernisée dans PHP 8.5

La classe Directory (issue de versions très anciennes de PHP) est améliorée : elle devient final, non sérialisable, avec des propriétés dynamiques interdites, etc. Par exemple :

$dir = new Directory('/chemin'); // ceci deviendra incorrect ou déconseillé
$dir = dir('/chemin');           // la bonne manière recommandée

Cela participe au “nettoyage” de certaines parties historiques du langage.

Même si elles ne sont pas “révolutionnaires” en comparaison de certains grands changements de PHP (comme l’arrivée des types unis ou du JIT dans les versions précédentes), ces évolutions sont pratiques, orientées développeur, et permettent de rendre votre code plus clair, plus moderne, plus maintenable.

Une nouvelle API pour manipuler les URL et URI

Pendant longtemps, travailler avec des URL en PHP reposait sur des fonctions parfois limitées comme parse_url() ou http_build_query(). PHP 8.5 introduit une nouvelle API complète, conforme aux standards RFC 3986 et WHATWG, pour manipuler proprement les adresses web.

Cette nouveauté apporte des classes dédiées (par exemple Uri\Rfc3986\Uri et Uri\WhatWg\Url) qui permettent de lire, modifier et reconstruire des URL de façon bien plus sûre et structurée.

use Uri\Rfc3986\Uri;

$url = new Uri('https://crea-troyes.fr/formations?cours=php');
echo $url->getHost(); // affiche "crea-troyes.fr"

$newUrl = $url->withQuery('cours=php85&niveau=avancé');
echo (string) $newUrl;
// affiche "https://crea-troyes.fr/formations?cours=php85&niveau=avancé"

Grâce à cette nouvelle approche orientée objet, fini les concaténations de chaînes à rallonge pour modifier un paramètre d’URL. Votre code devient plus propre et plus robuste face aux cas complexes (accents, caractères spéciaux, encodages, etc.).

L’attribut #[\NoDiscard] : ne plus ignorer les valeurs importantes

Imaginez une fonction qui calcule un résultat crucial, comme une vérification ou une opération sensible. Avec le nouvel attribut #[\NoDiscard], vous pouvez signaler à PHP 8.5 qu’il ne faut pas ignorer la valeur de retour de cette fonction.

C’est une manière élégante d’éviter les oublis : si quelqu’un appelle la fonction sans utiliser son résultat, un avertissement sera levé.

#[\NoDiscard]
function verifierMotDePasse(string $motDePasse): bool {
    return strlen($motDePasse) >= 8;
}

// Mauvaise utilisation : PHP émet un avertissement
verifierMotDePasse('123');

// Bonne utilisation :
if (!verifierMotDePasse('12345678')) {
    echo "Mot de passe trop court.";
}

Cet attribut peut sembler anecdotique, mais il améliore la qualité du code dans les projets collaboratifs. Il évite qu’un développeur négligent appelle une fonction critique sans en exploiter le retour.

La visibilité asymétrique des propriétés statiques

PHP 8.4 avait déjà introduit la possibilité de définir une visibilité différente pour la lecture et l’écriture d’une propriété d’objet. Avec PHP 8.5, cette asymétrie s’étend aux propriétés statiques.

En clair : vous pouvez désormais créer une variable statique accessible en lecture partout, mais modifiable uniquement à l’intérieur de la classe.

class Configuration {
    public private(set) static string $mode = 'production';

    public static function activerTest() {
        self::$mode = 'test';
    }
}

echo Configuration::$mode; // OK : lecture autorisée
// Configuration::$mode = 'debug'; // Erreur : écriture interdite

Cela évite qu’un script externe vienne modifier une variable sensible (comme un mode de production) tout en permettant de la consulter. Une vraie amélioration pour la sécurité et la clarté du code.

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

OPcache devient obligatoire

Si vous avez déjà géré un serveur PHP, vous connaissez probablement OPcache, ce module qui garde en mémoire les scripts compilés pour accélérer leur exécution. Jusqu’ici, OPcache était activable ou non selon les besoins.

Avec PHP 8.5, OPcache devient une fonctionnalité intégrée par défaut, considérée comme essentielle au bon fonctionnement du langage.

Concrètement, cela veut dire que :

• Tous les environnements modernes PHP bénéficieront automatiquement des performances d’OPcache.
• Les différences entre serveurs (certains ayant OPcache activé, d’autres non) disparaîtront.
• Les performances de PHP devraient être plus homogènes et plus rapides, même sans configuration manuelle.

C’est un peu comme si PHP décidait d’intégrer un turbo à toutes ses voitures. Avant, il fallait l’installer soi-même ; désormais, il est inclus d’office.

De nouvelles options pour les administrateurs

PHP 8.5 ajoute également quelques petites nouveautés côté configuration, qui raviront les administrateurs et développeurs soucieux de la stabilité de leur environnement.

a. L’option php --ini=diff
Cette commande affiche uniquement les directives de configuration différentes des valeurs par défaut. C’est extrêmement pratique pour diagnostiquer une anomalie entre deux serveurs.

php --ini=diff

Par exemple, si votre serveur de production se comporte différemment de votre machine locale, cette commande vous dira en un clin d’œil quelles options divergent.

Les petits ajouts comme php --ini=diff ou max_memory_limit témoignent d’un souci du détail rare dans un langage aussi ancien.

b. Nouvelle directive max_memory_limit
Cette directive permet de fixer un plafond à memory_limit. En clair, même si un script tente d’augmenter la mémoire allouée, il ne pourra pas dépasser ce maximum défini dans le php.ini.

max_memory_limit = 512M

Cela renforce la sécurité et évite qu’un script défectueux consomme toute la mémoire disponible.

L’attribut #[\Deprecated] pour les traits

Jusqu’à présent, vous pouviez marquer des classes ou fonctions comme obsolètes. Désormais, c’est aussi possible pour les traits.

#[\Deprecated("Ce trait sera supprimé dans PHP 9.0")]
trait AncienSysteme {
    public function logOld() {
        echo "Ancienne méthode de log.";
    }
}

C’est une petite amélioration, mais qui permet de préparer proprement une migration sans casser la compatibilité du code existant.

Ces nouveautés avancées montrent à quel point PHP continue de progresser dans le bon sens : plus de sécurité, plus de performance et plus de clarté.

PHP 8.5 confirme que le langage n’est pas en déclin, mais bel et bien en pleine maturité. C’est une version qui peaufine tout ce que PHP a appris en vingt-cinq ans d’évolution. Et pour les développeurs web comme vous, c’est la promesse d’un environnement plus rapide, plus sûr, et toujours aussi accessible.

FILTER_THROW_ON_FAILURE : des erreurs plus explicites avec filter_var()

Depuis des années, filter_var() est utilisée pour valider ou assainir des données. Mais elle a toujours eu un petit défaut : en cas d’échec, elle retourne simplement false… sans qu’on sache vraiment pourquoi.

Avec PHP 8.5, un nouveau flag nommé FILTER_THROW_ON_FAILURE permet à cette fonction de lancer une exception si la validation échoue. Cela rend le code plus clair et plus sûr, surtout dans les applications critiques.

Exemple sans le flag (comportement classique) :

$email = filter_var('contact@crea-troyes', FILTER_VALIDATE_EMAIL);

if ($email === false) {
    echo "Adresse email invalide";
}

Exemple avec le nouveau flag FILTER_THROW_ON_FAILURE :

try {
    $email = filter_var('contact@crea-troyes', FILTER_VALIDATE_EMAIL, FILTER_FLAG_THROW_ON_FAILURE);
    echo "Adresse valide : $email";
} catch (ValueError $e) {
    echo "Erreur : " . $e->getMessage();
}

Grâce à ce flag, vous pouvez gérer les erreurs via un bloc try/catch, ce qui rend le comportement plus prévisible. C’est un pas en avant vers une programmation plus propre et orientée objet.

L’attribut #[\DelayedTargetValidation] : valider les attributs au bon moment

PHP 8.5 introduit un nouvel attribut interne nommé  #[\DelayedTargetValidation]. Son rôle ? Retarder la vérification de la validité d’un attribut (ou annotation) jusqu’à ce que toutes les dépendances soient connues.

Cela peut sembler très technique, mais c’est essentiel quand plusieurs classes ou interfaces s’imbriquent et se référencent mutuellement. Avant, PHP pouvait signaler une erreur de validation « trop tôt », alors que la cible était encore en cours de chargement.

Exemple simplifié :

#[\DelayedTargetValidation]
#[CustomAttribute(SomeClass::class)]
class MaClasse {}

Ici, si SomeClass n’était pas encore déclarée au moment de la validation, PHP attendra désormais le moment opportun avant de déclencher une erreur.

Ce mécanisme améliore la robustesse des systèmes complexes, notamment dans les frameworks modernes (comme Symfony ou Laravel) qui utilisent abondamment les attributs pour la configuration.

Support des cookies partitionnés (CHIPS) avec PHP 8.5

Les CHIPS (Cookies Having Independent Partitioned State) sont une nouveauté des navigateurs récents comme Chrome 125+. Ils permettent aux cookies d’avoir des états indépendants selon le site d’origine, afin d’améliorer la confidentialité des utilisateurs.

PHP 8.5 met à jour ses fonctions setcookie() et setrawcookie() pour prendre en charge ces cookies partitionnés. Cela aide les développeurs à se conformer aux exigences de sécurité modernes imposées par les navigateurs.

Exemple : création d’un cookie partitionné

setcookie(
    name: "session_id",
    value: "abc123",
    options: [
        "path" => "/",
        "secure" => true,
        "httponly" => true,
        "partitioned" => true // Nouvel argument !
    ]
);

Grâce à l’option "partitioned" => true, le cookie est isolé par contexte. Autrement dit, si le même utilisateur charge votre site depuis un autre domaine, ce cookie ne sera pas partagé — un vrai progrès pour la sécurité et la confidentialité.

Cette évolution est en phase avec les efforts mondiaux pour réduire le suivi inter-sites. En d’autres termes, PHP s’aligne sur le Web moderne, tout en restant fidèle à sa philosophie de simplicité.

L’attribut #[\Override] étendu aux propriétés

Introduit dans PHP 8.3 pour les méthodes, l’attribut #[\Override] permettait de marquer explicitement une méthode qui remplace une méthode héritée. Si la méthode parentale n’existe pas, PHP déclenchait une erreur, évitant ainsi les fautes de frappe ou les incohérences d’héritage.

Bonne nouvelle, avec PHP 8.5, cet attribut peut désormais être appliqué aux propriétés :

class ParentClass {
    public string $role = 'user';
}

class ChildClass extends ParentClass {
    #[\Override]
    public string $role = 'admin';
}

Si la propriété $role n’existe pas dans la classe parente, PHP lèvera une erreur. C’est un outil simple mais puissant pour sécuriser vos hiérarchies de classes et éviter les erreurs sournoises liées à une faute de frappe.

Pourquoi c’est utile : dans de gros projets orientés objet, il arrive souvent qu’un développeur croie surcharger une propriété, alors qu’en réalité il en crée une nouvelle par erreur. Ce petit attribut évite ce type de bug silencieux.

Locale::isRightToLeft() : détecter les langues RTL

Enfin, PHP 8.5 continue d’enrichir son extension Intl (internationalisation) avec une nouvelle méthode : Locale::isRightToLeft() et sa version fonctionnelle locale_is_right_to_left().

Cette nouveauté permet de déterminer rapidement si une langue s’écrit de droite à gauche (RTL), comme l’arabe, l’hébreu ou le persan.

use Locale;

$locale = 'ar_EG'; // arabe d'Égypte

if (Locale::isRightToLeft($locale)) {
    echo "Cette langue s'écrit de droite à gauche.";
} else {
    echo "Cette langue s'écrit de gauche à droite.";
}

Cela facilite grandement la gestion des interfaces multilingues. Plus besoin de maintenir des listes manuelles de langues RTL : PHP sait désormais le détecter automatiquement.

Cas concret : si vous développez un site multilingue, vous pouvez adapter dynamiquement votre CSS pour inverser la mise en page selon la direction d’écriture.

PHP 8.5 n’est donc pas une révolution spectaculaire, mais une mise à jour de fond, intelligente et précieuse. C’est le genre d’évolution qui, sur le long terme, fait gagner du temps, réduit les erreurs et renforce la confiance des développeurs — exactement ce qu’on attend d’un langage mûr et bien vivant.

cURL : partage persistant des ressources pour plus de performance

Si vous avez déjà développé un script qui envoie plusieurs requêtes HTTP successives avec cURL, vous savez combien il peut être coûteux de rouvrir une nouvelle connexion à chaque fois.

Jusqu’à présent, chaque appel cURL créait son propre « contexte » : cookies, connexions, DNS, etc. Avec PHP 8.5, la RFC « Persistent cURL Share Handles » introduit la possibilité de partager ces ressources entre plusieurs requêtes, même au-delà du cycle de vie d’un script.

Cela signifie que PHP peut réutiliser les connexions précédemment établies, accélérant ainsi vos appels API ou vos crawlers.

Exemple simple :

// Création d'un handle de partage
$share = curl_share_init();
curl_share_setopt($share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
curl_share_setopt($share, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);

// Requête 1
$ch1 = curl_init('https://api.crea-troyes.fr/user');
curl_setopt($ch1, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch1, CURLOPT_SHARE, $share);
$response1 = curl_exec($ch1);

// Requête 2 – même session, mêmes cookies !
$ch2 = curl_init('https://api.crea-troyes.fr/profile');
curl_setopt($ch2, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch2, CURLOPT_SHARE, $share);
$response2 = curl_exec($ch2);

curl_close($ch1);
curl_close($ch2);
curl_share_close($share);

Grâce à cette approche, les connexions persistent entre les appels : moins de DNS, moins de négociations SSL, et donc des temps de réponse plus rapides.

Cas d’usage concret : si vous avez un site qui interroge fréquemment une API (par exemple pour un tableau de bord de statistiques), cette amélioration se traduit par un gain de performance mesurable, sans changement majeur dans votre code.

Dans le monde du développement de PHP, une RFC est un document officiel de proposition de changement du langage.

Nouvelle syntaxe clone with : cloner un objet avec des modifications

Une autre petite révolution syntaxique arrive avec PHP 8.5 : la RFC « Clone with v2 », qui introduit le mot-clé clone with.

Jusqu’ici, pour cloner un objet en changeant quelques propriétés, il fallait :

1. cloner manuellement l’objet,
2. puis redéfinir les propriétés une par une.

Cela rendait le code long et redondant.

Avant PHP 8.5 :

$user1 = new User('Alban', 'admin', true);
$user2 = clone $user1;
$user2->role = 'user';
$user2->active = false;

Avec PHP 8.5 :

$user1 = new User('Alban', 'admin', true);
$user2 = clone $user1 with {
    role: 'user',
    active: false
};

Cette syntaxe est inspirée d’autres langages modernes (comme Rust ou Kotlin) et permet de créer des objets dérivés sans avoir à répéter inutilement les lignes de clonage.

Pourquoi c’est pratique :

• C’est plus lisible et expressif.
• Cela évite d’écrire du code « accidentel » qui oublie une propriété.
• Cela prépare PHP à mieux gérer les objets immuables.

Imaginez un site e-commerce où vous voulez dupliquer un produit tout en modifiant uniquement son prix et son identifiant SKU (identifiant unique pour reconnaitre un produit) :

$product = new Product('Clavier mécanique', 'SKU001', 89.99);

$newProduct = clone $product with {
    sku: 'SKU002',
    price: 79.99
};

En une ligne, vous obtenez un clone prêt à être enregistré dans la base, sans risquer de casser les références de l’objet original.

Extension Intl : une API plus complète pour formater des listes

PHP continue d’améliorer son extension Intl, dédiée à la gestion du multilinguisme. PHP 8.5 ajoute notamment une nouvelle API pour formater des listes selon les conventions linguistiques de chaque langue, via la classe IntlListFormatter.

Avant, pour afficher une liste comme « pommes, bananes et oranges », il fallait concaténer manuellement les éléments. Maintenant, PHP s’occupe du formatage et du séparateur correct en fonction de la langue.

Exemple :

$fr = new IntlListFormatter('fr_FR', IntlListFormatter::TYPE_CONJUNCTION);
$en = new IntlListFormatter('en_US', IntlListFormatter::TYPE_CONJUNCTION);

$fruits = ['pommes', 'bananes', 'oranges'];

echo $fr->format($fruits); // "pommes, bananes et oranges"
echo $en->format($fruits); // "apples, bananas, and oranges"

Autres modes disponibles :

• IntlListFormatter::TYPE_DISJUNCTION → pour des phrases du type « pommes, bananes ou oranges ».
• IntlListFormatter::TYPE_UNIT → pour formater des unités comme « 10 heures, 30 minutes ».

Pourquoi c’est utile :

• Cela simplifie la localisation des textes dans les sites multilingues.
• Le formatage respecte automatiquement les conventions grammaticales de chaque langue.
• On évite les erreurs de ponctuation ou d’espace insécable, souvent négligées.

Avant cette amélioration, les développeurs francophones devaient bricoler des fonctions pour gérer les « , » et le « et ». Désormais, PHP sait le faire parfaitement, même pour des langues plus complexes comme le japonais ou l’arabe.

Dépréciations importantes à surveiller

Mettre à jour sans prévoir les dépréciations, c’est un peu comme construire un pont sans vérifier la solidité des fondations. PHP 8.5 annonce plusieurs dépréciations qu’il vaut mieux connaître pour anticiper la maintenance.

À surveiller

• Les constantes MHASH_* sont désormais dépréciées. Il est recommandé de migrer vers l’extension hash().
• Les castings de types scalaires non-canoniques ((boolean), (integer), (double), etc.) posent désormais problème.
• La classe Directory ne peut plus être instanciée via new Directory() dans certains contextes ; il faut utiliser dir().

Avant de déployer en production, parcourez votre code et recherchez l’usage de fonctions/méthodes obsolètes. Une erreur en production peut prendre assez de temps à résoudre — souvenez-vous de cette fois où j’ai dû corriger un bug en pleine nuit…

Tableau récapitulatif des nouveautés de PHP 8.5

PHP 8.5, la maturité d’un langage en pleine forme

PHP 8.5 n’est pas simplement une mise à jour technique : c’est une étape de maturation profonde pour un langage qui a su évoluer sans jamais trahir sa philosophie d’origine. Longtemps perçu comme un outil vieillissant, PHP prouve ici qu’il reste moderne, performant et tourné vers l’avenir.

Cette version 8.5 combine améliorations visibles et optimisations internes. L’arrivée de l’opérateur pipe (|>), de la syntaxe clone with, ou encore de nouvelles fonctions comme array_first() et array_last() simplifie réellement la vie des développeurs. En parallèle, des ajustements discrets — comme la persistance des connexions cURL, l’intégration d’OPcache par défaut ou la gestion des cookies partitionnés (CHIPS) — renforcent les performances et la sécurité sans effort supplémentaire.

Au-delà de la technique, PHP 8.5 marque aussi une volonté claire : celle d’offrir un langage plus lisible, cohérent et rigoureux. Les attributs #[\NoDiscard], #[\Override] ou encore #[\Deprecated] traduisent une approche plus professionnelle du code, inspirée des langages modernes. Le développeur garde la liberté qui a fait le succès de PHP, mais gagne une structure plus robuste pour des projets ambitieux.

On pourrait dire que PHP 8.5, c’est un peu comme un artisan qui polit ses outils après vingt-cinq ans d’expérience : il ne change pas sa manière de travailler, mais tout devient plus fluide, plus précis et plus rapide.

Que vous soyez développeur confirmé ou débutant motivé, cette version est l’occasion idéale de remettre les mains dans le code, de tester les nouvelles syntaxes et de moderniser vos projets. PHP 8.5 ne cherche pas à tout révolutionner, mais à perfectionner ce qui fait sa force : un langage simple, accessible et toujours au cœur du Web.

En somme, PHP 8.5 n’est pas une promesse d’avenir : c’est la preuve que l’avenir du Web continue bel et bien de s’écrire… en PHP.

Alban

Fondateur de l’agence Créa-troyes.
Intervenant en Freelance.
Contactez-moi

crea-troyes.fr