La signature de messages dans Messenger

La sécurité des transports dans Messenger a toujours été le problème de l’application à résoudre. 7.4 ajoute la signature de messages : un mécanisme basé sur des stamps qui signe les messages dispatchés et valide les signatures à la réception.

Le cas d’usage cible est les scénarios multi-tenant ou de transport externe où on a besoin d’une preuve cryptographique qu’un message n’a pas été altéré ni injecté depuis l’extérieur. La configuration vit au niveau du transport :

framework:
    messenger:
        transports:
            async:
                dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
                options:
                    signing_key: '%env(MESSENGER_SIGNING_KEY)%'

Configuration en tableaux PHP

Les formats de configuration de Symfony ont toujours été YAML (défaut), XML et PHP. Le format PHP existait mais était maladroit : un DSL builder fluent qui nécessitait du chaînage de méthodes et ne donnait rien d’utile à l’IDE.

7.4 remplace le format fluent par des tableaux PHP standard. Les IDEs peuvent maintenant vraiment l’analyser, config/reference.php est auto-généré comme référence avec annotations de types, et le résultat ressemble à des données plutôt qu’à du code :

return static function (FrameworkConfig $framework): void {
    $framework->router()->strictRequirements(null);
    $framework->session()->enabled(true);
};

Le format fluent est déprécié. Les tableaux sont l’avenir, et honnêtement c’est un meilleur format.

Améliorations OIDC

#[IsSignatureValid] valide les URLs signées directement dans les contrôleurs, supprimant le boilerplate de la validation manuelle. OpenID Connect supporte maintenant plusieurs endpoints de découverte, et une nouvelle commande security:oidc-token:generate rend le dev et les tests beaucoup moins pénibles.

La fenêtre de support

7.4 LTS : bugs jusqu’en novembre 2028, correctifs de sécurité jusqu’en novembre 2029. Le chemin vers 8.4 LTS (la prochaine cible long terme) passe par les notices de dépréciation de 7.4 et la mise à jour PHP 8.4. Corriger les dépréciations maintenant et le saut vers 8.x sera beaucoup moins douloureux.

Les attributs deviennent plus précis

#[CurrentUser] accepte maintenant les types union, ce qui compte en pratique quand une route est accessible par plus d’une classe utilisateur :

