La suppression la plus visible : les annotations Doctrine. @Route, @ORM\Column, @Assert — disparus. Les attributs PHP natifs sont l’approche recommandée depuis Symfony 5.2. 7.0 rend juste ça officiel.

Les attributs partout

La migration des annotations vers les attributs est principalement mécanique : la syntaxe passe de @ à #[], et les références de classes passent des classes d’annotation Doctrine aux classes d’attribut PHP :

// avant
/** @Route('/users', methods={"GET"}) */

// après
#[Route('/users', methods: ['GET'])]

Le vrai gain n’est pas juste la syntaxe : les attributs sont validés par le moteur PHP, pas un parseur de docblock. Les IDEs peuvent les résoudre sans plugins personnalisés. Les outils d’analyse statique les comprennent nativement. Fini les “ça échoue silencieusement à l’exécution à cause d’une faute de frappe dans un commentaire.”

Workflow avec attributs PHP

Les listeners et guards d’événements Workflow peuvent maintenant être enregistrés via des attributs :

#[AsGuard(workflow: 'order', transition: 'ship')]
public function canShip(Event $event): void
{
    if (!$event->getSubject()->isPaymentConfirmed()) {
        $event->setBlocked(true);
    }
}

Le profiler de workflow, un panneau dédié montrant le marquage courant et les transitions disponibles, est un outil de debug vraiment utile quand on travaille avec des machines à états complexes.

DatePoint dans le composant Clock

DatePoint, le DateTime immutable avec gestion stricte des erreurs introduit dans 6.4, est maintenant la façon recommandée de travailler avec les dates. Combiné avec les propriétés readonly de PHP 8.2, les objets-valeur de dates dans le code de domaine deviennent presque trivialement propres :

readonly class Order {
    public function __construct(
        public DatePoint $createdAt,
        public ?DatePoint $shippedAt = null,
    ) {}
}

Ce que 7.0 supprime

La liste complète des suppressions : le support des annotations Doctrine, le bridge du composant Templating, le bridge ProxyManager, le bridge Monolog pour les versions inférieures à 3.0, et le transport Sendinblue (remplacé par Brevo). Le support PHP 8.0 et 8.1 se termine aussi. 8.2 est le plancher maintenant.

Monter de 6.4 avec toutes les notices de dépréciation corrigées, et 7.0 est fluide. Sauter cette étape et on s’expose à une mauvaise surprise.

Scheduler et AssetMapper diplômés

Deux composants qui sont sortis en expérimental dans 6.3 sont maintenant stables : Scheduler et AssetMapper. Stable signifie des APIs verrouillées, plus de mises en garde @experimental, et ils apparaissent correctement dans le guide de mise à jour. On peut vraiment compter sur eux maintenant.

Scheduler reçoit #[AsCronTask] et #[AsPeriodicTask] pour l’enregistrement de tâches par attribut, la modification de planning à l’exécution avec recalcul du heap, FailureEvent, et une option --date sur schedule:debug. AssetMapper ajoute le support des fichiers CSS dans l’importmap, une commande outdated, une commande audit, et le préchargement automatique via WebLink.

#[AsCronTask('0 2 * * *')]
class NightlyReportMessage {}

#[AsPeriodicTask(frequency: '1 hour')]
class HourlyCleanupMessage {}

Le câblage de services reçoit deux nouveaux attributs

#[AutowireLocator] et #[AutowireIterator] ont atterri dans 6.4 et sont stables dans 7.0. Ils remplacent la configuration verbose XML/YAML des service locators taggués par quelque chose qu’on peut juste mettre directement en PHP :

class HandlerRegistry
{
    public function __construct(
        #[AutowireLocator('app.handler', indexAttribute: 'key')]
        private ContainerInterface $handlers,
    ) {}
}

#[Target] est aussi plus intelligent : quand un service a un alias d’autowiring nommé comme invoice.lock.factory, on peut maintenant écrire #[Target('invoice')] au lieu du nom complet de l’alias. Moins de bruit quand le type dit déjà ce qu’on veut.