public function index(#[CurrentUser] AdminUser|Customer $user): Response

#[Route] accepte un tableau pour l’option env, donc une route de debug active seulement en dev et test n’a plus besoin de deux définitions séparées. #[AsDecorator] est maintenant répétable, ce qui signifie qu’une classe peut décorer plusieurs services à la fois. Les signatures de méthode #[AsEventListener] acceptent les types d’événements union. #[IsGranted] reçoit une option methods pour limiter une vérification d’autorisation à des verbes HTTP spécifiques sans dupliquer la route.

La classe Request arrête d’en faire trop

Request::get() est dépréciée, et franchement bonne débarrassance. La méthode cherchait dans les attributs de route, puis les paramètres de query, puis le corps de la requête, dans cet ordre, retournant silencieusement ce qu’elle trouvait en premier. Cette ambiguïté causait de vrais bugs. Elle est supprimée dans 8.0 ; dans 7.4 elle fonctionne encore mais déclenche une dépréciation. Les remplacements sont explicites : $request->attributes->get(), $request->query->get(), $request->request->get().

Le parsing du corps pour les requêtes PUT, PATCH, DELETE et QUERY arrive en même temps. Auparavant Symfony ne parsait application/x-www-form-urlencoded et multipart/form-data que pour POST. Ces mêmes types de contenu sont maintenant parsés pour les autres méthodes accessibles en écriture aussi, ce qui tue un contournement REST API courant.

La surcharge de méthode HTTP pour GET, HEAD, CONNECT et TRACE est dépréciée. Surcharger une méthode sûre avec un header était de toute façon toujours sémantiquement cassé. On peut maintenant autoriser explicitement seulement les méthodes qui ont du sens pour son application :

Request::setAllowedHttpMethodOverride(['PUT', 'PATCH', 'DELETE']);

Les Workflows acceptent les BackedEnums

Les places et transitions de Workflow peuvent maintenant être définies avec des backed enums PHP, à la fois en YAML (via le tag !php/enum) et en config PHP. Le marking store fonctionne avec les valeurs d’enum directement, donc le modèle de domaine et la définition du workflow utilisent enfin les mêmes types :

framework:
    workflows:
        blog_publishing:
            initial_marking: !php/enum App\Status\PostStatus::Draft
            places: !php/enum App\Status\PostStatus
            transitions:
                publish:
                    from: !php/enum App\Status\PostStatus::Review
                    to: !php/enum App\Status\PostStatus::Published

Étendre la validation et la sérialisation pour les classes tierces

Besoin d’ajouter des métadonnées de validation ou de sérialisation à une classe d’un bundle qu’on ne possède pas ? 7.4 a #[ExtendsValidationFor] et #[ExtendsSerializationFor] pour ça. On écrit une classe compagnon avec ses annotations supplémentaires, on pointe l’attribut vers la classe cible, et Symfony fusionne les métadonnées à la compilation du conteneur :

#[ExtendsValidationFor(UserRegistration::class)]
abstract class UserRegistrationValidation
{
    #[Assert\NotBlank(groups: ['my_app'])]
    #[Assert\Length(min: 3, groups: ['my_app'])]
    public string $name = '';

    #[Assert\Email(groups: ['my_app'])]
    public string $email = '';
}

Symfony vérifie à la compilation que les propriétés déclarées existent réellement sur la classe cible. Un renommage ne cassera pas silencieusement la validation.

DX : ce qui ne fait pas la une mais compte

Le helper Question dans Console accepte un timeout. Demander à l’utilisateur de confirmer quelque chose, et s’il ne répond pas en N secondes, la réponse par défaut s’applique. Très pratique dans les scripts de déploiement qui ne peuvent pas se permettre d’attendre éternellement un humain.

messenger:consume reçoit --exclude-receivers. Combiné avec --all, il permet de consommer depuis tous les transports sauf des spécifiques :

bin/console messenger:consume --all --exclude-receivers=low_priority

Le mode worker FrankenPHP est maintenant auto-détecté. Si le processus tourne dans FrankenPHP, Symfony bascule en mode worker automatiquement. Pas de package supplémentaire nécessaire.

La commande debug:router cache les colonnes Scheme et Host quand toutes les routes utilisent ANY, ce qui supprime beaucoup de bruit de la sortie par défaut. Les méthodes HTTP sont maintenant aussi colorées.

Les tests fonctionnels reçoivent $client->getSession() avant la première requête. Auparavant il fallait faire au moins une requête pour accéder à la session, ce qui était agaçant. Maintenant on peut pré-remplir les tokens CSRF ou les flags A/B en amont :

$session = $client->getSession();
$session->set('_csrf/checkout', 'test-token');
$session->save();

Lock : store DynamoDB

DynamoDbStore arrive comme nouveau backend de Lock. Utile dans les déploiements AWS-natifs où Redis n’est pas dans la stack, et ça fonctionne exactement comme n’importe quel autre store :

$store = new DynamoDbStore('dynamodb://default/locks');
$factory = new LockFactory($store);

Bridge Doctrine : types day point et time point

Deux nouveaux types de colonnes Doctrine : day_point stocke une valeur date uniquement (sans composant heure) et time_point stocke une valeur heure uniquement, tous deux mappant vers DatePoint. Bien quand le domaine sépare genuinement la date de l’heure :

#[ORM\Column(type: 'day_point')]
public DatePoint $birthDate;

#[ORM\Column(type: 'time_point')]
public DatePoint $openingTime;

Routing : paramètres de query explicites

La clé _query dans la génération d’URL permet de définir les paramètres de query explicitement, séparément des paramètres de route. Ça compte quand un paramètre de route et un paramètre de query partagent le même nom :

$url = $urlGenerator->generate('report', [
    'site' => 'fr',
    '_query' => ['site' => 'us'],
]);
// /report/fr?site=us

WebLink : parsing des en-têtes Link entrants

HttpHeaderParser parse les en-têtes de réponse Link en objets structurés. Avant ça, parser des en-têtes Link depuis des réponses d’API nécessitait soit d’importer une bibliothèque tierce, soit d’écrire des regex. Le cas d’usage : les APIs HTTP qui annoncent des ressources liées ou la pagination via des en-têtes Link, comme le fait l’API GitHub.

Le parsing HTML5 est plus rapide sur PHP 8.4

DomCrawler et HtmlSanitizer basculent vers le parser HTML5 natif de PHP 8.4 quand il est disponible. Pas de changements de code nécessaires de votre côté. Le parser natif est plus rapide et plus conforme à la spec que le fallback précédent. Sur PHP 8.2 ou 8.3, rien ne change.

Translation : StaticMessage

StaticMessage implémente TranslatableInterface mais ne traduit intentionnellement pas. Elle passe la string inchangée quelle que soit la locale. Le cas d’usage : les réponses d’API qui doivent rester dans une langue fixe quelle que soit la locale de l’utilisateur, ou les entrées de log d’audit où on doit préserver le texte original tel quel.

Ce n’est pas juste un bump de version. C’est un engagement à construire contre le langage actuel plutôt que le plancher historique.

Le système de sécurité, enfin reconstruit

Le composant de sécurité Symfony a deux systèmes. L’ancien (AnonymousToken, GuardAuthenticatorInterface, un enchevêtrement d’interfaces qui vous faisaient implémenter des méthodes dont vous n’aviez pas besoin) avait été déprécié. 6.0 le supprime entièrement.

Le nouveau système de sécurité (security.enable_authenticator_manager: true en 5.x) est maintenant le seul système. C’est plus propre : une seule interface à implémenter, séparation claire entre authentification et autorisation, vérification des credentials basée sur des passeports. La migration depuis les anciens guard authenticators n’est pas indolore, mais la destination est beaucoup moins confuse.

La classe Path du Filesystem

Travailler avec des chemins de fichiers en PHP est fondamentalement un problème de manipulation de strings. __DIR__, concaténation, realpath(), séparateurs spécifiques à la plateforme : la bibliothèque standard donne des primitives mais pas vraiment un modèle.

La nouvelle classe Path gère ça :

use Symfony\Component\Filesystem\Path;

Path::join('/var/www', 'html', '../uploads'); // /var/www/uploads
Path::makeRelative('/var/www/html', '/var/www'); // html
Path::isAbsolute('./relative/path'); // false

Multiplateforme, sans effets de bord, sans accès au filesystem nécessaire. Aussi dans 6.0 : support des patterns .gitignore imbriqués dans Finder.

Les enums dans le système de formulaires

En s’appuyant sur les fondations posées par 5.4, 6.0 pousse le support des enums plus loin. Les valeurs BackedEnum font des allers-retours à travers les formulaires et le sérialiseur sans transformateurs personnalisés. Le composant de formulaire comprend les cases d’enum comme options de choix nativement.

Ce que 6.0 supprime

La liste des suppressions est extensive : l’ancien système de sécurité, le composant Templating, le support des annotations PHP (remplacées par les attributs natifs), le support du cache Doctrine, ContainerAwareTrait. Six années de marqueurs @deprecated accumulés, finalement nettoyés.

Les applications qui avaient pris au sérieux les warnings de dépréciation de 5.4 avaient un chemin de migration propre. Celles qui ne l’avaient pas fait avaient du travail à faire.

La complétion automatique était toujours le manque

Le composant Console a reçu l’autocomplétion shell, et c’est proprement intégré : définir une méthode complete() sur sa commande, et Tab dans Bash suggère des valeurs valides pour les options et arguments.

class DeployCommand extends Command
{
    public function complete(CompletionInput $input, CompletionSuggestions $suggestions): void
    {
        if ($input->mustSuggestOptionValuesFor('env')) {
            $suggestions->suggestValues(['prod', 'staging', 'dev']);
        }
    }
}

Toutes les commandes Symfony intégrées ont reçu la complétion aussi : debug:router, cache:pool:clear, lint:yaml, et une quinzaine d’autres. Exécuter bin/console completion bash >> ~/.bashrc et c’est terminé.

Messenger, maintenant avec attributs et traitement par lots

L’attribut #[AsMessageHandler] remplace l’ancienne MessageHandlerInterface. Moins de boilerplate, et on peut maintenant configurer l’affinité de transport et la priorité directement sur l’attribut :

#[AsMessageHandler(fromTransport: 'async', priority: 10)]
class SendWelcomeEmailHandler
{
    public function __invoke(UserRegistered $message): void { ... }
}

L’autre ajout significatif : BatchHandlerInterface. Quand on insère un millier de lignes, traiter les messages un par un est du gaspillage. Les batch handlers collectent les messages et les traitent en groupes. La taille de lot par défaut est 10, contrôlée par BatchHandlerTrait::shouldFlush(). L’Acknowledger gère le succès et l’échec individuels dans le lot.

reset_on_message: true dans la config Messenger réinitialise les services du conteneur entre les messages. Auparavant, un buffer Monolog pouvait se remplir à travers la gestion des messages et personne ne s’en rendait compte avant la production. Ça évite cette catégorie de bugs de stateful sans nécessiter de nettoyage manuel.

Le conteneur DI devient plus expressif

Trois changements qui comptent en pratique.

Les types union et intersection s’autowire maintenant. PHP 8.1 a ajouté les types intersection, et Symfony 6.0 les câble :

public function __construct(
    private NormalizerInterface&DenormalizerInterface $serializer
) {}

Ça fonctionne tant que les deux interfaces pointent vers le même service via les alias d’autowiring.

TaggedIterator et TaggedLocator ont reçu les options defaultPriorityMethod et defaultIndexMethod. On n’a plus besoin de YAML pour exprimer l’ordonnancement ou l’indexation pour les services taggués :

public function __construct(
    #[TaggedIterator(tag: 'app.handler', defaultPriorityMethod: 'getPriority')]
    private iterable $handlers,
) {}

SubscribedService (l’attribut qui remplace la magie implicite de ServiceSubscriberTrait) rend l’accès paresseux aux services explicite et typable :

#[SubscribedService]
private function mailer(): MailerInterface
{
    return $this->container->get(__METHOD__);
}

La validation reçoit trois nouveaux outils

CssColor valide les valeurs de couleurs CSS dans les formats voulus : hex, RGB, HSL, couleurs nommées, ou n’importe quel mélange. Utile pour les champs de configuration de thème où on veut accepter #ff0000 mais pas red, ou vice versa.

#[Assert\CssColor(formats: Assert\CssColor::HEX_LONG)]
private string $brandColor;

Cidr valide la notation CIDR pour IPv4 et IPv6, avec des options pour fixer la version et contraindre la plage de masque réseau. Les outils d’infrastructure et les formulaires de config réseau ont enfin une contrainte de première classe.

Le troisième ajout n’est pas une nouvelle contrainte. Ce sont les attributs imbriqués PHP 8.1 qui rendent les contraintes composées existantes utilisables sans XML. AtLeastOneOf, Collection, All, Sequentially : tout ça nécessitait auparavant des contournements d’annotation. Maintenant ça fonctionne juste comme attributs :

#[Assert\Collection(
    fields: [
        'email' => new Assert\Email(),
        'role'  => [new Assert\NotBlank(), new Assert\Choice(['admin', 'user'])],
    ]
)]
private array $payload;