Messenger reçoit une gestion plus précise des échecs

RejectRedeliveredMessageException dit au worker de ne pas retenter un message, ce qui est pratique quand un message arrive deux fois à cause d’un timeout d’ack du transport et qu’on a besoin d’une sémantique exactly-once. messenger:failed:remove --all vide tout le transport d’échec en un coup, pas de boucle nécessaire. Les retries échoués peuvent aussi aller directement au transport d’échec, en contournant entièrement la queue de retry.

Plusieurs hôtes Redis Sentinel sont maintenant supportés dans le DSN :

redis-sentinel://host1:26379,host2:26379,host3:26379/mymaster

Console reçoit les noms de signaux et le profilage de commandes

SignalMap mappe les entiers de signaux à leurs noms POSIX. Quand un worker attrape SIGTERM, le log dit maintenant SIGTERM au lieu de 15. Petite chose, vraie amélioration. ConsoleTerminateEvent est dispatché même quand le processus se termine via signal, ce qui n’était pas le cas avant 7.0.

Le profilage de commandes arrive aussi : passer --profile à bin/console et les données collectées vont directement dans le profiler Symfony, navigable depuis l’UI web.

Form : des petites choses qui s’accumulent

ChoiceType reçoit une option duplicate_preferred_choices. La définir à false et on arrête de montrer la même option deux fois quand les choix préférés chevauchent la liste complète. FormEvent::setData() est déprécié pour les événements où les données sont déjà verrouillées à ce point du cycle de vie. La barre oblique auto-fermante sur les éléments <input> est aussi supprimée : <input> est un élément void en HTML5 et la barre oblique était techniquement invalide.

Le support des enums dans les formulaires est bien fait : ChoiceType rend les backed enums directement, et les enums translatable reçoivent leurs labels via le translator sans câblage personnalisé.

HttpFoundation : small but useful

Response::send() reçoit un paramètre $flush. Passer false pour bufferiser la sortie sans la flusher au client, utile quand on enchaîne des middlewares qui doivent inspecter la réponse avant qu’elle quitte le processus.

UriSigner passe de HttpKernel à HttpFoundation, où il appartient sémantiquement. Même nom de classe, namespace différent.

Les cookies reçoivent le support CHIPS (Cookies Having Independent Partitioned State), le mécanisme navigateur pour les cookies cross-site dans une partition first-party. Ça ne compte que si on construit des widgets embarquables, mais bon à savoir que c’est là.

Translation : provider Phrase et sortie arborescente

Phrase rejoint Crowdin et Lokalise comme provider de traduction supporté. Le configurer dans config/packages/translation.yaml et les commandes translation:push / translation:pull gèrent la synchronisation.

translation:pull reçoit une option --as-tree qui écrit les fichiers de traduction en YAML imbriqué plutôt qu’en clés à notation pointée plate. Si c’est vraiment mieux dépend entièrement de l’équipe.

LocaleSwitcher::runWithLocale() passe maintenant la locale courante comme argument au callback, évitant un appel getLocale() à l’intérieur :

$switcher->runWithLocale('fr', function (string $locale) use ($mailer) {
    $mailer->send($this->buildEmail($locale));
});

Quelques choses dans Serializer et DomCrawler

L’attribut Context du Serializer peut maintenant cibler des classes spécifiques, donc un seul DTO peut se comporter différemment pendant la (dé)sérialisation selon quelle classe détient le contexte. TranslatableNormalizer arrive pour normaliser les objets qui implémentent TranslatableInterface : le translator est appelé pendant la normalisation, pas avant.

Crawler::attr() reçoit un paramètre $default. Au lieu de null-checker la valeur de retour, on passe une valeur de repli :

$src = $crawler->attr('src', '/placeholder.png');

assertAnySelectorText() et assertAnySelectorTextContains() rejoignent l’ensemble d’assertions DomCrawler. Ils passent si au moins un élément correspondant satisfait la condition, plutôt que d’en exiger que tous correspondent.