Le sérialiseur, nettoyé

Deux choses. D’abord, le contexte de sérialisation est maintenant configurable globalement au lieu d’être répété à chaque appel serialize() :

# config/packages/serializer.yaml
serializer:
    default_context:
        enable_max_depth: true

Ensuite, l’option COLLECT_DENORMALIZATION_ERRORS change comment le sérialiseur gère les erreurs de type à la désérialisation. Au lieu de lever une exception au premier problème, il les collecte tous et les expose via PartialDenormalizationException. Si on écrit une API qui désérialise des corps de requête, c’est la différence entre retourner “le premier champ qui échoue” et “tous les champs qui échouent” dans une seule réponse.

Les utilitaires de string que personne ne savait vouloir

trimPrefix() et trimSuffix() sur les classes UnicodeString / ByteString. Pas glamour, mais supprimer un préfixe connu avec ltrim() est un piège subtil : ça supprime des caractères, pas des strings. Ceux-ci sont corrects :

use function Symfony\Component\String\u;

u('file-image-001.png')->trimPrefix('file-');   // 'image-001.png'
u('report.html.twig')->trimSuffix('.twig');     // 'report.html'

Aussi dans cette version : NilUlid pour les ULIDs à valeur zéro, perMonth() et perYear() sur RateLimiter pour quand les limites horaires n’ont pas de sens, et appendToFile() dans le composant Filesystem a reçu un paramètre LOCK_EX optionnel pour les écrivains concurrents.

Déboguer l’environnement

debug:dotenv est une nouvelle commande console qui montre quels fichiers .env ont été chargés et d’où vient chaque valeur. Quand on a .env, .env.local, .env.test, et .env.test.local qui se battent et que quelque chose ne va pas, cette commande dit exactement quel fichier a gagné. Elle n’apparaît que quand le composant Dotenv est utilisé, ce qui est le cas pour toute application Symfony standard.

C’est une bonne chose, même si ça ne le semble pas quand c’est vous qui devez faire la migration.

Le problème mcrypt

mcrypt n’est plus maintenu depuis 2007. Plus d’une décennie de stagnation dans une bibliothèque cryptographique. Dépréciée en 7.1, elle est retirée définitivement en 7.2. Son remplaçant : sodium, désormais intégré comme extension core.

Sodium est le binding PHP pour libsodium, une bibliothèque cryptographique moderne conçue autour de valeurs par défaut sûres. Là où mcrypt vous demandait de choisir le bon algorithme, le bon mode et le bon padding (et vous laissait vous planter silencieusement), l’API de sodium rend les choix dangereux structurellement difficiles. sodium_crypto_secretbox() pour le chiffrement symétrique, sodium_crypto_box() pour l’asymétrique, sodium_crypto_sign() pour les signatures. Les noms disent ce qu’on fait.