HttpClient : réponses HAR pour les tests

MockResponse accepte maintenant les fichiers HAR (HTTP Archive). Enregistrer de vraies interactions HTTP dans le navigateur ou avec un proxy, déposer le fichier .har dans les fixtures de tests, et les rejouer :

$client = new MockHttpClient(HarFileResponseFactory::createFromFile(__DIR__.'/fixtures/api.har'));

Bien mieux qu’écrire des stubs de réponse à la main quand on traite avec une API complexe.

JIT

Le compilateur Just-In-Time était l’annonce principale. La réalité en production est plus nuancée : pour les applications web typiques (requêtes en base, appels HTTP, rendu de templates) les gains sont modestes, parce que ces workloads sont limités par les I/O, pas par le calcul. Là où le JIT brille vraiment, c’est le code intensif en CPU : manipulation d’images, transformation de données, calcul mathématique.

Pour la plupart des applications web, l’amélioration de performance vient du travail sur le moteur en général dans 8.0, pas du JIT spécifiquement. Vaut quand même la peine de l’activer : ça ne coûte rien sur les workloads I/O-bound.

Les expressions match

switch a trois problèmes : il utilise la comparaison souple, il tombe en cascade par défaut, et il ne peut pas être utilisé comme expression. match règle les trois :

$result = match($status) {
    'active', 'pending' => 'processing',
    'done'             => 'finished',
    default            => throw new \UnexpectedValueException($status),
};

Comparaison stricte. Pas de cascade. Expression qui retourne une valeur. Un match non exhaustif lève une exception. Après une semaine avec match, j’ai arrêté d’écrire des switch.

Les arguments nommés

array_slice(array: $users, offset: 0, length: 10, preserve_keys: true);

Les arguments nommés permettent de passer les arguments dans n’importe quel ordre et d’en sauter des optionnels. Le gain évident : la lisibilité sur les fonctions avec plusieurs flags booléens. Le gain moins évident : les arguments nommés survivent aux mises à jour de PHP même quand l’ordre des paramètres change, parce qu’on nomme ce qu’on veut dire.

Les attributs

Place aux docblock annotations (le style @Route, @ORM\Column sur lequel les frameworks se sont appuyés pendant des années), bienvenue à la syntaxe PHP de première classe :

#[Route('/users', methods: ['GET'])]
#[IsGranted('ROLE_ADMIN')]
public function list(): Response { ... }

Les attributs sont validés par le moteur, pas parsés depuis des strings. Le support IDE fonctionne directement, sans magie de plugin. Pour les utilisateurs de Symfony et Doctrine, c’est le vrai gain quotidien de PHP 8.0.

La promotion de constructeur

class User {
    public function __construct(
        public readonly int $id,
        public string $name,
        private ?string $email = null,
    ) {}
}

Propriétés déclarées et assignées en une ligne dans la signature du constructeur. Le gain de refactoring le plus immédiat dans 8.0 : chaque classe de données que j’ai touchée depuis la mise à jour fait moitié moins de lignes qu’avant.

L’opérateur nullsafe

$city = $user?->getAddress()?->getCity()?->getName();

null à n’importe quel point de la chaîne court-circuite le reste et retourne null. L’alternative était des null checks imbriqués ou une chaîne de retours anticipés. Ça se compose naturellement.

Les types union

Les arguments nommés rendent les signatures de fonctions plus explicites au site d’appel. Les types union les rendent plus honnêtes au site de déclaration :

function processInput(int|float|string $value): string|int
{
    if (is_string($value)) {
        return strlen($value);
    }
    return (int) round($value);
}

L’union int|float|string est un OU littéral. Le moteur l’impose à l’entrée et à la sortie. Avant 8.0, “ce paramètre accepte int ou float” vivait dans un docblock que rien n’imposait. Il y a aussi null comme composant de type : ?string est juste du sucre syntaxique pour string|null, les deux sont valides.