Si vous avez du code mcrypt en production, la migration est inévitable. Et ça vaut le coup de le faire soigneusement : du code cryptographique qui “fonctionne encore” peut être silencieusement cassé d’une façon que vous ne remarquerez qu’il sera trop tard.

Le type hint object

7.2 ajoute object comme type de paramètre et de retour :

function serialize(object $data): string {
    // accepte n'importe quel objet
}

C’est large — n’importe quel objet le satisfait — mais c’est mieux qu’aucun type du tout quand vous ne vous souciez vraiment pas de la classe spécifique. Complète les types existants array, callable et les hints par classe concrète.

Argon2 dans password_hash

$hash = password_hash($password, PASSWORD_ARGON2I);

PASSWORD_BCRYPT était la valeur par défaut et reste raisonnable, mais Argon2 a remporté le Password Hashing Competition pour une bonne raison : il est memory-hard, ce qui rend le craquage par GPU significativement plus coûteux. Vaut la peine de basculer pour les nouvelles apps.

7.2 est davantage une version sécurité qu’une version langage. Supprimez mcrypt, ajoutez sodium, et vous placez la plateforme dans un état où on peut lui faire confiance avec des données sensibles. Les fonctionnalités du langage sont incrémentales. Le changement d’infrastructure, lui, ne l’est pas.

Des types de paramètres qu’on peut désormais omettre intentionnellement

7.2 formalise quelque chose qui était jusqu’ici juste une odeur de code : quand vous implémentez une interface ou surchargez une méthode, vous pouvez maintenant omettre complètement le type du paramètre. C’est de la contravariance valide au sens du principe de substitution de Liskov.

interface Serializable {
    public function serialize(array $data): string;
}

class JsonSerializer implements Serializable {
    public function serialize($data): string { // pas de type — accepte plus, toujours valide
        return json_encode($data);
    }
}

Ça paraît bizarre au premier abord. Mais c’est logiquement correct : une méthode qui accepte tout est strictement plus permissive qu’une qui n’accepte que des tableaux. Le système de types est d’accord, même si votre relecteur de code lève un sourcil.

Des méthodes abstraites qui évoluent

Quand une classe abstraite étend une autre classe abstraite, elle peut désormais surcharger la méthode abstraite avec une signature différente. La contrainte est directionnelle : les paramètres peuvent être élargis (contravariants), les types de retour peuvent être resserrés (covariants).

abstract class BaseProcessor {
    abstract function process(string $input);
}

abstract class TypedProcessor extends BaseProcessor {
    abstract function process($input): int; // paramètre élargi, type de retour ajouté
}

C’était refusé avant 7.2. Ça débloque des abstractions intermédiaires sans forcer chaque classe feuille à répéter la même signature.

Virgule finale dans les imports groupés

Petit, mais je remarque son absence quand elle manque. Les imports de namespaces groupés peuvent désormais avoir une virgule finale après le dernier élément :

use App\Services\{
    UserService,
    OrderService,
    NotificationService, // virgule ici — enfin
};

Ça signifie qu’on peut réordonner ou ajouter des lignes sans toucher à la ligne précédente. Les diffs git deviennent plus propres, les conflits de merge plus rares.

count() a développé une conscience

Avant 7.2, count(null) retournait 0. Silencieusement. Sans warning. C’est exactement le genre de chose qui enterre un bug pendant des mois. Maintenant, ça émet un E_WARNING quand vous passez quelque chose qui n’est ni un tableau ni un objet Countable.

count(null);  // Warning: count(): Parameter must be an array or an object that implements Countable
count(42);    // pareil
count("hi");  // pareil

Le comportement n’a pas changé pour les entrées valides. Seul le silence a été brisé. C’est la bonne direction.

spl_object_id() — ce que vous émuliez avec SplObjectStorage

Si vous avez déjà construit une map indexée par identité d’objet, vous avez écrit quelque chose comme ça :

$storage = new SplObjectStorage();
$storage[$obj] = true;

7.2 ajoute spl_object_id(), qui retourne un entier unique pour la durée de vie d’un objet. C’est le même handle interne qu’utilise SplObjectStorage, rendu directement accessible :

$id = spl_object_id($obj); // ex. 42
$map[$id] = 'something';

L’entier est réutilisé après la destruction de l’objet, donc ne le conservez pas au-delà de la durée de vie de l’objet. Dans un contexte bien délimité cependant, c’est une clé d’identité peu coûteuse.

PDO : les chaînes de caractères nationales

Quand on travaille avec des bases de données qui distinguent les types de chaînes régulières et nationales (Oracle, SQL Server), 7.2 ajoute les flags nécessaires :

$stmt = $pdo->prepare("SELECT * FROM users WHERE name = ?");
$stmt->bindValue(1, 'Ångström', PDO::PARAM_STR | PDO::PARAM_STR_NATL);

Ou définir une valeur par défaut au niveau de la connexion :

$pdo->setAttribute(PDO::ATTR_DEFAULT_STR_PARAM, PDO::PARAM_STR_NATL);

PDO::PARAM_STR_NATL indique que la chaîne est un type caractère national (NCHAR/NVARCHAR). Obscur, certes. Indispensable si vous avez déjà vu vos données Unicode ressortir déformées parce que le driver ne faisait pas la différence.

GD supporte les BMP et les rectangles de clipping

Deux choses à connaître. D’abord, les fichiers BMP sont désormais des citoyens de première classe dans l’extension GD :

$image = imagecreatefrombmp('photo.bmp');
imagebmp($image, 'output.bmp');

Ensuite, on peut maintenant définir un rectangle de clipping pour que les opérations de dessin n’affectent qu’une portion de l’image :

imagesetclip($image, 10, 10, 200, 150); // x1, y1, x2, y2
// tout ce qui est dessiné en dehors de ce rectangle est silencieusement ignoré

Aucune de ces fonctionnalités ne transforme la façon dont la plupart des apps fonctionnent, mais les deux remplacent “installer une bibliothèque supplémentaire” par “c’est juste dans le core maintenant.”

mb_chr() et mb_ord() — le chr() et ord() d’Unicode

PHP a chr() et ord() depuis toujours. Ils travaillent sur des octets. Pour les points de code Unicode, vous étiez livré à vous-même. 7.2 ajoute les équivalents multibyte :

$char = mb_chr(0x1F600); // retourne l'emoji 😀
$code = mb_ord('é');     // retourne 233

Et mb_scrub(), qui supprime les séquences d’octets invalides d’une chaîne plutôt que d’échouer silencieusement ou de lancer une exception :

$clean = mb_scrub($untrustedInput, 'UTF-8');

Pratique à toute frontière externe : réponses API, uploads de fichiers, lectures en base depuis des systèmes legacy.

Dépréciations à connaître avant l’arrivée de 7.4

Plusieurs choses ont été mollement dépréciées en 7.2 et deviendront des erreurs dans les versions ultérieures. Celles qui risquent le plus de piquer :

__autoload() est déprécié. Si vous enregistrez encore une fonction d’autoload globale au lieu d’utiliser spl_autoload_register(), corrigez ça avant que ça devienne fatal.

create_function() est déprécié. C’est un wrapper autour de eval() et ça a toujours été dangereux. Utilisez une closure :

// avant
$fn = create_function('$x', 'return $x * 2;');

// après
$fn = fn($x) => $x * 2;

each() est déprécié. Le pattern de boucle qu’il permettait s’écrit mieux avec foreach. Aucune perte ici.

parse_str() sans second argument déverse les valeurs parsées dans la table des symboles locale — un problème de sécurité qui n’aurait jamais dû être autorisé. Passez toujours la variable de sortie :

parse_str($queryString, $params); // correct

Le cast (unset) est déprécié parce qu’il retourne toujours null, que vous pouvez simplement écrire null. Une syntaxe complètement inutile qui n’aurait jamais dû exister.