Un cas spécial : false. PHP a un tas de fonctions natives qui retournent une valeur typée en cas de succès et false en cas d’échec. Le système de types de 8.0 accommode ça : array|false, string|false. C’est une reconnaissance honnête que la codebase ne peut pas être réécrite du jour au lendemain.

Le type de retour static

static comme type de retour était possible de manière informelle via les docblocks, mais 8.0 le rend officiel. La distinction entre self et static compte dans l’héritage :

class Builder {
    protected array $config = [];

    public function set(string $key, mixed $value): static {
        $this->config[$key] = $value;
        return $this;
    }
}

class SpecialBuilder extends Builder {}

$result = (new SpecialBuilder())->set('foo', 'bar');
// $result est SpecialBuilder, pas Builder

Avec self comme type de retour, cette chaîne retournerait Builder, cassant les interfaces fluides dans les sous-classes. static fait fonctionner correctement les APIs fluides à travers les hiérarchies d’héritage sans surcharges manuelles.

Le type mixed

mixed était une convention de docblock pendant des années. 8.0 en fait un vrai type qui apparaît dans les signatures :

function debug(mixed $value): void {
    var_dump($value);
}

Il accepte tout : null, objets, ressources, scalaires, tableaux. Sémantiquement c’est la même chose que n’avoir aucune déclaration de type, mais c’est explicite plutôt qu’absent. La différence entre “ce paramètre est non typé” et “ce paramètre accepte intentionnellement n’importe quoi.” Vaut la peine de l’utiliser quand on écrit un utilitaire généraliste qui serait malhonnête avec un type plus étroit.

throw comme expression

Avant 8.0, throw était une instruction. Ça semble une distinction pédante jusqu’à ce qu’on tombe sur les endroits où on veut vraiment une expression :

// Dans un ternaire :
$value = $input ?? throw new \InvalidArgumentException('input required');

// Dans une arrow function :
$getId = fn(User $u) => $u->id ?? throw new \RuntimeException('no id');

// Dans un bras match (qui est déjà une expression) :
$status = match($code) {
    200     => 'ok',
    404     => 'not found',
    default => throw new \UnexpectedValueException("unknown code: $code"),
};

Le dernier est particulièrement utile : un match sans default lancera UnhandledMatchError automatiquement, mais parfois on veut contrôler le type d’exception et le message.

catch sans variable

Petite amélioration de qualité de vie. Quand on attrape une exception mais qu’on n’utilise pas réellement l’objet, 8.0 permet d’omettre la variable :

try {
    $result = $cache->get($key);
} catch (CacheMissException) {
    $result = $this->compute($key);
}

Avant 8.0, il fallait écrire catch (CacheMissException $e) et ensuite soit utiliser $e soit vivre avec l’avertissement IDE sur la variable inutilisée. Aucune des deux options n’était satisfaisante.

Les fonctions string qui auraient dû exister depuis des années

Trois fonctions que chaque développeur PHP a écrites manuellement au moins une fois :

str_contains('hello world', 'world');  // true
str_starts_with('hello world', 'hell'); // true
str_ends_with('hello world', 'world'); // true

Avant 8.0, les approches habituelles étaient strpos() !== false, strncmp(), ou substr() ===, qui nécessitent toutes de s’arrêter pour se souvenir de la sémantique. Ces nouvelles fonctions sont juste directes et lisibles. Pas de regex, pas d’arithmétique d’offset.

Un tri stable

Les fonctions de tri de PHP n’étaient pas stables avant 8.0. “Pas stable” signifie que les éléments qui se comparent comme égaux pouvaient se retrouver dans n’importe quel ordre les uns par rapport aux autres. En pratique, ça causait des bugs subtils dans le code UI qui avait besoin d’un ordre cohérent, une pagination qui changeait entre les chargements, et des tests qui ne passaient que par chance.

8.0 garantit la stabilité à travers toutes les fonctions de tri : sort(), usort(), array_multisort(), et le reste. Les éléments égaux conservent leur position relative originale. C’est le comportement que la plupart des gens supposaient déjà être là.

WeakMap

7.4 apportait WeakReference pour les objets simples. 8.0 apporte WeakMap : une map où les clés (des objets) et leurs données associées peuvent être ramassées par le GC quand aucune autre référence à l’objet-clé n’existe :

class RequestCache {
    private WeakMap $cache;

    public function __construct() {
        $this->cache = new WeakMap();
    }

    public function get(Request $request): Response {
        return $this->cache[$request] ??= $this->compute($request);
    }
}

Dès que $request n’est plus référencé ailleurs, l’entrée disparaît de la map. Pas de nettoyage manuel nécessaire. C’est le bon pattern pour la mémoïsation et les caches de propriétés calculées où on ne veut pas être la seule raison qu’un objet reste vivant.

Les nouveaux types d’exception

ValueError est levée quand une fonction reçoit le bon type mais une valeur invalide, par opposition à TypeError qui se déclenche sur les mauvais types :

array_chunk([], -5); // ValueError: array_chunk(): Argument #2 ($length) must be greater than 0

Avant 8.0, beaucoup de ces cas étaient des warnings qui retournaient false ou null. Maintenant ils lèvent des exceptions. Le moteur est plus strict, ce qui signifie qu’on attrape les problèmes plus tôt plutôt que d’obtenir des résultats bizarres quelque part en aval.

get_debug_type() et fdiv()

Deux fonctions utilitaires à connaître.

get_debug_type() retourne une représentation string normalisée de n’importe quelle valeur, pratique pour les messages d’erreur :

get_debug_type(1);          // "int"
get_debug_type(1.0);        // "float"
get_debug_type(null);       // "null"
get_debug_type(new Foo());  // "Foo" (pas "object")
get_debug_type([]);         // "array"

La différence avec gettype() : elle retourne les noms de classes pour les objets et utilise des noms normalisés ("int" pas "integer"). Exactement ce qu’on veut pour construire un message d’exception qui dit ce qu’on a reçu versus ce qu’on attendait.

fdiv() effectue une division en virgule flottante suivant IEEE 754, ce qui signifie que la division par zéro retourne INF, -INF, ou NAN au lieu d’un warning :

fdiv(10, 0);   // INF
fdiv(-10, 0);  // -INF
fdiv(0, 0);    // NAN

Les changements qui cassent des choses

8.0 inclut aussi quelques changements qui ne sont pas des fonctionnalités, ce sont des corrections.

Le plus important : 0 == "foo" est maintenant false. En PHP 7, comparer un entier à une string non numérique castait la string en 0, donc 0 == "n'importe-quoi-non-numérique" s’évaluait à true. C’était une source persistante de bugs et de maux de tête de sécurité. PHP 8 l’inverse : l’entier est casté en string à la place :

var_dump(0 == "foo");  // bool(false) en 8.0, bool(true) en 7.x
var_dump(0 == "");     // bool(false) en 8.0, bool(true) en 7.x
var_dump(0 == "0");    // bool(true) dans les deux ("0" est numérique)

Si on s’appuyait sur ça intentionnellement, on savait déjà que c’était douteux. Si on ne savait pas qu’on s’en appuyait, 8.0 va trouver ces chemins de code.

Plusieurs fonctions qui retournaient des ressources retournent maintenant des objets propres : curl_init() retourne un CurlHandle, imagecreate() retourne un GdImage, xml_parser_create() retourne un XMLParser. Le code qui vérifie is_resource($curl) va casser, parce que is_resource() retourne false pour ces objets. La correction consiste à vérifier contre false (la valeur de retour en cas d’échec) plutôt que de vérifier le type du cas de succès.

PHP 8.0 est le genre de version où les fonctionnalités se renforcent mutuellement. Les attributs se marient bien avec la promotion de constructeur. Match s’associe naturellement avec les types union. Les fonctions string réduisent le bruit qui cachait l’intention. Les corrections sont parfois cassantes, mais elles poussent le langage vers une cohérence qu’il aurait dû avoir depuis des années.