🐘 Et maintenant, PHP

Un guide de PHP moderne qui se lit en deux à trois heures, pour les développeurs venus d’un autre langage.

Vous savez coder, et on vient de vous confier un projet PHP, ou bien vous revenez à ce langage après des années passées ailleurs. Vous n’avez pas besoin d’un tutoriel, mais du delta entre ce que vous savez déjà et ce que PHP fait à sa manière : comment il s’exécute, comment il type, comment il organise le code en paquets, où il va vous surprendre, et à quoi ressemble le PHP d’aujourd’hui une fois l’ancienne réputation mise de côté.

Ce livre se lit en deux à trois heures. Chaque chapitre répond à une question, « comment PHP fait-il ça ? », puis passe à la suivante.

Le PHP décrit ici est PHP 8.5. Les fonctionnalités plus récentes que PHP 8.2 portent leur numéro de version, pour que vous sachiez ce que votre projet peut utiliser.

Introduction

On vous a confié une base de code PHP, que vous l’ayez demandée ou non. Vous ouvrez le premier fichier, vous y trouvez $this->, des ->, des :: et une fonction qui s’appelle htmlspecialchars, et vous vous demandez si c’est bien le langage dont tout le monde vous a dit du mal.

En bonne partie, oui, mais pas celui d’aujourd’hui. Le PHP dont on vous a parlé a existé, et il a presque entièrement disparu. Ce qui reste est un langage typé, orienté objet, avec ramasse-miettes, un gestionnaire de paquets, un style de code standardisé, un écosystème d’analyse statique sérieux, une version par an chaque novembre, et un modèle d’exécution qui ne ressemble à rien de ce que vous avez utilisé jusqu’ici. Ce modèle d’exécution est la seule chose que vous ayez vraiment à apprendre.

Ce qui était vrai

PHP est né en 1995 comme un jeu de gabarits avec un peu de logique dedans, et pendant sa première décennie il a été permissif jusqu’à l’absurde. Les variables apparaissaient de nulle part, "abc" == 0 valait vrai, les erreurs s’imprimaient dans la page et l’exécution continuait, les requêtes SQL se construisaient par concaténation, et la bibliothèque standard s’est assemblée une fonction à la fois, au gré des besoins de chacun, ce qui explique que strpos voisine avec str_replace et array_key_exists avec in_array.

Toute une génération a appris à programmer sur ce PHP-là, en a écrit énormément, et une bonne partie de ce code tourne encore. C’est de ce PHP que parlent les blagues.

Ce qui a changé

PHP 7 (2015) a doublé les performances et ajouté les déclarations de types scalaires. PHP 8 (2020) a apporté un vrai système de types avec les types union, match, les arguments nommés, les attributs, les énumérations, readonly, les callables de première classe et un compilateur JIT. PHP 8.4 a ajouté les hooks de propriété et la visibilité asymétrique, et PHP 8.5 un opérateur pipe. Dans le même mouvement, les règles de comparaison ont été corrigées, les propriétés dynamiques dépréciées, les vieilles fonctions mysql_* supprimées, et l’interpréteur lève désormais une TypeError là où il devinait.

Autour du langage, la communauté a construit Composer, le gestionnaire de paquets que tout projet utilise ; les standards du PHP-FIG, pour que les bibliothèques d’auteurs différents s’emboîtent ; PHPUnit et Pest pour les tests ; PHPStan et Psalm, deux analyseurs statiques qui vous donnent l’essentiel de ce qu’un compilateur donnerait ; et Rector, qui réécrit le vieux code en syntaxe moderne. Depuis 2021, la PHP Foundation salarie des développeurs du cœur du langage, pour que son avenir ne dépende plus des soirées de bénévoles.

Ce qui pique encore

Tout n’a pas été corrigé, et un livre pour gens pressés doit le dire d’emblée. Les chaînes sont des suites d’octets, donc strlen('é') vaut 2 et il vous faut les fonctions mb_ dès qu’il s’agit de texte. La bibliothèque standard garde ses noms et ses ordres d’arguments incohérents, == convertit toujours ses opérandes, quoique bien moins sauvagement qu’avant, le typage strict est un interrupteur par fichier qu’il faut activer, les tableaux se copient à l’affectation, et le langage lui-même n’a pas de génériques. Chacun de ces points a une pratique moderne qui le neutralise, et chacun est traité au chapitre où vous le rencontrerez.

La réputation de PHP est restée en 2010, alors que le langage a continué d’avancer.

L’idée à saisir en premier

Une requête web PHP démarre sans rien, exécute votre code de haut en bas, envoie sa réponse et jette tout. Il n’y a pas de mémoire partagée entre les requêtes, pas d’objet application qui reste en vie, pas de boucle d’événements et pas de threads : le serveur web tend une requête à PHP, PHP produit une réponse, puis oublie tout ce qu’il vient de faire.

Si vous venez de Node, de Java, de Go ou d’un serveur Python ASGI, c’est la différence la plus importante, et la plupart des idiomes PHP en découlent : l’absence de pool de connexions par défaut, « l’état global » qui n’est qu’une notion par requête, le plantage qui n’affecte qu’un visiteur, la montée en charge par ajout de processus, l’existence d’OPcache, et les serveurs PHP persistants comme FrankenPHP ou RoadRunner qui forment un sujet à part entière. Comment PHP s’exécute traite tout cela, et c’est le seul chapitre à ne pas sauter.

Comment lire ce livre

Chaque chapitre répond à une question et se suffit à lui-même. Les phrases en gras portent le fil : en ne lisant que celles-là, vous obtenez le delta entre PHP et ce que vous connaissez déjà. Les blocs de code vous donnent la syntaxe, et le reste du texte est là pour le jour où un détail compte pour vous.

Les comparaisons avec Python, JavaScript, Java et quelques autres langages sont des points de repère, pas des traductions, et vous pouvez sauter celles des langages que vous ne connaissez pas sans rien perdre de l’explication.

Chaque exemple tourne sur une installation nue de PHP avec php fichier.php, sans framework ni bibliothèque, pour que la leçon porte sur PHP lui-même. Installez d’abord PHP : votre gestionnaire de paquets l’a, php.net liste les builds officiels, et l’image Docker officielle est php:8.5-cli. Gardez ensuite un terminal ouvert et exécutez ce que vous lisez.

Trois chapitres s’adressent à un lecteur en particulier. Revenir à PHP après des années fait correspondre les vieilles habitudes aux pratiques modernes, pour ceux qui reviennent au langage. Venir de Python, JavaScript ou Java est une table de correspondance, et PHP 8.0 à 8.5 en un coup d’œil vous dit ce que la version PHP de votre projet sait faire.

Dans deux ou trois heures, la base de code que vous avez ouverte aura changé d’aspect : pas forcément plus simple, mais lisible.

Comment PHP s’exécute

PHP n’exécute pas votre application : il exécute votre script, une fois, pour une requête, puis il s’arrête. Il n’y a pas d’objet serveur à instancier, pas d’appel à listen(), pas de boucle d’événements. Quelque chose d’extérieur à PHP (un serveur web, ou vous dans un terminal) lance l’interpréteur, l’interpréteur exécute un fichier de haut en bas, et tout ce qu’il a alloué est libéré quand le fichier se termine.

Tous les autres chapitres de ce livre sont plus faciles une fois celui-ci assimilé.

Deux portes d’entrée

Depuis un terminal, PHP se comporte comme Python ou Ruby :

php hello.php
php -r 'echo PHP_VERSION, PHP_EOL;'
php -a          # interactive shell
php -l file.php # syntax check only
php -S localhost:8000   # development web server, current folder as document root

Sur le web, PHP n’est pas le serveur. Le serveur web reçoit la requête HTTP et la transmet à PHP, le plus souvent via PHP-FPM, un pool de processus PHP en attente derrière nginx, Apache ou Caddy. Un processus prend la requête, exécute le script auquel l’URL correspond, écrit la réponse, nettoie, et retourne attendre la suivante. Le pool compte autant de processus que vous en configurez, et c’est ainsi que PHP utilise tous vos cœurs, avec des processus plutôt qu’avec des threads.

La couche qui relie l’interpréteur au monde extérieur s’appelle une SAPI (server API). La ligne de commande, FPM et le mod_php d’Apache sont trois SAPI différentes posées sur le même moteur ; seule la plomberie change de l’une à l’autre.

Rien de partagé

C’est la partie qui change votre façon d’écrire du code. Rien ne survit d’une requête à la suivante à l’intérieur de PHP. Une propriété statique que vous affectez, une globale, une connexion ouverte, un objet mis en cache dans un tableau : tout cela existe le temps d’une requête, puis disparaît.

<?php
declare(strict_types=1);

final class Counter
{
    public static int $hits = 0;
}

Counter::$hits++;
echo Counter::$hits; // 1, on every single request, forever

Exécutez ce code sous un serveur web, rechargez la page cent fois, et il affiche 1 cent fois, là où le même code en Node ou en Java compterait jusqu’à 100. Aucun des deux comportements n’est un bug, ce sont simplement deux modèles différents.

Les conséquences s’enchaînent :

• Un bug n’affecte qu’une requête. Fuite mémoire, boucle infinie, exception non rattrapée : le processus qui traitait cette requête meurt ou est recyclé, et la requête suivante en reçoit un neuf.
• La montée en charge est horizontale par construction. Plus de trafic demande plus de processus FPM ou plus de machines, et rien dans l’application n’a besoin d’être thread-safe, puisque rien n’est partagé.
• L’état vit hors de PHP. Les sessions vont dans des fichiers, une base de données ou un stockage clé-valeur. Les caches vont dans OPcache et APCu (mémoire partagée entre les processus d’une machine) ou dans un stockage externe comme Redis ou Memcached. La connexion à la base s’ouvre au début de la requête et se ferme à la fin ; le pooling, si vous en avez besoin, se fait dans un pooler devant la base, pas dans PHP.
• Le coût de démarrage se paie à chaque requête. C’est ce qui explique que PHP démarre vite, et que l’écosystème accorde autant d’attention à l’autoloading, à OPcache et au préchargement.

Si vous vous surprenez à concevoir un singleton pour « garder la connexion ouverte entre les requêtes », arrêtez-vous : dans ce modèle, il n’existe aucun moment entre deux requêtes.

Le cache de bytecode

Lire et compiler chaque fichier à chaque requête serait lent, alors PHP ne le fait pas. OPcache conserve la forme compilée de chaque fichier en mémoire partagée, et la requête suivante la réutilise. Il est livré avec PHP et activé par défaut dans toute installation sérieuse.

En développement, OPcache vérifie les dates des fichiers et recompile ce qui a changé, donc la boucle éditer-recharger fonctionne telle quelle, sans étape de build ni watcher. En production, la vérification des dates est en général désactivée pour gagner du temps, ce qui signifie qu’un déploiement doit réinitialiser le cache, en redémarrant FPM ou en appelant opcache_reset(). Quand on l’oublie, on obtient le classique « j’ai déployé et rien n’a changé ».

OPcache héberge aussi le compilateur JIT (PHP 8.0). Il aide surtout les scripts gourmands en CPU, et ce n’est pas lui qui rend une application web rapide, donc voyez-le comme une option à essayer plutôt que comme une fondation.

PHP persistant

Le modèle sans état partagé est le comportement par défaut, pas une loi. Plusieurs runtimes gardent votre application en mémoire entre les requêtes, comme le ferait un serveur Node ou Java : FrankenPHP en mode worker, RoadRunner, et Swoole ou OpenSwoole. Votre amorçage s’exécute une fois, puis une boucle vous tend les requêtes l’une après l’autre.

Le gain est réel, puisque le coût d’amorçage disparaît et que les connexions peuvent vraiment rester ouvertes. Le coût est celui que vous connaissez déjà des autres langages : l’état fuit si vous ne le nettoyez pas, une fuite mémoire grossit, et un compteur statique compte pour de bon. Les frameworks qui prennent en charge ces runtimes réinitialisent leur conteneur entre deux requêtes précisément pour cela. Commencez avec FPM, et passez à un runtime worker quand vous aurez mesuré une raison de le faire.

Ce qu’il y a dans la boîte

L’interpréteur est un cœur en C plus des extensions, certaines intégrées et toujours actives, d’autres compilées au build, d’autres installées à part. php -m liste ce que contient votre build. Celles dont vous remarquerez l’absence sur une installation fraîche sont en général pdo_mysql ou pdo_pgsql (pilotes de base de données), intl (collation Unicode, formatage), mbstring (chaînes multi-octets), curl, gd ou imagick (images), et xdebug (débogueur, développement seulement).

Votre gestionnaire de paquets les fournit sous forme de paquets séparés (php-intl, php-mbstring, etc.), et l’image Docker officielle fournit docker-php-ext-install. Les extensions non livrées avec PHP viennent de PECL, ou de PIE, l’installeur d’extensions plus récent, dans l’esprit de Composer.

La configuration vit dans php.ini. La ligne de commande et FPM lisent des fichiers ini différents, ce qui explique qu’un script se comporte d’une façon dans un terminal et d’une autre sous le serveur web. php --ini montre les fichiers que charge la CLI, et phpinfo() dans une page montre ceux que charge FPM. Deux réglages comptent dès le premier jour : memory_limit (128 Mo par défaut sous FPM, illimité en CLI) et max_execution_time (30 secondes sous FPM, illimité en CLI).

Le piège

En venant d’un runtime persistant, la première erreur est d’attendre que la mémoire persiste, avec un cache dans un tableau statique, une classe « pool de connexions » ou un compteur pour limiter le débit. Sous FPM, tout cela ne sert silencieusement à rien. La seconde erreur est le miroir de la première : après le passage à un runtime worker, une valeur propre à une requête rangée dans une statique se retrouve partagée entre les utilisateurs.

Posez une seule question sur tout état : doit-il survivre à cette requête ? Si oui, sa place n’est pas dans la mémoire de PHP, mais dans la base, dans un cache ou dans la session.

Une fois ce modèle en place, la syntaxe est la partie facile, et c’est l’objet du chapitre La syntaxe.

La syntaxe

PHP ressemble à du C avec un $ devant chaque variable, -> pour les membres et . pour concaténer les chaînes. Si vous lisez du Java, du JavaScript ou du C#, vous lisez déjà du PHP, et le reste de ce chapitre est la liste des endroits où vos doigts vont taper la mauvaise chose.

Un fichier, de haut en bas

<?php
declare(strict_types=1);

$name = 'world';
$count = 3;

echo "Hello, {$name}!", PHP_EOL;
echo 'Hello, ' . $name . '! Count: ' . $count . PHP_EOL;

Le fichier s’ouvre sur <?php. Tout ce qui précède cette balise, même une ligne vide, part tel quel dans la sortie, parce que PHP a commencé sa vie comme langage de gabarits. Un fichier qui ne contient que du code s’ouvre sur <?php et ne referme jamais la balise, parce qu’un ?> final suivi d’un saut de ligne oublié ferait fuir ce saut de ligne dans votre réponse HTTP.

declare(strict_types=1); vient ensuite, sur sa propre ligne, et désactive la conversion automatique des arguments scalaires dans les appels faits depuis ce fichier. Le système de types explique précisément ce que cette ligne couvre et ce qu’elle ne couvre pas ; pour l’instant, mettez-la dans chaque fichier, et considérez un fichier qui ne l’a pas comme un fichier portant un panneau d’avertissement.

Les variables commencent par $ et ne se déclarent jamais : vous affectez, et la variable existe, sans let, sans var et sans type devant. Les noms de variables sont sensibles à la casse, alors que les noms de fonctions et de classes ne le sont pas, même si personne ne s’appuie sur cette tolérance.

Les instructions se terminent par un point-virgule. echo prend une liste séparée par des virgules et l’affiche, print fait la même chose avec un seul argument et se voit rarement, et PHP_EOL est le saut de ligne de la plateforme.

Les chaînes

L’opérateur de concaténation est ., pas +. Écrire $a + $b avec deux chaînes pousse PHP à les additionner comme des nombres, ce qui donne une TypeError pour des chaînes non numériques sous PHP 8.

Les guillemets simples vous donnent les octets que vous avez tapés, tandis que les guillemets doubles interpolent les variables et traduisent les séquences comme \n. Entourez d’accolades tout ce qui dépasse une simple variable :

<?php
declare(strict_types=1);

$user = ['name' => 'Ada'];
$items = 3;

echo "Hi {$user['name']}, you have {$items} items\n";
echo 'Hi {$user[name]}\n'; // printed literally, backslash included

Pour du texte sur plusieurs lignes, un heredoc interpole et un nowdoc n’interpole pas. Le marqueur de fin peut être indenté (depuis PHP 7.3), et cette indentation est retirée de chaque ligne :

<?php
declare(strict_types=1);

$title = 'Report';

$html = <<<HTML
    <h1>{$title}</h1>
    <p>Generated by PHP</p>
    HTML;

$raw = <<<'TXT'
    No {$interpolation} in here.
    TXT;

echo $html, PHP_EOL, $raw, PHP_EOL;

Trois flèches

PHP a trois symboles en forme de flèche, et leurs rôles ne se recouvrent jamais. -> entre dans une instance, comme dans $user->name ou $user->save(). :: entre dans une classe, comme dans User::create(), User::MAX_AGE ou self::$count. => associe une clé à une valeur dans un tableau littéral ou une branche de match, comme dans ['id' => 1].

<?php
declare(strict_types=1);

final class Money
{
    public const string CURRENCY = 'EUR'; // typed constant, PHP 8.3

    public function __construct(public readonly int $cents)
    {
    }

    public static function zero(): self
    {
        return new self(0);
    }
}

$price = new Money(1999);
echo $price->cents, ' ', Money::CURRENCY, ' ', Money::zero()->cents, PHP_EOL;
// 1999 EUR 0

Dans une méthode, l’instance courante est $this. Les classes et les objets ont leur propre chapitre, Les classes, et cet exemple montre seulement quelle flèche va où.

L’égalité

Utilisez ===, et considérez == comme un opérateur hérité. Le double égal convertit les deux côtés vers un type commun avant de comparer, ce qui a produit les absurdités célèbres du vieux PHP. Depuis PHP 8, un nombre comparé à une chaîne non numérique est comparé comme une chaîne, donc 0 == 'foo' vaut false, mais '1' == '01' vaut toujours true : le comportement est plus sain qu’avant, et reste un jeu de devinettes. Le triple égal compare la valeur et le type, sans rien deviner.

La même règle vaut pour !== contre !=, et pour in_array() et array_search(), qui prennent un troisième argument true pour comparer strictement.

<=> est l’opérateur vaisseau spatial : il renvoie -1, 0 ou 1, et existe pour les fonctions de tri.

Null, en trois opérateurs

<?php
declare(strict_types=1);

$config = ['debug' => null, 'owner' => null];

$debug = $config['debug'] ?? false;      // false: ?? treats null like missing
$config['level'] ??= 'info';             // assign only if null or missing
$length = $config['owner']?->name;       // null, no error: nullsafe chain
$mode = $config['debug'] ? 'on' : 'off'; // plain ternary, same as everywhere

var_dump($debug, $config['level'], $length, $mode);

?? est la coalescence de null, et il avale aussi « clé indéfinie » et « variable indéfinie », ce qui en fait la façon idiomatique de lire une entrée optionnelle d’un tableau. ??= n’affecte que si le côté gauche est null ou absent, et ?-> (PHP 8.0) arrête une chaîne d’appels au premier null et renvoie null. Le ternaire abrégé ?: existe aussi ($a ?: $b renvoie $a s’il est vrai au sens large) ; il convient aux booléens et trompe avec tout le reste.

Le flux de contrôle, d’un seul coup

<?php
declare(strict_types=1);

$scores = ['ada' => 92, 'linus' => 71, 'grace' => 85];

foreach ($scores as $who => $score) {
    if ($score >= 90) {
        $grade = 'A';
    } elseif ($score >= 80) {
        $grade = 'B';
    } else {
        $grade = 'C';
    }
    echo "{$who}: {$grade}", PHP_EOL;
}

for ($i = 0; $i < 3; $i++) {
    echo $i;
}
echo PHP_EOL;

$attempts = 0;
while ($attempts < 3) {
    $attempts++;
}

$label = match (true) {
    $attempts === 0 => 'never tried',
    $attempts < 3 => 'a few tries',
    default => 'gave it everything',
};
echo $label, PHP_EOL;

Rien ici ne demande d’explication, à part deux détails. foreach est la boucle des tableaux et de tout itérable, et elle vous donne la clé et la valeur ensemble avec as $key => $value. match est une expression qui compare avec ===, ne tombe pas dans la branche suivante et lève une exception si rien ne correspond, alors que switch, que vous trouverez dans le code ancien, compare avec == et enchaîne les branches. Énumérations et match montre à quoi sert match.

Tout le reste sur un écran

<?php
declare(strict_types=1);

namespace App\Billing;         // one per file, mirrors the folder

use App\Money;                 // import a class from another namespace
use function App\format_cents; // functions and constants can be imported too

const TAX_RATE = 0.2;          // compile-time constant, namespaced
define('LEGACY', true);        // runtime constant, global, older style

// one-line comment
# also a one-line comment, rarer
/* block
   comment */

/**
 * Docblock: read by editors, PHPStan and Psalm, not by PHP itself.
 */
function total(int ...$cents): int
{
    return array_sum($cents);
}

$parts = [100, 250];
echo total(...$parts), PHP_EOL; // 350: ... unpacks on both sides

... déplie un tableau en arguments et, dans une liste de paramètres, rassemble le reste dans un tableau. Les arguments nommés (total(cents: 5)) existent depuis 8.0. null est une valeur, en minuscules par convention, comme true et false. Les espaces de noms et use font exactement ce que vous attendez des packages Java ou des imports ES, et Namespaces, Composer et autoloading explique comment les fichiers sont trouvés.

Côte à côte

Le piège

Deux choses font trébucher un nouveau venu dans la première heure. La première est ==, une comparaison qui a l’air juste et passe les tests évidents, puis décide que '1e1' == '10' et que null == false. Tapez === jusqu’à ce que ce soit un réflexe, et laissez strict_types attraper le reste.

La seconde est la bibliothèque standard, où l’on trouve strpos($haystack, $needle) mais array_search($needle, $haystack), str_replace avec un tiret bas mais strlen sans, et array_key_exists à côté de in_array. Le nommage n’a jamais été conçu, il s’est accumulé au fil des versions. Les fonctions récentes sont cohérentes (str_contains, array_is_list, array_find), les anciennes ne changeront pas, et le remède n’est pas la mémoire mais un éditeur avec complétion et un analyseur statique qui signale l’ordre d’arguments inversé.

Une fois la syntaxe réglée, les questions intéressantes commencent, à commencer par ce que garantit vraiment int. Le système de types y répond avec plus de nuances que vous ne l’auriez souhaité.

Le système de types

PHP est typé dynamiquement, et chaque type que vous écrivez est vérifié à l’exécution, pas à la compilation comme en Java, et pas effacé comme en TypeScript. Un paramètre déclaré int reçoit un int, sinon l’appel lève une TypeError, à chaque fois, y compris en production. Tout le modèle tient dans cette phrase, et la nuance se cache dans ce que « reçoit un int » veut dire, parce que cette nuance dépend d’un interrupteur.

Les types que vous pouvez écrire

<?php
declare(strict_types=1);

function describe(int|float $n, ?string $label, bool $verbose = false): string
{
    return ($label ?? 'value') . ': ' . $n . ($verbose ? ' (verbose)' : '');
}

echo describe(3, null), PHP_EOL;          // value: 3
echo describe(2.5, 'pi-ish', true), PHP_EOL; // pi-ish: 2.5 (verbose)

Les scalaires sont int, float, string et bool. Les types composés sont array, object, callable, iterable, et tout nom de classe ou d’interface. Par-dessus, PHP a une poignée de types qui n’ont de sens qu’à une position : void et never comme types de retour (never signifie que la fonction lève une exception ou quitte le programme), static comme type de retour d’une méthode fluide, self pour la classe courante, mixed quand vous acceptez vraiment n’importe quoi, et null, true, false comme types autonomes depuis PHP 8.2.

Ces types se combinent : ?string est string|null, int|string est une union (PHP 8.0), Countable&Traversable est une intersection (PHP 8.1) qui exige que l’objet implémente les deux, et (Countable&Traversable)|null mélange les deux formes (PHP 8.2). La grammaire s’arrête là, sans génériques, sans tuples et sans typage structurel.

Les types se posent sur les paramètres, les valeurs de retour, les propriétés, et depuis PHP 8.3 sur les constantes de classe :

<?php
declare(strict_types=1);

final class Temperature
{
    public const string UNIT = 'C';

    public function __construct(
        public readonly float $degrees,
    ) {
    }
}

$t = new Temperature(21.5);
var_dump($t->degrees); // float(21.5)

Les paramètres et propriétés non typés existent toujours et signifient mixed, mais le code moderne ne les laisse pas sans type.

Ce que int accepte vraiment

C’est ici que PHP diffère de tout le reste. Sans strict_types, PHP convertit les arguments scalaires vers le type déclaré quand il le peut. Passez la chaîne "12" à un paramètre int et la fonction reçoit l’entier 12 ; passez "12abc" et vous obtenez une TypeError ; passez 1.5 et vous obtenez 1 avec un avertissement de dépréciation.

La coercition ne concerne que les scalaires : un tableau n’est jamais transformé en chaîne, ni un objet en entier. Une seule conversion reste permise même en mode strict, celle d’un int là où un float est attendu, parce qu’elle ne perd jamais d’information.

L’interrupteur est par fichier, et côté appelant

<?php
declare(strict_types=1);

function double(int $n): int
{
    return $n * 2;
}

echo double(21), PHP_EOL;    // 42
echo double('21'), PHP_EOL;  // TypeError: must be of type int, string given

Supprimez la ligne declare et le second appel affiche 42. Cet interrupteur a trois propriétés, et chacune surprend quelqu’un.

Il est par fichier. Il n’existe ni réglage global, ni option dans php.ini, ni paramètre à l’échelle du projet : chaque fichier annonce son propre mode, et un fichier sans la ligne est en mode coercitif.

Il s’applique aux appels faits depuis le fichier, pas aux fonctions qui y sont définies. Si double() vit dans un fichier strict et qu’un fichier coercitif l’appelle, double('21') convertit, parce que c’est l’appelant qui décide. Ce choix est voulu : l’auteur d’une bibliothèque ne peut pas imposer la rigueur au code qui l’appelle, et le code ancien continue de fonctionner quand il appelle une bibliothèque moderne.

Il couvre aussi les valeurs de retour. Une fonction en mode strict qui déclare : int et renvoie "42" lève une exception.

La règle pratique est courte : mettez declare(strict_types=1); en tête de chaque fichier que vous écrivez, laissez votre outil de style de code l’imposer, et n’y pensez plus.

strict_types n’est pas « PHP avec les types activés », puisque PHP vérifie toujours les types. L’interrupteur décide seulement si une chaîne qui ressemble à un nombre compte comme un nombre.

Convertir volontairement

Quand vous voulez une conversion, dites-le :

<?php
declare(strict_types=1);

var_dump((int) '42');        // int(42)
var_dump((int) '42 apples'); // int(42): a cast takes the leading digits
var_dump((int) 'apples');    // int(0)
var_dump((string) 3.0);      // string(1) "3"
var_dump((bool) '0');        // bool(false): "0" is falsy, "0.0" is not
var_dump(intval('0x1A', 16)); // int(26)

Les transtypages ne lèvent jamais d’exception et n’émettent jamais d’avertissement : ils font de leur mieux avec ce qu’ils reçoivent. Cela en fait le bon outil pour une entrée utilisateur déjà validée, et le mauvais pour tout ce qui ne l’est pas. Pour vérifier avant de convertir, is_int(), is_string(), is_numeric() et leurs cousines renvoient des booléens, et filter_var($x, FILTER_VALIDATE_INT) renvoie l’entier ou false.

Pour voir ce que vous tenez, var_dump() affiche le type et la valeur. get_debug_type() (PHP 8.0) renvoie le nom que vous écririez dans une déclaration (int, string, App\User), là où l’ancien gettype() renvoie integer et object.

Null et la bibliothèque standard

Vos propres fonctions refusent null pour un paramètre non nullable, dans les deux modes. Les fonctions natives sont plus tolérantes, et cette tolérance est en voie de disparition. strlen(null) renvoie 0 aujourd’hui avec un avertissement de dépréciation (depuis PHP 8.1), et la prochaine version majeure devrait lever une exception. Un code qui lit strlen($_GET['q']) sur un paramètre absent vit donc en sursis, alors que strlen($_GET['q'] ?? '') continuera de fonctionner.

La même tolérance se voit dans l’autre sens. Là où une fonction renvoyait false en cas d’échec, les plus récentes lèvent une ValueError (PHP 8.0), et celles qui renvoient encore false sont documentées ainsi. Quand la documentation dit string|false, testez false avec === et jamais avec if (!$result), parce que "0" et "" sont faux au sens large, eux aussi.

Les nombres, brièvement

Un int fait 64 bits sur toutes les plateformes que vous rencontrerez, et le dépassement ne boucle pas : un entier qui déborde devient un flottant, en silence.

<?php
declare(strict_types=1);

var_dump(PHP_INT_MAX + 1); // float(9.223372036854776E+18)
var_dump(0.1 + 0.2 === 0.3); // bool(false), as in every IEEE 754 language
var_dump(intdiv(7, 2), 7 / 2); // int(3), float(3.5)

La division produit toujours un flottant, sauf si les deux opérandes sont des entiers et que le résultat est exact. intdiv() donne la division entière, % est le modulo entier et fmod() celui des flottants. Pour la monnaie ou tout ce qui est décimal, l’extension bcmath et sa classe BcMath\Number (PHP 8.4) font de l’arithmétique à précision arbitraire.

Où sont passés les génériques

Le langage n’en a pas. array est le type de tout tableau, quel que soit son contenu, et une classe Collection ne peut pas dire ce qu’elle collectionne. L’écosystème a répondu avec des docblocks lus par les analyseurs statiques, et sur un projet maintenu cette réponse a autant de poids qu’un compilateur :

<?php
declare(strict_types=1);

/**
 * @template T
 * @param list<T> $items
 * @param callable(T): bool $keep
 * @return list<T>
 */
function keep(array $items, callable $keep): array
{
    return array_values(array_filter($items, $keep));
}

/** @var list<int> $evens */
$evens = keep([1, 2, 3, 4], fn (int $n) => $n % 2 === 0);

PHP lit array et callable, tandis que PHPStan et Psalm lisent list<T> et callable(T): bool, en déduisent que $evens contient des entiers, et font échouer le build si vous passez des chaînes. Avec list<int>, array<string, User>, non-empty-string ou int<1, max>, le vocabulaire est plus riche que le langage, et les deux outils s’accordent sur l’essentiel. Tests, analyse statique et outillage montre comment en installer un.

Le piège

La première erreur est d’écrire function f(int $n) dans un fichier sans strict_types, de passer "12" dans un test, de voir que ça marche, et d’en conclure que PHP ne vérifie rien, alors qu’il a vérifié et converti dans la foulée. La seconde est l’inverse : ajouter declare(strict_types=1) à un fichier et s’attendre à ce que toute l’application devienne stricte, alors que seuls les appels de ce fichier ont changé.

Les deux ont le même remède. La ligne va dans chaque fichier, une règle de style de code l’impose, et un analyseur statique attrape au build les cas que le moteur attraperait en production.

Les tableaux ont été mentionnés trois fois dans ce chapitre sans un mot sur ce qu’ils sont, parce qu’ils ne sont pas ce que votre langage appelle un tableau. Les tableaux remet les choses en place.

Les tableaux

Un tableau PHP est une table de hachage ordonnée, et c’est la seule collection native. Il joue à la fois le rôle de la liste et du dictionnaire de Python, du tableau et de l’objet de JavaScript, de l’ArrayList et de la LinkedHashMap de Java. Les clés sont des entiers ou des chaînes, les valeurs sont n’importe quoi, et l’ordre d’insertion est toujours conservé.

<?php
declare(strict_types=1);

$list = ['apple', 'pear'];                  // keys 0, 1
$map  = ['name' => 'Ada', 'born' => 1815];  // string keys
$mixed = [5 => 'five', 'six', 'x' => 'ex']; // keys 5, 6, 'x'

$list[] = 'plum';          // append, key 2
$map['died'] = 1852;       // insert, at the end

var_dump(array_is_list($list)); // true
var_dump(array_is_list($map));  // false

Il n’y a pas de type liste à part. Une « liste » est un tableau dont les clés se trouvent être 0, 1, 2 et ainsi de suite, dans cet ordre, et array_is_list() (PHP 8.1) vous dit si c’est le cas. La distinction compte quand le tableau quitte PHP : json_encode() produit [...] pour une liste et {...} pour tout le reste.

Les clés sont normalisées

Une clé est soit un int, soit une string, et PHP convertit tout le reste à l’entrée. Une chaîne numérique devient l’entier qu’elle nomme, un flottant perd ses décimales, un booléen devient 0 ou 1, et null devient la chaîne vide :

<?php
declare(strict_types=1);

$a = [];
$a['1'] = 'a';   // key 1, not '1'
$a[1.7] = 'b';   // key 1, overwrites (and a deprecation notice since 8.1)
$a[true] = 'c';  // key 1, overwrites again
$a[null] = 'd';  // key ''

var_dump($a); // [1 => 'c', '' => 'd']

Ces trois écritures visent la même clé. La règle rend service quand une base de données renvoie des identifiants sous forme de chaînes, et elle devient un piège quand vous comptiez sur '1' et 1 pour former deux entrées distinctes, ce qui n’arrive jamais.

Lire une clé absente

Lire une clé absente émet un avertissement et renvoie null. Deux fonctions vous disent si une clé existe, et elles ne sont pas d’accord sur null :

<?php
declare(strict_types=1);

$user = ['name' => 'Ada', 'email' => null];

var_dump(isset($user['email']));            // false: the value is null
var_dump(array_key_exists('email', $user)); // true: the key is there
var_dump(isset($user['phone']));            // false, no warning

$phone = $user['phone'] ?? 'unknown';       // no warning, default applied

isset() répond « y a-t-il ici une valeur non nulle ? », array_key_exists() répond « la clé est-elle présente ? ». Dans presque tous les cas, c’est ?? que vous voulez : il lit la clé si elle existe et n’est pas null, et se rabat sur la valeur par défaut sinon, en silence.

Les tableaux sont des valeurs

Si vous ne retenez qu’une chose de ce chapitre, retenez celle-ci. Affecter un tableau, le passer à une fonction ou le renvoyer produit à chaque fois une copie, et l’original ne voit jamais ce qui arrive à cette copie.

<?php
declare(strict_types=1);

function addItem(array $cart, string $item): array
{
    $cart[] = $item;
    return $cart;
}

$cart = ['book'];
$bigger = addItem($cart, 'pen');

var_dump(count($cart));   // 1
var_dump(count($bigger)); // 2

En JavaScript, en Python ou en Java, cart contiendrait maintenant deux éléments, parce que ces langages font circuler une référence vers une structure partagée. En PHP, la fonction a reçu son propre tableau, et pour vous donner le résultat elle doit le renvoyer.

Le coût est plus faible qu’il n’y paraît, parce que PHP partage la mémoire sous le capot et ne duplique les données qu’à la première écriture, un mécanisme appelé copie à l’écriture. Passer un tableau de dix mille éléments à une fonction qui se contente de le lire ne coûte donc rien.

Vous pouvez y renoncer avec une référence, &, sur le paramètre :

function addItemInPlace(array &$cart, string $item): void
{
    $cart[] = $item;
}

Réservez cette écriture à la rare boucle critique où la copie se mesure. Une fonction qui renvoie un nouveau tableau se lit, se teste et se type plus facilement, et si la famille sort() modifie sur place par référence, c’est une exception héritée de l’histoire du langage plutôt qu’un modèle à suivre.

Les objets se comportent à l’inverse : une variable objet est un identifiant, et les copies de cet identifiant désignent le même objet, comme dans tous les langages que vous connaissez. Quand il vous faut une sémantique de référence pour une collection, enveloppez-la dans une classe, ce que le chapitre Les classes détaille.

foreach, par valeur et par référence

foreach itère sur une copie, donc modifier $item dans la boucle ne change rien :

<?php
declare(strict_types=1);

$prices = [10, 20, 30];

foreach ($prices as $price) {
    $price *= 2; // local copy, the array is untouched
}

foreach ($prices as &$price) {
    $price *= 2; // writes through
}
unset($price); // break the reference

var_dump($prices); // [20, 40, 60]

Le unset() qui suit la boucle par référence a une vraie fonction : sans lui, $price pointe toujours vers le dernier élément, et un $price = 0; innocent plus loin dans le fichier écrase $prices[2]. La plupart des développeurs PHP se sont fait prendre une fois. Un foreach avec $key => $value et une écriture dans $prices[$key] évite la question, et array_map() l’évite tout autant.

Démonter et remonter des tableaux

La déstructuration fonctionne sur les listes et sur les dictionnaires :

<?php
declare(strict_types=1);

[$x, $y] = [3, 4];
['id' => $id, 'name' => $name] = ['id' => 7, 'name' => 'Ada'];
[, $second] = ['skip', 'keep']; // holes are allowed

$defaults = ['color' => 'blue', 'size' => 'M'];
$order = [...$defaults, 'size' => 'L']; // string keys spread since 8.1

var_dump($order); // ['color' => 'blue', 'size' => 'L']

Le dépliage avec des clés chaînes se comporte comme {...defaults, size: 'L'} en JavaScript : les dernières entrées gagnent. Avec des clés entières, le dépliage renumérote, donc [...[1, 2], ...[3]] vaut [1, 2, 3], et non un dictionnaire avec des clés en double.

Le trio fonctionnel et ses cousins

array_map(), array_filter() et array_reduce() font ce que leur nom dit, avec chacun sa subtilité :

<?php
declare(strict_types=1);

$orders = [
    ['id' => 1, 'total' => 40, 'paid' => true],
    ['id' => 2, 'total' => 15, 'paid' => false],
    ['id' => 3, 'total' => 90, 'paid' => true],
];

$totals = array_map(fn(array $o) => $o['total'], $orders);       // [40, 15, 90]
$paid   = array_filter($orders, fn(array $o) => $o['paid']);      // keys 0 and 2
$sum    = array_reduce($totals, fn(int $carry, int $t) => $carry + $t, 0); // 145

echo json_encode($paid);                // {"0":{...},"2":{...}}  an object!
echo json_encode(array_values($paid));  // [{...},{...}]          a list

array_filter() conserve les clés d’origine. Après le filtrage d’une liste, les clés ont des trous, array_is_list() répond false et json_encode() produit un objet ; array_values() renumérote et remet tout en ordre. Notez aussi l’ordre des arguments, qui place le tableau en premier pour array_filter() et array_reduce() mais la fonction de rappel en premier pour array_map(). Cette incohérence a trente ans, et la complétion de votre éditeur reste le meilleur remède.

PHP 8.4 a ajouté les recherches que vous réécriviez à la main : array_find() renvoie le premier élément qui correspond, array_find_key() sa clé, array_any() et array_all() renvoient des booléens. PHP 8.5 a ajouté array_first() et array_last(), qui renvoient la première et la dernière valeur quelles que soient les clés, à côté des plus anciennes array_key_first() et array_key_last().

// PHP 8.4
$firstBig = array_find($orders, fn(array $o) => $o['total'] > 50);
$allPaid  = array_all($orders, fn(array $o) => $o['paid']);   // false

Le tri modifie sur place et, depuis PHP 8.0, est stable. usort() avec l’opérateur vaisseau spatial est l’idiome :

usort($orders, fn(array $a, array $b) => $b['total'] <=> $a['total']);

sort() et usort() renumérotent les clés ; asort() et uasort() les conservent ; ksort() trie par clé. array_column($orders, 'total', 'id') extrait un champ d’une liste de lignes et, avec le troisième argument, indexe le résultat par un autre. array_combine(), array_flip(), array_unique(), array_slice() et array_splice() sont là aussi, avec count() pour la longueur.

Vous croiserez aussi compact() et extract(), qui transforment des variables locales en tableau et inversement. Il suffit de savoir les reconnaître, parce qu’elles mettent en échec l’analyse statique comme votre éditeur et qu’aucun code récent ne les écrit.

Itérer sur n’importe quoi

foreach ne se limite pas aux tableaux. Tout ce qui est iterable fonctionne : tableaux, générateurs, et objets implémentant Iterator ou IteratorAggregate. Une fonction qui accepte iterable peut recevoir un générateur d’un million de lignes sans charger le million de lignes, ce que Fonctions et closures reprend.

<?php
declare(strict_types=1);

function total(iterable $amounts): int
{
    $sum = 0;
    foreach ($amounts as $amount) {
        $sum += $amount;
    }
    return $sum;
}

echo total([1, 2, 3]); // 6

Quand un tableau ne suffit pas

Un tableau ne peut pas dire ce qu’il contient : array $orders n’apprend rien au lecteur, et le langage n’a pas d’array<Order>. La réponse légère est un docblock, @param list<Order> $orders, que PHPStan et Psalm imposent comme un vrai type et que votre éditeur utilise pour la complétion. La réponse plus lourde est une petite classe, une final class Orders qui détient un tableau privé, expose exactement les opérations dont vous avez besoin, et implémente les interfaces qui lui permettent de se comporter comme un tableau là où c’est utile : Countable pour count(), ArrayAccess pour $orders[0] et IteratorAggregate pour foreach.

Pour les cas qu’un tableau ne couvre pas, la bibliothèque standard fournit SplObjectStorage, qui associe des objets à des données en utilisant l’objet lui-même comme clé, et WeakMap (PHP 8.0), qui fait de même sans garder l’objet en vie, ce qui permet aux caches indexés par entité de ne pas fuir.

Les deux habitudes à perdre ici sont d’attendre d’une fonction qu’elle modifie le tableau que vous lui passez, et d’oublier qu’array_filter() laisse des trous. Renvoyez le nouveau tableau, et passez par array_values() avant d’encoder.

Les tableaux sont ce que la plupart du code PHP fait circuler, et les fonctions sont ce à quoi il les confie. Comme les closures de PHP capturent leur contexte autrement que celles que vous connaissez, elles méritent leur propre chapitre, Fonctions et closures.

Fonctions et closures

Les fonctions PHP ressemblent à celles de TypeScript avec un $ devant chaque paramètre, et les closures capturent par valeur, pas par variable. La première moitié de cette phrase se lit en vitesse, et c’est dans la seconde que se cachent les surprises de ce chapitre.

<?php
declare(strict_types=1);

function greet(string $name, string $greeting = 'Hello', bool $shout = false): string
{
    $text = "$greeting, $name!";
    return $shout ? strtoupper($text) : $text;
}

echo greet('Ada');                       // Hello, Ada!
echo greet('Ada', shout: true);          // HELLO, ADA!
echo greet(greeting: 'Hi', name: 'Ada'); // Hi, Ada!

Paramètres et valeurs de retour portent des types, vérifiés à l’exécution comme l’explique Le système de types. Les valeurs par défaut fonctionnent comme partout. Les arguments nommés (PHP 8.0) permettent de sauter les valeurs par défaut qui ne vous intéressent pas et rendent lisible un appel à quatre booléens. Positionnels et nommés se mélangent, les positionnels d’abord.

Variadiques, références et types de retour particuliers

... sur le dernier paramètre rassemble le reste dans un tableau ; ... dans un appel déplie un tableau en arguments, clés de chaîne comprises, ce qui transforme un tableau en arguments nommés :

<?php
declare(strict_types=1);

function sum(int ...$numbers): int
{
    return array_sum($numbers);
}

echo sum(1, 2, 3);        // 6
echo sum(...[4, 5]);      // 9

$options = ['greeting' => 'Hey', 'name' => 'Ada'];
// greet(...$options) would call greet(name: 'Ada', greeting: 'Hey')

Un paramètre déclaré &$x reçoit une référence, et la fonction écrit alors directement dans la variable de l’appelant. La bibliothèque standard s’en sert pour sort(), pour le $matches de preg_match() et pour quelques autres. Dans votre propre code, préférez renvoyer la valeur, parce qu’une fonction qui modifie ses arguments oblige le lecteur à l’ouvrir pour comprendre ce qu’elle fait.

Les types de paramètres acceptent tout ce que le système de types propose : ?string $label = null pour une valeur optionnelle, int|string $id pour une union, Countable&Traversable $items pour une intersection. Écrivez le ? explicitement, car un simple string $x = null fonctionne encore mais est déprécié depuis PHP 8.4. Pour une fonction qui accepte une fonction, vous avez le choix entre callable, qui accepte les closures ainsi que les formes chaîne et tableau décrites plus bas, et Closure, qui n’accepte que de vrais objets closure. Le code récent tend à déclarer Closure et à laisser l’appelant convertir avec (...), parce qu’une Closure se vérifie par le typage alors qu’une chaîne échappe à toute vérification.

Les fonctions qui ne reviennent pas normalement disposent de leurs propres types de retour : void signifie que rien ne revient, et never (PHP 8.1) signifie que la fonction lève toujours une exception ou termine le script, de sorte que les analyseurs statiques savent que le code placé après un appel à fail() est inaccessible.

Les fonctions ne sont pas des valeurs, mais on peut en obtenir une référence

Un nom de fonction n’est pas une expression, et $f = strlen; est une erreur de syntaxe. Le contournement historique passait par une chaîne : $f = 'strlen'; fonctionne parce que le type callable accepte un nom de fonction, une paire [$object, 'method'] ou une chaîne 'Class::method'. Cette forme marche encore, mais rien ne la vérifie avant l’exécution.

La façon moderne est la syntaxe de callable de première classe (PHP 8.1) : le nom suivi de (...).

<?php
declare(strict_types=1);

final class Mailer
{
    public function send(string $to): string
    {
        return "sent to $to";
    }
}

$length = strlen(...);                   // Closure wrapping strlen()
$send = (new Mailer())->send(...);       // Closure bound to that instance

echo $length('hello'); // 5
echo $send('ada@example.org');

var_dump(array_map(strtoupper(...), ['a', 'b'])); // ['A', 'B']

Le résultat est un objet Closure, la seule valeur de type fonction en PHP. Il est sûr pour le typage comme pour le refactoring, puisque votre éditeur suit le renommage de la méthode, et c’est la forme à passer à array_map() et consorts. Quand vous tenez une chaîne plutôt qu’un nom, Closure::fromCallable('strlen') produit le même objet.

Le réflexe du développeur venu d’ailleurs est d’écrire $this->send sans parenthèses, ce qui en PHP lit la propriété send, qui n’existe pas. La méthode en tant que valeur s’écrit $this->send(...).

Les closures capturent par valeur

Les fonctions anonymes existent, et vous devez dire ce qu’elles capturent :

<?php
declare(strict_types=1);

$rate = 0.2;

$withTax = function (float $price) use ($rate): float {
    return $price * (1 + $rate);
};

$rate = 0.5; // too late, the closure already copied 0.2

echo $withTax(100.0); // 120

La clause use copie les variables au moment où la closure est créée. Rien de la portée englobante n’est visible sans être listé, et les changements ultérieurs de la variable extérieure n’atteignent pas la closure. Là où JavaScript et Python se referment sur la variable elle-même et afficheraient 150 ici, PHP donne à la closure un instantané pris à sa création.

Pour capturer la variable plutôt que sa valeur, ajoutez & dans la clause, use (&$rate), et la closure partage alors la variable avec la portée extérieure, dans les deux sens. On en a besoin pour un accumulateur, ou pour une closure récursive qui doit se voir elle-même :

$fact = function (int $n) use (&$fact): int {
    return $n <= 1 ? 1 : $n * $fact($n - 1);
};

Les fonctions fléchées (PHP 7.4) suppriment la cérémonie. fn capture automatiquement toute la portée englobante, par valeur, et ne contient qu’une seule expression :

$withTax = fn(float $price): float => $price * (1 + $rate);

Il n’y a plus ni use, ni return, ni accolades, mais la sémantique d’instantané reste la même. La plupart des callbacks que vous écrirez seront des fonctions fléchées, et vous reviendrez à function () use () quand il vous faudra plusieurs instructions ou une capture par référence.

Dans une classe, une closure conserve $this automatiquement, comme vous vous y attendez. Marquez-la static fn ou static function quand elle n’a pas besoin de l’instance, ce qui évite de maintenir l’objet en vie depuis un callback de longue durée. Closure::bind() et $closure->call($object) rattachent $this à un autre objet ; c’est ainsi que les frameworks atteignent un état privé depuis l’extérieur, et vous les écrirez rarement vous-même.

Générateurs

Une fonction qui contient yield renvoie un Generator sans exécuter son corps, et chaque tour de foreach la fait avancer jusqu’au yield suivant. Si vous connaissez les générateurs de Python, vous les retrouvez ici presque ligne pour ligne :

<?php
declare(strict_types=1);

/** @return Generator<int, string> */
function lines(string $path): Generator
{
    $handle = fopen($path, 'r');
    try {
        while (($line = fgets($handle)) !== false) {
            yield rtrim($line, "\n");
        }
    } finally {
        fclose($handle);
    }
}

foreach (lines('/etc/hosts') as $number => $line) {
    echo "$number: $line", PHP_EOL;
}

Le fichier est lu une ligne à la fois, quelle que soit sa taille, et fermé quand la boucle se termine ou s’interrompt. Un générateur est iterable, donc toute fonction qui accepte iterable le prend sans le savoir. yield $key => $value fixe des clés explicites, yield from délègue à un autre générateur ou à un tableau, et un return dans un générateur définit une valeur lisible via getReturn() une fois l’itération terminée. Un générateur ne s’exécute qu’une fois, et pour itérer à nouveau il faut rappeler la fonction.

Pipelines

PHP 8.5 ajoute l’opérateur pipe. $x |> f(...) appelle f($x), et les chaînes se lisent de haut en bas au lieu de l’intérieur vers l’extérieur :

// PHP 8.5
$slug = ' Hello World '
    |> trim(...)
    |> strtolower(...)
    |> (fn(string $s) => str_replace(' ', '-', $s));

echo $slug; // hello-world

Chaque étape est n’importe quel callable à un argument, ce qui correspond exactement à ce que produisent la syntaxe de callable de première classe et les fonctions fléchées. Avant 8.5, le même code tenait en trois appels imbriqués ou en trois variables temporaires, deux formes qui fonctionnent toujours et restent courantes.

PHP 8.5 apporte aussi #[\NoDiscard], un attribut pour les fonctions dont la valeur de retour ne doit pas être ignorée. Si vous appelez une telle fonction comme simple instruction, PHP émet un avertissement, et vous transtypez l’appel en (void) pour dire que c’est voulu. Les bibliothèques l’utilisent sur les méthodes qui renvoient un nouvel objet immuable, pour éviter le bug classique du $date->modify() dont on jette le résultat.

Les formes anciennes que vous reconnaîtrez

func_get_args() et func_num_args() lisent les arguments d’une fonction déclarée sans paramètres ; elles précèdent ...$args et survivent dans le vieux code. call_user_func() et call_user_func_array() invoquent un callable, ce que $callable(...$args) fait aujourd’hui. create_function() fabriquait des closures à partir de chaînes et a été supprimée en 8.0. Quand vous croisez ces formes, le remplacement moderne se trouve à une ligne de là, et Rector peut faire la modification pour vous.

Les closures photographient leurs variables use, les fonctions fléchées photographient toute la portée, et une méthode devient une valeur avec (...). Avec ces trois points en tête, les callbacks PHP n’ont plus de surprise en réserve.

Les fonctions portent le comportement, mais les données sur lesquelles elles agissent sont surtout des objets, et le modèle objet de PHP a plus changé ces cinq dernières années que pendant les quinze précédentes. Le chapitre Les classes montre à quoi il ressemble aujourd’hui.

Les classes

Une classe PHP moderne est courte, typée et presque entièrement immuable. Le constructeur déclare les propriétés, les types sont vérifiés à l’exécution, et l’essentiel du code répétitif que vous connaissez de Java, ou de PHP 5, a disparu. L’exemple ci-dessous montre une classe complète :

<?php
declare(strict_types=1);

namespace App\Billing;

final class Invoice
{
    private array $lines = [];

    public function __construct(
        public readonly string $number,
        public readonly \DateTimeImmutable $issuedAt,
    ) {
    }

    public function addLine(string $label, int $cents): static
    {
        $this->lines[] = ['label' => $label, 'cents' => $cents];

        return $this;
    }

    public function total(): int
    {
        return array_sum(array_column($this->lines, 'cents'));
    }
}

$invoice = new Invoice('2026-0042', new \DateTimeImmutable('2026-09-14'));
$invoice->addLine('Hosting', 1200)->addLine('Support', 800);

echo $invoice->number, ': ', $invoice->total(), PHP_EOL; // 2026-0042: 2000

En la lisant de haut en bas, vous rencontrez d’abord namespace, qui place la classe dans App\Billing, de sorte que son nom complet est App\Billing\Invoice (le chapitre Namespaces, Composer et autoloading explique comment ce nom correspond à un fichier). final interdit l’héritage, et le code PHP moderne rend les classes final par défaut pour ne les ouvrir qu’à dessein. Le constructeur n’a pas de corps, parce qu’écrire public readonly string $number dans la liste des paramètres déclare la propriété, la type et l’affecte en une seule ligne. Cette promotion de propriétés dans le constructeur (PHP 8.0) a retiré l’essentiel de la cérémonie des classes PHP. readonly (PHP 8.1) rend la propriété affectable une seule fois, dans le constructeur, et plus jamais ensuite. Enfin, static comme type de retour signifie « la classe de l’objet sur lequel la méthode a été appelée », ce qui est exactement ce qu’une méthode fluide veut promettre.

L’accès aux membres passe par deux symboles : -> atteint un membre d’instance, :: atteint un membre statique ou une constante. $this est l’objet courant, et vous l’écrivez toujours puisqu’il n’y a pas de this implicite.

Les objets circulent par identifiant

Les tableaux se copient quand vous les affectez, comme le chapitre Les tableaux l’explique, mais les objets suivent la règle inverse. Affecter ou passer un objet copie un identifiant qui désigne le même objet, comme le font Java, Python et JavaScript :

<?php
declare(strict_types=1);

final class Cart
{
    public array $items = [];
}

function addApple(Cart $cart): void
{
    $cart->items[] = 'apple';
}

$cart = new Cart();
addApple($cart);
echo count($cart->items), PHP_EOL; // 1, the caller sees the change

Ce comportement ne doit rien au & des paramètres par référence, qui sont un mécanisme différent, réservé aux variables, et dont vous n’avez presque jamais besoin avec des objets.

clone $cart fait une copie superficielle, c’est-à-dire un nouvel objet dont les propriétés contiennent les mêmes valeurs, de sorte qu’un objet rangé à l’intérieur est partagé entre les deux copies. Définissez __clone() si la copie a besoin de ses propres objets internes.

Pour comparer deux objets, == compare l’état propriété par propriété, tandis que === demande si les deux côtés sont le même objet, ce qui explique que $a === clone $a vaille false.

L’immuabilité sans accesseurs

La classe PHP 5 classique avait une propriété privée, un getter, et parfois un setter. Ce motif a été remplacé par des fonctionnalités récentes que vous verrez dans toutes les bases de code écrites après 2024.

La première est readonly, que vous avez déjà rencontré. Quand toutes les propriétés d’une classe sont readonly, marquez plutôt la classe elle-même (PHP 8.2) :

<?php
declare(strict_types=1);

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

    public function add(Money $other): self
    {
        return new self($this->amount + $other->amount, $this->currency);
    }
}

Chaque propriété est publique et personne ne peut la modifier, ce qui vous donne un objet valeur sans le moindre getter.

La visibilité asymétrique (PHP 8.4) laisse l’extérieur lire une propriété que seule la classe peut écrire :

// PHP 8.4
final class Counter
{
    public private(set) int $count = 0;

    public function increment(): void
    {
        $this->count++;
    }
}

$c = new Counter();
$c->increment();
echo $c->count; // 1
$c->count = 5;  // Error: Cannot modify private(set) property Counter::$count

Le getter n’a plus de raison d’être. Là où il vous faut de la logique à la lecture ou à l’écriture, les hooks de propriété (PHP 8.4) l’attachent à la propriété elle-même, comme une propriété C# ou le @property de Python :

// PHP 8.4
final class User
{
    public string $email {
        set(string $value) {
            if (!filter_var($value, FILTER_VALIDATE_EMAIL)) {
                throw new \InvalidArgumentException("Invalid email: $value");
            }
            $this->email = strtolower($value);
        }
    }

    public string $domain {
        get => substr($this->email, strpos($this->email, '@') + 1);
    }
}

$u = new User();
$u->email = 'Ada@Example.org';
echo $u->domain; // example.org

Pour l’appelant, ce sont des propriétés ordinaires, alors qu’à l’intérieur set valide et normalise pendant que get calcule. Une propriété avec un seul hook get et sans stockage est simplement une propriété calculée.

Interfaces, classes abstraites, traits

Les interfaces et les classes abstraites fonctionnent comme en Java et en C# : une interface liste des signatures de méthodes et des constantes, une classe abstraite peut porter de l’implémentation, une classe implémente plusieurs interfaces et étend un seul parent. #[\Override] (PHP 8.3) sur une méthode fait vérifier à PHP que le parent la possède vraiment, ce qui attrape les fautes de frappe dans les redéfinitions.

Les traits, eux, n’ont pas d’équivalent exact dans la plupart des langages. Un trait est un bloc de méthodes et de propriétés que le compilateur copie dans chaque classe qui l’utilise avec use. Les mixins de Ruby en sont le repère le plus proche, alors que les traits de Rust, malgré le nom, décrivent tout autre chose.

<?php
declare(strict_types=1);

trait HasTimestamps
{
    private ?\DateTimeImmutable $createdAt = null;

    public function touch(): void
    {
        $this->createdAt ??= new \DateTimeImmutable();
    }
}

final class Article
{
    use HasTimestamps;
}

$a = new Article();
$a->touch();

Les traits sont pratiques pour les utilitaires transversaux et faciles à surutiliser, parce qu’une classe qui en utilise cinq vous impose cinq fichiers à lire pour savoir ce qu’elle fait. Préférez la composition quand vous le pouvez.

La différence entre static et self tient en quelques lignes : self nomme la classe où le code est écrit, tandis que static nomme la classe de l’objet à l’exécution. Dans une fabrique statique définie dans une classe parente, new static() construit donc la sous-classe réellement appelée, alors que new self() construit toujours le parent.

Construction

PHP n’a qu’un constructeur par classe et ne connaît pas la surcharge de méthodes. Le manque est comblé par les arguments nommés (PHP 8.0) pour les paramètres optionnels, et par les fabriques statiques pour les autres façons de construire :

<?php
declare(strict_types=1);

final readonly class Period
{
    private function __construct(
        public \DateTimeImmutable $start,
        public \DateTimeImmutable $end,
    ) {
    }

    public static function fromStrings(string $start, string $end): self
    {
        return new self(new \DateTimeImmutable($start), new \DateTimeImmutable($end));
    }

    public static function year(int $year): self
    {
        return self::fromStrings("$year-01-01", "$year-12-31");
    }
}

$fy = Period::year(2026);
echo $fy->end->format('Y-m-d'), PHP_EOL; // 2026-12-31

Un constructeur privé plus des fabriques publiques se lit aussi bien qu’un jeu de constructeurs surchargés, et chaque variante porte un nom.

Depuis PHP 8.4, vous pouvez chaîner un appel sur un objet fraîchement créé sans l’entourer de parenthèses : new Period(...)->start exigeait auparavant (new Period(...))->start.

Pour les objets immuables, « modifier » signifie « fabriquer une copie modifiée ». PHP 8.5 lui donne sa propre syntaxe : clone($money, ['amount' => 500]) renvoie une copie avec les propriétés listées remplacées. Les règles de visibilité habituelles s’appliquent, et une propriété readonly ne s’écrit que depuis l’intérieur de sa classe, donc l’appel vit dans une méthode withAmount() plutôt que chez l’appelant. Avant 8.5, cette même méthode clonait puis affectait dans __clone(), ce que PHP 8.3 a autorisé pour les propriétés readonly.

Chaînes, magie et métadonnées

Tout objet peut s’afficher lui-même en implémentant __toString(). Le déclarer fait automatiquement implémenter Stringable (PHP 8.0) à la classe, de sorte que vous pouvez typer un paramètre string|Stringable et accepter les deux.

Les autres méthodes à double tiret bas sont des crochets que le moteur appelle : __get et __set s’exécutent quand le code touche une propriété qui n’existe pas, __call quand il appelle une méthode qui n’existe pas. Les frameworks et les ORM s’en servent pour construire des API fluides et des modèles paresseux, et il suffit de savoir les reconnaître, sans les utiliser dans le code applicatif. Dans le même esprit, créer une propriété jamais déclarée ($obj->foo = 1 sans $foo dans la classe) est déprécié depuis PHP 8.2 et doit devenir une erreur dans la prochaine version majeure, ce qui est une raison de plus de déclarer toutes vos propriétés.

Les attributs (PHP 8.0) sont des métadonnées structurées sur une classe, une méthode, une propriété ou un paramètre, lues par réflexion. Les annotations Java et les attributs C# sont le repère direct :

<?php
declare(strict_types=1);

#[\Attribute(\Attribute::TARGET_METHOD)]
final readonly class Route
{
    public function __construct(public string $path) {}
}

final class HomeController
{
    #[Route('/')]
    public function index(): string
    {
        return 'Hello';
    }
}

$method = new \ReflectionMethod(HomeController::class, 'index');
foreach ($method->getAttributes(Route::class) as $attribute) {
    echo $attribute->newInstance()->path, PHP_EOL; // /
}

Un attribut est lui-même une classe marquée #[\Attribute], et rien ne se passe à l’exécution tant que personne n’appelle getAttributes(), la métadonnée restant inerte jusqu’à sa lecture. Le routage, la validation, la sérialisation et les frameworks de test reposent tous sur ce mécanisme.

Invoice::class donne le nom pleinement qualifié sous forme de chaîne, ce que vous faites circuler au lieu d’écrire 'App\Billing\Invoice' en dur. $x instanceof Invoice vérifie le type à l’exécution et vaut false, sans erreur, quand $x n’est pas un objet. Les objets paresseux (PHP 8.4) permettent d’instancier une classe sans exécuter son constructeur tant qu’une propriété n’est pas touchée, un outil pour les conteneurs d’injection de dépendances et les ORM plutôt que pour le code de tous les jours.

Le langage n’a pas de génériques, et une classe Collection contient du mixed aux yeux du moteur ; les docblocks @template décrits dans Le système de types donnent à PHPStan et Psalm ce qui manque au moteur.

Le piège

Une fonction qui reçoit un objet et « l’ajuste juste un peu » ajuste aussi l’objet de l’appelant. Si vous vouliez une modification locale, faites d’abord un clone, ou concevez la classe en readonly et renvoyez une nouvelle instance.

Gardez aussi en tête que readonly est superficiel : il gèle la case de la propriété, pas ce vers quoi elle pointe. Un readonly array $items ne peut pas être réaffecté, mais un readonly Cart $cart laisse quiconque tient $cart y pousser des articles. L’immuabilité de tout le graphe reste une décision de conception, que le mot-clé ne prend pas à votre place.

Une fois les classes en main, reste à voir comment PHP représente un ensemble fermé de choix, ce qui est le sujet du chapitre Énumérations et match.

Énumérations et match

Une énumération PHP est une classe dotée d’un ensemble fixe d’instances, et match est l’expression qui choisit une branche par instance. Ensemble, ils remplacent le motif constantes-de-classe-plus-switch dont le vieux code PHP est rempli. Si vous connaissez les enums de Java, vous savez déjà presque tout ; si vous venez de l’Enum de Python ou des unions de littéraux de chaîne de TypeScript, la forme vous sera familière et les vérifications plus strictes.

<?php
declare(strict_types=1);

enum Status: string
{
    case Draft = 'draft';
    case Published = 'published';
    case Archived = 'archived';

    public function label(): string
    {
        return match ($this) {
            self::Draft => 'Draft',
            self::Published => 'Live',
            self::Archived => 'Archived',
        };
    }

    public function canEdit(): bool
    {
        return $this !== self::Archived;
    }
}

$status = Status::from('published');   // Status::Published
echo $status->label(), PHP_EOL;         // Live
echo $status->value, PHP_EOL;           // published
var_dump($status->canEdit());           // bool(true)
var_dump(Status::tryFrom('deleted'));   // NULL

Cas, valeurs et méthodes

Une énumération (PHP 8.1) déclare ses case et rien d’autre ne peut en être un. Status::Draft est un objet, le seul de son espèce, donc deux références au même cas sont le même objet, et === est la comparaison à utiliser. Les énumérations ne s’instancient pas avec new, ne s’étendent pas, et ne portent aucun état, ni propriétés ni données par instance. En revanche, elles peuvent avoir des méthodes, des constantes, des méthodes statiques et des interfaces à implémenter.

Le : string après le nom en fait une énumération adossée, dont chaque cas porte un scalaire (string ou int) accessible via ->value. from() retransforme un scalaire en cas et lève une ValueError quand rien ne correspond, tandis que tryFrom() renvoie null à la place. C’est par ce duo qu’une énumération franchit une frontière, qu’il s’agisse d’une colonne en base, d’un champ JSON ou d’un paramètre d’URL. Une énumération pure, déclarée sans type adossé, a des cas mais pas de ->value, et convient quand le choix ne quitte jamais votre code.

cases() renvoie tous les cas dans l’ordre de déclaration, ce que veulent une liste déroulante ou une règle de validation :

$allowed = array_map(fn (Status $s) => $s->value, Status::cases());
// ['draft', 'published', 'archived']

Chaque cas a aussi un ->name ('Draft'), utile pour les journaux.

Comme $this dans une méthode d’énumération est un cas, le comportement qui dépend du cas appartient à l’énumération plutôt qu’à des chaînes de if éparpillées dans le code. label() et canEdit() ci-dessus illustrent ce motif, où l’énumération sait ce que chacun de ses cas signifie.

Depuis PHP 8.2, les cas d’énumération sont autorisés dans les expressions constantes, donc comme valeurs par défaut de paramètres, constantes de classe et arguments d’attributs : public function __construct(private Status $status = Status::Draft).

match

match (PHP 8.0) ressemble à switch et se comporte comme une expression en Rust ou un when en Kotlin, avec un comportement qui se résume à ce qui suit.

Il renvoie une valeur. $label = match ($status) { ... }; et return match (...) sont les usages normaux. Il n’y a pas de break, parce qu’il n’y a pas de passage à la branche suivante, et exactement une branche s’exécute.

Il compare avec ===. match ('1') { 1 => 'int', '1' => 'string' } choisit la seconde branche, là où switch aurait choisi la première.

Il doit être exhaustif. Si aucune branche ne correspond et qu’il n’y a pas de default, PHP lève UnhandledMatchError. Si vous ajoutez un cas à une énumération et oubliez de mettre à jour un match qui la lit, la première fois que ce cas atteint le match vous obtenez une exception qui nomme la ligne exacte, plutôt qu’un null silencieux.

Une branche peut lister plusieurs valeurs, séparées par des virgules :

<?php
declare(strict_types=1);

enum Status: string
{
    case Draft = 'draft';
    case Published = 'published';
    case Archived = 'archived';
}

function isVisible(Status $status): bool
{
    return match ($status) {
        Status::Published => true,
        Status::Draft, Status::Archived => false,
    };
}

Les analyseurs statiques comprennent cette règle, et PHPStan comme Psalm signalent un match sur une énumération qui laisse un cas non traité, avant même qu’il s’exécute.

Le sujet d’un match n’est pas forcément une énumération. Toute valeur convient, et l’idiome match (true) en fait une échelle de conditions qui produit une valeur :

$size = match (true) {
    $bytes < 1024 => 'small',
    $bytes < 1024 * 1024 => 'medium',
    default => 'large',
};

Chaque branche est comparée avec === à true, donc chaque branche est une expression booléenne, ce qui se lit mieux qu’un ternaire imbriqué et ne peut pas passer à la branche suivante.

switch existe toujours, avec sa comparaison lâche, son passage à la branche suivante et ses break, et vous le croiserez dans du code plus ancien. Dans du code neuf, match est le bon choix par défaut, et switch sert au cas rare où vous voulez vraiment que plusieurs étiquettes partagent un bloc d’instructions.

Null et throw comme expressions

Deux opérateurs se marient naturellement avec match et les énumérations. L’opérateur nullsafe ?-> (PHP 8.0) court-circuite une chaîne quand le côté gauche vaut null, de sorte que $order?->customer?->email vaut null si un maillon est null, au lieu de provoquer une erreur. Combiné à ??, il donne une valeur par défaut en une ligne : $email = $order?->customer?->email ?? 'nobody@example.org';.

throw est une expression (PHP 8.0), donc il peut se placer à droite d’un ??, dans un ternaire ou dans une branche de match :

$status = Status::tryFrom($input) ?? throw new \InvalidArgumentException("Unknown status: $input");

$handler = match ($status) {
    Status::Draft => $this->saveDraft(...),
    Status::Published => $this->publish(...),
    Status::Archived => throw new \LogicException('Archived items are read-only'),
};

Le second exemple montre aussi le motif du dispatch, un match qui renvoie un callable, suivi de $handler($item).

Persistance et comportement au même endroit

Dans une application, les trois idées se retrouvent dans une même déclaration : une énumération adossée pour le stockage, des méthodes pour le comportement, et match là où vivent les branches.

<?php
declare(strict_types=1);

interface HasColor
{
    public function color(): string;
}

enum Priority: int implements HasColor
{
    case Low = 1;
    case Normal = 2;
    case High = 3;

    public const DEFAULT = self::Normal;

    public static function fromLabel(string $label): self
    {
        return match (strtolower($label)) {
            'low' => self::Low,
            'normal', 'medium' => self::Normal,
            'high', 'urgent' => self::High,
            default => throw new \ValueError("Unknown priority: $label"),
        };
    }

    public function color(): string
    {
        return match ($this) {
            self::Low => 'grey',
            self::Normal => 'blue',
            self::High => 'red',
        };
    }

    public function escalate(): self
    {
        return match ($this) {
            self::Low => self::Normal,
            self::Normal, self::High => self::High,
        };
    }
}

$p = Priority::fromLabel('medium');
echo $p->color(), PHP_EOL;              // blue
echo $p->escalate()->name, PHP_EOL;     // High
echo Priority::DEFAULT->value, PHP_EOL; // 2

L’entier part en base et l’énumération circule partout ailleurs. Il n’y a pas de constante PRIORITY_HIGH = 3 à garder synchronisée avec une table de couleurs quelque part, parce que le cas et son comportement vivent dans un seul fichier.

Face au motif ancien, constantes de classe plus drapeaux de chaîne plus switch, une énumération vous donne un vrai type à mettre dans une signature (function assign(Priority $p)), vérifié par le moteur, et un ensemble fermé sur lequel l’analyseur peut raisonner.

Le piège

Deux habitudes venues d’autres langages, et du vieux PHP, provoquent le même bug.

La première consiste à reprendre switch, qui compare de façon lâche : switch (Status::Draft) avec case 'draft': ne correspond jamais, puisqu’une énumération n’est pas égale à sa valeur quelle que soit la comparaison, et avec un sujet de type chaîne un case 0: correspond à plus de choses que vous ne l’imaginez.

La seconde consiste à comparer une énumération à sa valeur adossée, alors que $status == 'published' vaut toujours false, l’énumération étant un objet et la chaîne ce qu’elle stocke. Comparez des cas à des cas ($status === Status::Published), ou convertissez d’abord ($status->value === 'published').

La question suivante, pour un développeur venu d’ailleurs, est ce qui se passe quand quelque chose tourne mal, et le chapitre Erreurs et exceptions décrit un modèle qui mêle deux mécanismes.

Erreurs et exceptions

PHP a des exceptions, et elles fonctionnent comme celles de Python ou de Java. Il a aussi un mécanisme plus ancien, les erreurs moteur, antérieur aux exceptions et toujours présent. La pratique moderne consiste à tout faire passer par les exceptions, et ce chapitre montre d’abord ce modèle, puis la poignée de lignes de configuration qui ramènent l’ancien mécanisme dans le même circuit.

Deux hiérarchies, une racine

Tout ce qui peut être levé avec throw et rattrapé avec catch implémente Throwable, et cette interface se divise en deux familles.

Error est ce que le moteur lève quand votre code est faux : TypeError pour un mauvais argument, ValueError pour un bon type avec une valeur impossible, ArgumentCountError, DivisionByZeroError, UnhandledMatchError quand un match ne trouve aucune branche. Vous ne les levez pas vous-même, et vous les rattrapez rarement, parce qu’elles signalent un bug plutôt qu’une situation.

Exception est la famille de vos propres erreurs. PHP en livre un petit jeu dans la SPL, dont les noms tiennent lieu de documentation : InvalidArgumentException, RuntimeException, LogicException, DomainException, OutOfRangeException, UnexpectedValueException. Étendez l’une d’elles plutôt qu’Exception directement, et vos appelants disposent d’une famille parlante à rattraper.

La syntaxe ne réserve aucune surprise :

<?php
declare(strict_types=1);

function parsePort(string $raw): int
{
    if (!ctype_digit($raw)) {
        throw new InvalidArgumentException("Not a port: $raw");
    }

    return (int) $raw;
}

try {
    $port = parsePort('80a');
} catch (InvalidArgumentException|ValueError $e) {
    echo 'Bad input: ', $e->getMessage(), PHP_EOL;
} finally {
    echo 'Done.', PHP_EOL;
}

| rattrape plusieurs types dans un même bloc (PHP 7.1). finally s’exécute qu’une exception ait été levée ou non. Rattrapez Throwable quand vous voulez vraiment tout, par exemple en tête de la boucle d’un worker.

Exceptions vérifiées et valeurs d’erreur

Une fonction PHP signale un échec en levant une exception ou en renvoyant null. Rien n’oblige l’appelant à gérer l’un ou l’autre, et rien dans la signature ne liste ce qui peut être levé. Si vous venez de Java, il n’y a pas de clause throws ni de vérification à la compilation ; un docblock @throws est une courtoisie lue par votre IDE et par PHPStan ou Psalm, pas par le moteur. Si vous venez de Go ou de Rust, il n’y a ni valeur de retour d’erreur ni type Result dans le langage. Quelques bibliothèques en proposent un, mais le PHP idiomatique ne s’en sert pas.

Le type de retour nullable plus ?? est l’idiome du « peut-être » :

<?php
declare(strict_types=1);

function findUser(int $id): ?array
{
    return $id === 1 ? ['name' => 'Ada'] : null;
}

$name = findUser(2)['name'] ?? 'anonymous';
echo $name, PHP_EOL; // anonymous

La règle courante est de renvoyer null quand l’absence est normale et de lever une exception quand elle ne l’est pas. Comme throw est une expression (PHP 8.0), les deux se combinent sur une ligne :

$user = findUser($id) ?? throw new RuntimeException("No user $id");

Les exceptions personnalisées transportent des données

Une exception personnalisée est une classe, donc elle peut porter un contexte typé et offrir un constructeur nommé qui compose le message pour vous :

<?php
declare(strict_types=1);

final class InsufficientFunds extends DomainException
{
    public function __construct(
        public readonly int $requested,
        public readonly int $available,
        ?Throwable $previous = null,
    ) {
        parent::__construct(
            "Requested $requested, only $available available",
            previous: $previous,
        );
    }

    public static function forWithdrawal(int $requested, int $available): self
    {
        return new self($requested, $available);
    }
}

try {
    throw InsufficientFunds::forWithdrawal(100, 40);
} catch (InsufficientFunds $e) {
    echo $e->available, PHP_EOL; // 40
}

L’argument previous sert à chaîner. Rattrapez une exception de bas niveau, enveloppez-la dans une exception qui a un sens pour votre appelant, et passez l’originale en previous. getPrevious() remonte la chaîne, et tous les loggers l’affichent, donc rien ne se perd.

try {
    $pdo->query($sql);
} catch (PDOException $e) {
    throw new RuntimeException('Order lookup failed', previous: $e);
}

L’autre mécanisme

Avant l’existence des exceptions, PHP signalait les problèmes en émettant une erreur d’un niveau donné (notice, warning, fatal) et, pour tout ce qui n’était pas fatal, continuait. L’essentiel de cette machinerie a été replié dans des exceptions Error au fil des ans : une division par zéro lève, un argument du mauvais type lève, un appel de méthode sur null lève. Quelques situations émettent encore un warning et continuent : lire une variable non définie, une clé de tableau absente, une propriété non définie, et toute notice de dépréciation.

<?php
declare(strict_types=1);

$config = [];
echo $config['debug']; // Warning: Undefined array key "debug"
echo 'still running', PHP_EOL;

Ce « still running » est précisément ce qu’un développeur venu d’un autre langage n’attend pas. Le remède est un gestionnaire d’erreurs, installé à l’amorçage, qui transforme chaque erreur moteur en exception, et c’est ce que font tous les frameworks :

<?php
declare(strict_types=1);

error_reporting(E_ALL);

set_error_handler(function (int $severity, string $message, string $file, int $line): bool {
    throw new ErrorException($message, 0, $severity, $file, $line);
});

$config = [];
echo $config['debug']; // ErrorException: Undefined array key "debug"

ErrorException est une exception intégrée qui se souvient de la sévérité. À partir de là, il n’y a plus qu’un chemin d’échec, et try le rattrape en entier.

Quelques réglages accompagnent ce gestionnaire. error_reporting(E_ALL) garantit que rien n’est filtré. display_errors vaut On en développement et Off en production, où les erreurs partent dans le journal : une exception non rattrapée sur une page publique ne doit jamais afficher une trace. set_exception_handler() reçoit tout ce qui atteint le sommet sans avoir été rattrapé, et c’est là que vous journalisez et affichez une page d’erreur générique. PHP 8.5 ajoute get_error_handler() et get_exception_handler() pour qu’une bibliothèque puisse inspecter ce qui est installé avant de l’envelopper.

Ce qui ne se rattrape pas

Les erreurs fatales terminent la requête sans qu’aucun catch ne les voie : mémoire épuisée, max_execution_time dépassé, même classe déclarée deux fois. Une erreur de syntaxe dans un fichier inclus, en revanche, est une ParseError que vous pouvez rattraper depuis PHP 7. S’il faut réagir, register_shutdown_function() s’exécute après l’arrêt du script, et error_get_last() vous dit si l’arrêt était propre. Depuis PHP 8.5, une erreur fatale affiche une trace d’appels, et une mémoire épuisée en production pointe enfin vers une ligne.

L’opérateur @ et assert()

Vous croiserez @ dans du code ancien : @file_get_contents($url). Il réduit au silence tout warning émis par l’expression. Votre gestionnaire d’erreurs est toujours appelé, mais error_reporting() y renvoie un masque réduit, ce qui permet au gestionnaire de savoir que @ a été utilisé. Considérez cet opérateur comme un signal d’alerte quand vous le croisez. Le seul usage défendable entoure une fonction qui émet un warning et renvoie false en cas d’échec, immédiatement suivi d’un test sur cette valeur de retour. Même là, un try autour d’une alternative qui lève une exception se lit mieux.

assert() mérite aussi d’être reconnu. C’est une vérification de développement, retirée en production quand zend.assertions vaut -1 dans php.ini, la valeur recommandée pour la production. Servez-vous-en pour des invariants qui documentent une intention, jamais pour valider une entrée.

Le piège

Les deux erreurs classiques sont silencieuses. La première consiste à rattraper Exception dans un gestionnaire de haut niveau et à croire que l’on a tout rattrapé, alors qu’une TypeError est une Error et non une Exception, et qu’elle passe donc tout droit devant ce bloc. À la frontière de l’application, c’est Throwable qu’il faut rattraper.

La seconde est le catch vide :

try {
    $cache->delete($key);
} catch (Throwable) {
}

La variable peut être omise (PHP 8.0), ce qui rend le bloc honnête sur le fait qu’il ignore l’exception, et il y a des cas où ignorer est le bon choix. Mais un catch vide autour de quoi que ce soit d’important est la façon la plus sûre de cacher un bug pendant un an, alors journalisez au minimum ce que vous ignorez.

Tout ce qui tourne mal doit vous parvenir sous la forme d’une exception, en un seul endroit. PHP le fait, à condition de le lui demander.

Ce gestionnaire, et chaque classe que vous levez, vivent dans des fichiers que PHP doit trouver. Namespaces, Composer et autoloading explique comment il les trouve.

Namespaces, Composer et autoloading

PHP n’a pas de système de modules, mais trois mécanismes plus modestes, require, les espaces de noms et un crochet d’autoloading, que Composer assemble en un gestionnaire de paquets comparable à npm, pip, Maven ou Cargo. Vous n’écrirez plus jamais de require pour l’une de vos propres classes, et il reste utile de savoir ce que Composer fait à votre place.

Les trois primitives

require 'file.php'; lit et exécute un fichier, une fois par appel. C’est ainsi que le code se partageait en 2005, et c’est encore ainsi que tout s’amorce aujourd’hui, avec un unique require de vendor/autoload.php en tête de votre point d’entrée.

Un espace de noms est un préfixe sur un nom de classe. namespace App\Billing; en tête d’un fichier fait de chaque classe qui y est déclarée une App\Billing\Something, et n’apporte rien d’autre, aucune hiérarchie, aucune visibilité, aucun lien avec un dossier. App\Billing n’est pas « dans » App, ce sont simplement deux chaînes qui partagent un préfixe.

Le crochet d’autoloading est la pièce qui rend les deux premières utiles. Quand PHP rencontre une classe qu’il n’a jamais vue, il appelle une fonction que vous avez enregistrée, en lui passant le nom de la classe, et cette fonction est censée faire un require du bon fichier, après quoi PHP réessaie.

<?php
declare(strict_types=1);

spl_autoload_register(function (string $class): void {
    $file = __DIR__ . '/src/' . str_replace('\\', '/', $class) . '.php';
    if (is_file($file)) {
        require $file;
    }
});

$invoice = new App\Billing\Invoice(); // loads src/App/Billing/Invoice.php

Le mécanisme se résume à cette closure, et Composer en écrit une meilleure version, avec un cache, qu’il vous remet.

PSR-4 : du nom au chemin

La règle que suit la closure ci-dessus porte un nom, PSR-4, et Composer l’applique à partir d’un bloc de composer.json :

{
    "name": "acme/shop",
    "type": "project",
    "require": {
        "php": "^8.4",
        "ext-intl": "*"
    },
    "require-dev": {
        "phpunit/phpunit": "^12.0"
    },
    "autoload": {
        "psr-4": { "App\\": "src/" }
    },
    "autoload-dev": {
        "psr-4": { "App\\Tests\\": "tests/" }
    }
}

App\Billing\Invoice vit dans src/Billing/Invoice.php : une classe par fichier, un nom de fichier égal au nom de la classe, et des dossiers qui reprennent les segments de l’espace de noms après le préfixe. L’arborescence qui en résulte est la même sur tous les projets PHP modernes que vous ouvrirez :

shop/
├── composer.json
├── composer.lock
├── public/
│   └── index.php        # require __DIR__ . '/../vendor/autoload.php';
├── src/
│   └── Billing/
│       └── Invoice.php  # namespace App\Billing;
├── tests/
│   └── Billing/
│       └── InvoiceTest.php
└── vendor/              # generated, not committed

Ajoutez une classe sous src/, et elle est trouvée à la requête suivante, sans commande à lancer, puisque PSR-4 résout par chemin au moment de l’appel. La stratégie plus ancienne classmap parcourt les dossiers pour en faire un tableau généré, et réclame un composer dump-autoload après chaque nouveau fichier ; vous la rencontrerez dans les projets anciens.

Composer, dans le vocabulaire que vous connaissez

composer.json joue le rôle de votre package.json, composer.lock celui du fichier de verrouillage, vendor/ celui de node_modules, généré et ignoré par Git, et Packagist celui du registre public.

composer init                          # interactive composer.json
composer require monolog/monolog       # add and install, updates the lock
composer require --dev phpstan/phpstan # development-only dependency
composer install                       # reproduce exactly what the lock says
composer update                        # resolve anew, rewrite the lock
composer update monolog/monolog        # ... for one package only
composer show                          # what is installed, with versions
composer outdated                      # what has a newer release
composer audit                         # known vulnerabilities in the lock
composer dump-autoload -o              # regenerate the autoloader, optimised

install obéit à composer.lock, tandis qu’update le réécrit. En CI et en production vous lancez install, et vous obtenez exactement les versions que votre collègue a testées. Committez composer.lock pour une application ; pour une bibliothèque, la plupart des auteurs ne le font pas, afin qu’elle soit testée avec ce que ses utilisateurs résolvent, et c’est le même débat que dans tous les autres écosystèmes.

Les contraintes de version suivent semver, et ^8.4 signifie « 8.4 ou toute 8.x ultérieure ». L’entrée php de require est une contrainte elle aussi ; avec config.platform.php vous figez la version contre laquelle Composer résout, pour qu’un développeur sous PHP 8.5 ne tire pas un paquet que votre production en 8.4 ne peut pas exécuter.

Les scripts vivent sous une clé scripts et se lancent avec composer run nom ou comme crochets de cycle de vie (post-install-cmd), à la manière des scripts npm. Les extensions ne sont pas des paquets : ext-intl dans require vérifie seulement que l’extension est présente, et l’installer est le travail de votre gestionnaire de paquets système, de PECL ou de PIE. Les outils que vous installeriez globalement ailleurs (linters, analyseurs) vont dans require-dev, pour que chaque développeur et la CI utilisent la même version ; composer global require existe et il vaut mieux le laisser de côté. Un monorepo déclare ses paquets internes comme dépôts path, et Composer crée des liens symboliques.

Vivre avec les espaces de noms

Dans un fichier, une instruction use importe un nom pour que vous puissiez l’écrire court. Les alias résolvent les collisions, et les fonctions comme les constantes peuvent aussi être importées :

<?php
declare(strict_types=1);

namespace App\Billing;

use App\Customer\Customer;
use DateTimeImmutable as Date;
use function App\Support\money;
use const App\Support\CURRENCY;

final class Invoice
{
    public function __construct(
        public readonly Customer $customer,
        public readonly Date $issuedOn,
    ) {
    }

    public function total(): string
    {
        return money(1999, CURRENCY);
    }
}

echo Invoice::class, PHP_EOL; // App\Billing\Invoice

Invoice::class donne le nom pleinement qualifié sous forme de chaîne, ce qui est ce que vous passez à un conteneur, à un mock ou aux vérifications instanceof qui prennent une chaîne. Un antislash initial, comme dans \DateTimeImmutable, nomme une classe de l’espace de noms global sans passer par use.

Les fonctions se rabattent sur l’espace de noms global, alors que les classes ne le font pas. Appeler strlen() dans App\Billing cherche d’abord App\Billing\strlen, puis strlen, tandis qu’appeler new DateTimeImmutable() sans use ni antislash initial échoue. Vous verrez \strlen() dans certaines bibliothèques, parce que l’antislash saute la recherche et laisse OPcache inliner quelques fonctions intégrées ; c’est une micro-optimisation, pas une convention que vous ayez à adopter.

Les standards à connaître

Le PHP-FIG est le groupe où les auteurs de frameworks et de bibliothèques s’accordent sur des interfaces, publiées sous forme de PSR. Une PSR est un contrat plutôt qu’une bibliothèque : les implémentations viennent de nombreux éditeurs, et vous pouvez en remplacer une par une autre parce que votre code ne voit que l’interface. Voici celles que vous croiserez dès la première semaine :

• PSR-4, l’autoloading, ci-dessus.
• PER Coding Style, successeur de PSR-12 : placement des accolades, indentation, nommage. PHP-CS-Fixer ou PHP_CodeSniffer le font respecter.
• PSR-3, LoggerInterface. Toutes les bibliothèques journalisent à travers elle ; vous branchez le logger de votre choix.
• PSR-7, PSR-15 et PSR-17 : objets requête et réponse HTTP, middlewares, et leurs fabriques. Les $_GET et header() du langage sont traités dans Une requête web, sans framework ; PSR-7 est le modèle objet que les bibliothèques partagent par-dessus.
• PSR-11, ContainerInterface, pour qu’une bibliothèque puisse demander un service à n’importe quel conteneur.
• PSR-14, la distribution d’événements, PSR-6 et PSR-16, le cache.

Une bibliothèque qui type son constructeur contre Psr\Log\LoggerInterface fonctionne dans tous les frameworks cités dans ce livre. Cette interopérabilité explique pourquoi l’écosystème compte moins de forks et de réécritures que sa taille ne le laisserait penser.

Le piège

Ne modifiez jamais un fichier de vendor/. Le prochain composer install sur n’importe quelle machine efface la modification, et personne ne saura pourquoi la production diffère de votre portable. Forkez le paquet, ou surchargez la classe par votre propre entrée d’autoloading, ou envoyez le correctif en amont.

Le second piège est plus discret : vous ajoutez une classe, PHP dit qu’elle n’existe pas, et vous passez vingt minutes à chercher une faute de frappe qui n’existe pas. Comparez l’espace de noms au dossier : App\Billing\Invoice doit être src/Billing/Invoice.php, lettre pour lettre, casse comprise sous Linux. Si le projet utilise classmap plutôt que psr-4, lancez composer dump-autoload et passez à autre chose.

Composer n’est pas une étape de build, puisqu’il n’y a rien à compiler, à empaqueter ni à transpiler : après composer install, le code s’exécute tel quel.

Une fois les classes trouvées et les paquets installés, il reste la bibliothèque standard sur laquelle vous vous appuierez chaque jour, et Chaînes, nombres, dates et JSON en fait le tour.

Chaînes, nombres, dates et JSON

PHP est livré avec une grande bibliothèque standard, faite de fonctions bien plus que de méthodes. Vous n’appelez pas $s.upper() mais strtoupper($s), parce qu’il n’y a ni classe String, ni classe Number, ni receveur : les valeurs entrent en arguments et les résultats sortent en valeurs de retour. Une fois cette convention acceptée, la bibliothèque est vaste, rapide, et documentée fonction par fonction sur php.net, où chaque page donne la signature, le journal des changements par version, et des exemples qui valent la lecture.

Les noms, en revanche, sont incohérents : strlen voisine avec str_replace, array_key_exists prend la clé en premier là où in_array prend l’aiguille en premier, strpos et array_search renvoient false en cas d’échec alors que preg_match renvoie 0. C’est le résidu de trente ans de croissance, et il ne disparaîtra pas. L’autocomplétion de votre éditeur et la page php.net sont le remède, bien plus que la mémorisation, et au bout d’une semaine vous ne remarquez plus ces écarts.

Les chaînes sont des octets

Une chaîne PHP est une suite d’octets, et non de points de code ou de graphèmes. Il en découle que strlen('é') vaut 2, que strrev('héllo') massacre l’accent, et que substr peut couper un caractère multi-octets en deux.

<?php
declare(strict_types=1);

$word = 'café';

echo strlen($word), PHP_EOL;      // 5
echo mb_strlen($word), PHP_EOL;   // 4
echo strtoupper($word), PHP_EOL;  // CAFé
echo mb_strtoupper($word), PHP_EOL; // CAFÉ

Pour tout texte qu’un humain lira, utilisez la famille mb_ : mb_strlen, mb_substr, mb_strtoupper, mb_str_pad, et depuis PHP 8.4 mb_trim, mb_ucfirst et mb_lcfirst. Elles supposent UTF-8 par défaut, et les fonctions nues restent utiles pour ce pour quoi elles ont été conçues : données binaires, protocoles ASCII, hachages, et tout ce qui se compte vraiment en octets.

Pour tout ce qui dépend de la langue de l’utilisateur, l’extension intl enveloppe ICU : Normalizer pour ramener formes composées et décomposées à une forme canonique, Collator pour trier « é » à côté de « e » selon la langue du lecteur, NumberFormatter pour les devises et les pluriels, IntlDateFormatter pour des dates écrites comme un lecteur français ou japonais les attend.

Les utilitaires du quotidien sont ceux de n’importe quel langage, avec des noms PHP :

<?php
declare(strict_types=1);

$path = '/var/log/app.log';

var_dump(str_contains($path, 'log'));      // true (PHP 8.0)
var_dump(str_starts_with($path, '/var'));  // true
var_dump(str_ends_with($path, '.log'));    // true

echo implode(', ', ['a', 'b', 'c']), PHP_EOL;    // a, b, c
print_r(explode('/', trim($path, '/')));         // ['var', 'log', 'app.log']
echo str_pad('7', 3, '0', STR_PAD_LEFT), PHP_EOL; // 007
echo ucfirst('php'), PHP_EOL;                    // Php
echo sprintf('%05.2f|%-6s|%03d', 3.14159, 'ok', 7), PHP_EOL; // 03.14|ok    |007
echo number_format(1234567.891, 2), PHP_EOL;     // 1,234,567.89

sprintf est celui du C, printf affiche au lieu de renvoyer, et number_format est ce que vous utilisez avant de découvrir NumberFormatter.

Deux syntaxes gèrent le texte sur plusieurs lignes. Le heredoc interpole, le nowdoc non, et les deux retirent l’indentation du marqueur de fin :

<?php
declare(strict_types=1);

$name = 'Ada';

$greeting = <<<TXT
    Hello, {$name}.
    Welcome back.
    TXT;

$raw = <<<'TXT'
    Hello, {$name}. This stays literal.
    TXT;

echo $greeting, PHP_EOL, $raw, PHP_EOL;

Expressions régulières

PHP utilise PCRE, le même dialecte que Perl et proche de ce qu’acceptent le module re de Python et JavaScript. Le motif est une chaîne entre délimiteurs, en général / ou ~, suivis de modificateurs. Ajoutez le modificateur u dès que le texte est en UTF-8, sans quoi . correspond à un seul octet et \w ignore les lettres accentuées.

<?php
declare(strict_types=1);

$line = 'Order #4521 shipped to Zoé on 2026-03-14';

if (preg_match('/#(?<id>\d+).*on (?<date>\d{4}-\d{2}-\d{2})/u', $line, $m)) {
    echo $m['id'], ' ', $m['date'], PHP_EOL; // 4521 2026-03-14
}

echo preg_replace('/\s+/u', ' ', "too   many\n\nspaces"), PHP_EOL;

echo preg_replace_callback(
    '/\d+/',
    fn (array $m): string => (string) ($m[0] * 2),
    'a1 b22 c333',
), PHP_EOL; // a2 b44 c666

preg_match renvoie 1, 0, ou false si le motif est mal formé. Les groupes nommés se retrouvent dans le tableau de résultat sous leur nom. preg_split, preg_quote et preg_match_all complètent la famille.

Les nombres

int est un entier signé sur 64 bits, et quand il déborde, PHP bascule silencieusement en float, sans exception ni retour à zéro. Ce comportement convient à un compteur et devient faux pour un identifiant ou un montant.

<?php
declare(strict_types=1);

var_dump(PHP_INT_MAX + 1);    // float(9.223372036854776E+18)
var_dump(intdiv(7, 2));       // int(3)
var_dump(7 / 2);              // float(3.5), division always yields float unless exact
var_dump(7 % 2);              // int(1)
var_dump(2 ** 10);            // int(1024)
var_dump(fdiv(1, 0));         // float(INF), where 1 / 0 throws DivisionByZeroError

var_dump(0.1 + 0.2 === 0.3);                             // false
var_dump(abs(0.1 + 0.2 - 0.3) < PHP_FLOAT_EPSILON);      // true
var_dump(round(2.5), round(3.5), round(-2.5));           // 3, 4, -3: half away from zero

Les flottants sont des doubles IEEE 754, avec les réserves habituelles. round arrondit par défaut la moitié en s’éloignant de zéro et accepte une constante de mode pour l’arrondi bancaire. L’argent, c’est soit des entiers dans la plus petite unité (les centimes), soit de la précision arbitraire : bcadd, bcmul et consorts travaillent sur des chaînes, et PHP 8.4 les enveloppe dans BcMath\Number, un objet immuable qui accepte les opérateurs.

// PHP 8.4
$price = new BcMath\Number('19.99');
$total = $price * 3;
echo $total, PHP_EOL; // 59.97

Pour l’aléatoire, rand() et mt_rand() sont rapides mais prévisibles. Tout ce qui touche à la sécurité passe par random_int, random_bytes ou la classe Random\Randomizer (PHP 8.2), adossés au générateur cryptographique du système d’exploitation.

<?php
declare(strict_types=1);

echo random_int(1, 6), PHP_EOL;                 // a fair die
echo bin2hex(random_bytes(16)), PHP_EOL;        // 32 hex chars, a fine token

$r = new Random\Randomizer();
echo $r->getInt(1, 100), PHP_EOL;
print_r($r->shuffleArray([1, 2, 3, 4]));
echo $r->getBytesFromString('abcdef0123456789', 8), PHP_EOL; // PHP 8.3

Les dates

Utilisez DateTimeImmutable plutôt que DateTime. Les deux existent et partagent une interface, mais la version mutable est un piège : $date->modify('+1 day') modifie $date sur place et le renvoie, donc chaque référence à cet objet se décale avec lui. La version immuable renvoie un nouvel objet et laisse l’original tranquille, comme vous l’attendez de java.time en Java ou de datetime en Python.

<?php
declare(strict_types=1);

date_default_timezone_set('UTC');

$start = new DateTimeImmutable('2026-03-14 09:30', new DateTimeZone('Europe/Paris'));
$end = $start->modify('+2 weeks')->setTime(18, 0);

echo $start->format(DateTimeInterface::ATOM), PHP_EOL; // 2026-03-14T09:30:00+01:00
echo $end->format('D, d M Y H:i'), PHP_EOL;            // Sat, 28 Mar 2026 18:00

$diff = $start->diff($end);
echo $diff->days, ' days, ', $diff->h, ' hours', PHP_EOL; // 14 days, 8 hours

$parsed = DateTimeImmutable::createFromFormat('d/m/Y', '01/07/2026');
echo $parsed->getTimestamp(), PHP_EOL;

$inTokyo = $start->setTimezone(new DateTimeZone('Asia/Tokyo'));
echo $inTokyo->format('H:i T'), PHP_EOL; // 17:30 JST

foreach (new DatePeriod($start, new DateInterval('P1D'), 3) as $day) {
    echo $day->format('l'), PHP_EOL; // Saturday, Sunday, Monday, Tuesday
}

L’analyseur derrière new DateTimeImmutable('...') et modify() accepte des expressions en anglais ('next monday', 'first day of last month') et toutes les formes ISO courantes. DateInterval utilise les durées ISO 8601 (P1Y2M3DT4H). Le fuseau par défaut vient de php.ini ; le régler sur UTC au début du point d’entrée et convertir aux frontières est la pratique habituelle. Les codes de format sont propres à PHP (Y-m-d H:i:s), pas ceux de strftime, dépréciée en 8.1.

JSON

json_encode et json_decode sont intégrés et rapides. Passez JSON_THROW_ON_ERROR à chaque fois, sans quoi un échec renvoie false ou null et vous le découvrez trois fonctions plus loin.

<?php
declare(strict_types=1);

$payload = ['id' => 4521, 'tags' => ['php', 'json'], 'total' => 59.97, 'note' => null];

$json = json_encode($payload, JSON_THROW_ON_ERROR | JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
echo $json, PHP_EOL;

$asArray = json_decode($json, true, flags: JSON_THROW_ON_ERROR);   // nested arrays
$asObject = json_decode($json, flags: JSON_THROW_ON_ERROR);        // stdClass objects
echo $asArray['tags'][0], ' ', $asObject->tags[1], PHP_EOL;         // php json

var_dump(json_validate('{"ok": true}')); // true (PHP 8.3), without building the tree

Le deuxième argument de json_decode choisit entre tableaux associatifs et stdClass. Les tableaux sont ce que la plupart du code attend. Les objets de vos propres classes se sérialisent via l’interface JsonSerializable : implémentez jsonSerialize(): mixed et renvoyez la forme de tableau voulue. Le sens inverse, JSON vers objet typé, n’est pas dans le langage ; bibliothèques et frameworks s’en chargent.

Un écueil mérite sa propre phrase, et Les tableaux explique pourquoi : un tableau dont les clés ne sont pas 0, 1, 2... s’encode en objet JSON et non en liste. Comme array_filter laisse des trous et que json_encode les voit, votre API renvoie {"0": ..., "2": ...} là où vous attendiez une liste, à moins de passer le tableau dans array_values() avant de l’encoder.

Les grands entiers survivent à l’aller-retour tant qu’ils tiennent sur 64 bits ; au-delà, décodez avec JSON_BIGINT_AS_STRING. Les flottants s’écrivent avec jusqu’à 17 chiffres significatifs par défaut (serialize_precision), donc 0.1 reste 0.1.

Fichiers et flux

file_get_contents et file_put_contents lisent ou écrivent un fichier entier en un appel, et acceptent des URL et des enveloppes de flux aussi bien que des chemins. Pour travailler ligne par ligne, il y a le trio à la C fopen/fgets/fclose, ou SplFileObject, qui est itérable :

<?php
declare(strict_types=1);

$path = __DIR__ . '/notes.txt';
file_put_contents($path, "one\ntwo\nthree\n");

foreach (new SplFileObject($path) as $n => $line) {
    if ($line !== '') {
        echo $n, ': ', rtrim($line), PHP_EOL;
    }
}

$stdin = fopen('php://stdin', 'r');
$buffer = fopen('php://memory', 'r+');
fwrite($buffer, 'scratch');
rewind($buffer);
echo fread($buffer, 100), PHP_EOL;

__DIR__ est le dossier du fichier courant ; sans lui, les chemins relatifs se résolvent par rapport au répertoire de travail, qui sous un serveur web est rarement celui que vous croyez. Les enveloppes php:// exposent les flux standard, des tampons mémoire et des fichiers temporaires à travers les mêmes fonctions que les vrais fichiers, et file_get_contents('https://...') fonctionne quand allow_url_fopen est activé, même si pour du vrai HTTP vous voudrez curl ou un client PSR-18.

Validation, hachage, URI

filter_var valide et assainit des scalaires avec un jeu de filtres intégrés, sans dépendance :

<?php
declare(strict_types=1);

var_dump(filter_var('ada@example.org', FILTER_VALIDATE_EMAIL)); // the string, or false
var_dump(filter_var('42', FILTER_VALIDATE_INT));                // int(42)
var_dump(filter_var('yes', FILTER_VALIDATE_BOOL, FILTER_NULL_ON_FAILURE)); // true

$hash = password_hash('correct horse battery staple', PASSWORD_DEFAULT);
var_dump(password_verify('correct horse battery staple', $hash)); // true
echo hash('sha256', 'payload'), PHP_EOL;

password_hash choisit l’algorithme, génère le sel et encode le tout dans une seule chaîne, que password_verify relit. Ces deux fonctions couvrent l’ensemble de la question des mots de passe, et PASSWORD_DEFAULT migre vers des algorithmes plus solides au fil des versions sans que vous changiez une ligne. hash couvre le reste, de sha256 à xxh3, et hash_hmac signe.

Depuis PHP 8.5, les URL passent par un vrai analyseur plutôt que par l’approximatif parse_url :

// PHP 8.5
$uri = new Uri\Rfc3986\Uri('https://example.org:8443/docs/intro?lang=fr#top');
echo $uri->getHost(), ' ', $uri->getPort(), ' ', $uri->getPath(), PHP_EOL;
// example.org 8443 /docs/intro

Uri\WhatWg\Url, dans la même extension, applique les règles des navigateurs plutôt que celles de la RFC, pour les cas où vous devez tomber d’accord avec ce que fera un <a href>.

Telle est la partie de la bibliothèque standard que vous toucherez au cours d’une semaine ordinaire. La question suivante est ce que PHP vous donne quand l’entrée n’est plus une chaîne dans une variable mais une requête HTTP, et Une requête web, sans framework y répond sans la moindre bibliothèque.

Une requête web, sans framework

PHP peut servir une page web sans bibliothèque, sans code serveur et sans configuration, parce que traiter une requête HTTP est ce pour quoi le langage a été conçu. La requête est déjà analysée quand votre script démarre, et la réponse est ce que vous affichez. Un framework ajoute de la structure par-dessus, mais il n’ajoute pas la capacité.

Avoir vu une fois cette couche brute rend ensuite chaque framework lisible, parce qu’ils reposent tous sur exactement ces primitives.

Le contrôleur frontal

Pointez le serveur de développement de PHP sur un seul fichier, et chaque URL passe par lui :

php -S localhost:8000 public/index.php

Ce fichier est le contrôleur frontal. En production, le serveur web fait la même chose avec une règle de réécriture (ou FrankenPHP et RoadRunner le font pour vous, comme le décrit Comment PHP s’exécute). Avec le serveur de développement, un détail compte : si le script renvoie false, le serveur sert le fichier demandé depuis le disque, et c’est ainsi que passent les ressources statiques.

<?php
declare(strict_types=1);

$path = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);

if ($path !== '/' && is_file(__DIR__ . $path)) {
    return false; // let the built-in server send the CSS or image
}

echo 'Every other URL lands here: ', htmlspecialchars($path, ENT_QUOTES);

Lire la requête

La requête vit dans les superglobales, des tableaux que PHP remplit avant la première ligne de votre code. $_GET contient la chaîne de requête, $_POST les champs d’un formulaire soumis, $_COOKIE les cookies, $_FILES les fichiers envoyés, et $_SERVER tout le reste : REQUEST_METHOD, REQUEST_URI, et chaque en-tête HTTP sous la forme HTTP_ suivi de son nom en majuscules, de sorte que Accept-Language devient $_SERVER['HTTP_ACCEPT_LANGUAGE'].

<?php
declare(strict_types=1);

$method = $_SERVER['REQUEST_METHOD'];
$page = filter_input(INPUT_GET, 'page', FILTER_VALIDATE_INT) ?: 1;
$name = trim($_POST['name'] ?? '');
$lang = $_SERVER['HTTP_ACCEPT_LANGUAGE'] ?? 'en';

$body = json_decode(file_get_contents('php://input'), true, flags: JSON_THROW_ON_ERROR);

$_POST n’est rempli que pour les corps application/x-www-form-urlencoded et multipart/form-data envoyés en POST. Un corps JSON, quelle que soit la méthode, se lit brut depuis php://input. Un formulaire envoyé en PUT ou PATCH n’est pas analysé du tout, sauf si vous le demandez : request_parse_body() (PHP 8.4) renvoie les champs et les fichiers pour ces méthodes aussi.

Rien dans ces tableaux n’est digne de confiance. HTTP_HOST est ce que le client a envoyé, REQUEST_URI peut contenir n’importe quoi, et un champ attendu comme chaîne arrive sous forme de tableau si le client écrit name[]=x. Traitez chaque valeur comme une entrée utilisateur non typée, validez-la avec filter_var ou vos propres vérifications, et seulement ensuite laissez-la approcher votre logique.

Écrire la réponse

Tout ce que votre script affiche est le corps de la réponse, qu’il s’agisse d’un echo, d’un print ou de texte placé hors des balises <?php ?>. Le statut et les en-têtes se règlent avec deux fonctions, à appeler avant le premier octet de sortie, parce que les en-têtes voyagent en premier :

<?php
declare(strict_types=1);

http_response_code(201);
header('Content-Type: application/json; charset=utf-8');
header('Cache-Control: no-store');
setcookie('theme', 'dark', [
    'expires' => time() + 86400 * 30,
    'path' => '/',
    'secure' => true,
    'httponly' => true,
    'samesite' => 'Lax',
]);

echo json_encode(['created' => true], JSON_THROW_ON_ERROR);

Affichez quoi que ce soit avant, même un saut de ligne égaré devant <?php, et header() échoue avec « headers already sent ». La mise en tampon de la sortie (ob_start() au début, ob_end_flush() à la fin) retient le corps en mémoire jusqu’à la fin du script et rend l’ordre indifférent ; c’est ce que font les frameworks.

Les gabarits sont du PHP

PHP a commencé comme langage de gabarits, et il l’est toujours : un fichier HTML avec des <?= $expr ?> dedans est un gabarit, et un include suffit à l’afficher. La seule règle porte sur la sortie : échappez chaque valeur avec htmlspecialchars avant qu’elle n’atterrisse dans le HTML, sinon le premier utilisateur nommé <script> est propriétaire de votre page.

<?php
declare(strict_types=1);

function e(string $value): string
{
    return htmlspecialchars($value, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
}

$todos = ['Write the chapter', 'Escape <everything>'];
?>
<ul>
<?php foreach ($todos as $todo): ?>
    <li><?= e($todo) ?></li>
<?php endforeach; ?>
</ul>

La forme foreach (...): ... endforeach; existe précisément pour cet entrelacement. Un utilitaire e() de deux lignes est toute l’histoire de l’échappement pour le HTML ; les attributs, les URL et les contextes JavaScript demandent chacun leur propre encodage, et c’est la partie que les moteurs de gabarits automatisent.

Une application complète

L’application ci-dessous fonctionne telle quelle, en un seul fichier : une liste de notes stockées dans SQLite, avec un formulaire pour en ajouter une. Elle tourne avec php -S localhost:8000 index.php et rien d’autre.

<?php
declare(strict_types=1);

$db = new PDO('sqlite:' . __DIR__ . '/notes.db', options: [
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);
$db->exec('CREATE TABLE IF NOT EXISTS notes (id INTEGER PRIMARY KEY, body TEXT NOT NULL)');

function e(string $value): string
{
    return htmlspecialchars($value, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
}

$route = $_SERVER['REQUEST_METHOD'] . ' ' . parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);

match ($route) {
    'GET /' => (function () use ($db): void {
        $notes = $db->query('SELECT id, body FROM notes ORDER BY id DESC')->fetchAll();
        echo '<h1>Notes</h1><form method="post" action="/notes">',
            '<input name="body" required> <button>Add</button></form><ul>';
        foreach ($notes as $note) {
            echo '<li>', e($note['body']), '</li>';
        }
        echo '</ul>';
    })(),
    'POST /notes' => (function () use ($db): void {
        $body = trim($_POST['body'] ?? '');
        if ($body === '') {
            http_response_code(422);
            echo 'A note needs a body.';
            return;
        }
        $stmt = $db->prepare('INSERT INTO notes (body) VALUES (:body)');
        $stmt->execute(['body' => $body]);
        http_response_code(303);
        header('Location: /');
    })(),
    default => (function (): void {
        http_response_code(404);
        echo 'Not found';
    })(),
};

Ce fichier illustre l’essentiel de ce qu’il y a à savoir. Le routeur est un match sur la méthode et le chemin, ce qui tient jusqu’à une dizaine de routes avant que vous n’en vouliez un vrai. PDO est l’API de base de données, une seule interface pour SQLite, MySQL, PostgreSQL et d’autres, et ERRMODE_EXCEPTION transforme chaque échec en PDOException levée plutôt qu’en false que vous oubliez de vérifier. La requête utilise un marqueur nommé et execute() lie la valeur ; le texte SQL et les données ne se rencontrent jamais sous forme de chaîne, donc aucune injection SQL à craindre. PHP 8.4 ajoute des sous-classes par pilote (Pdo\Sqlite, Pdo\Mysql, Pdo\Pgsql) via Pdo::connect(), qui exposent les spécificités de chaque pilote avec des types corrects.

Construire le SQL par interpolation, "WHERE id = $id", est la seule habitude des vieux tutoriels PHP que le langage vous laisse encore garder, et c’est précisément celle qu’il faut abandonner.

Sessions et mots de passe

Une session est un stockage côté serveur indexé par un cookie. Appelez session_start() avant toute sortie, et $_SESSION devient un tableau qui survit d’une requête à l’autre pour ce visiteur. Par défaut, les données vivent dans des fichiers sur le serveur ; les frameworks y substituent une base de données ou un cache via session_set_save_handler(). Le cookie ne transporte que l’identifiant de session.

<?php
declare(strict_types=1);

session_start();

if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $ok = password_verify($_POST['password'] ?? '', $storedHash ?? '');
    if ($ok) {
        session_regenerate_id(true);
        $_SESSION['user_id'] = 42;
    }
}

$csrf = $_SESSION['csrf'] ??= bin2hex(random_bytes(32));

password_hash et password_verify, vus dans Chaînes, nombres, dates et JSON, suffisent pour les mots de passe, à condition de régénérer l’identifiant de session à la connexion. Pour la protection CSRF, mettez un jeton aléatoire dans la session, imprimez-le en champ caché dans chaque formulaire, et comparez-le à la soumission avec hash_equals() ; cela tient en quatre lignes, et chaque framework fait la même chose sous un nom plus flatteur.

La couche des standards

Les superglobales et header() fonctionnent, mais c’est de l’état global, ce qui rend le code difficile à tester et impossible à composer. Le PHP-FIG a répondu par des interfaces :

• PSR-7 définit des objets immuables RequestInterface et ResponseInterface, de sorte qu’une requête est une valeur que vous passez et une réponse une valeur que vous renvoyez.
• PSR-15 définit l’intergiciel (middleware) : un gestionnaire prend une requête et renvoie une réponse, et un middleware enveloppe des gestionnaires. Authentification, CORS, journalisation, limitation de débit sont chacun une classe.
• PSR-17 définit les fabriques qui créent ces objets, pour qu’une bibliothèque ne dépende jamais d’une implémentation précise.
• PSR-18 définit un client HTTP, le côté sortant des mêmes objets.

Une bibliothèque écrite contre PSR-7 et PSR-15 tourne dans tout framework qui les parle, c’est-à-dire aujourd’hui la plupart. CakePHP, Laminas, Laravel, Symfony et Yii, et les micro-frameworks Mezzio et Slim, ajoutent chacun routage, injection de dépendances, gabarits et couche de base de données par-dessus ces primitives ; les primitives en dessous sont celles que vous venez de voir.

En production, le contrôleur frontal reste le même, et seul change ce qui l’appelle : PHP-FPM derrière nginx, Apache ou Caddy, ou un runtime persistant comme FrankenPHP ou RoadRunner. Rien dans ce chapitre n’a besoin d’être adapté à l’un ou à l’autre.

L’application ci-dessus n’a ni tests ni analyse statique, et Tests, analyse statique et outillage y remédie.

Tests, analyse statique et outillage

Un projet PHP maintenu lance quatre outils à chaque commit : un lanceur de tests, un analyseur statique, un correcteur de style de code, et l’audit intégré à Composer. Aucun de ces outils n’est livré avec le langage, mais tous s’installent avec un seul composer require --dev et se lancent depuis vendor/bin/. Si vous avez déjà utilisé pytest avec mypy, ou Jest avec tsc et Prettier, vous connaissez la forme de cette chaîne et il ne vous reste que les noms à apprendre.

Ce chapitre nomme deux outils pour chaque tâche, non par indécision, mais parce que les deux sont largement utilisés et bons, et que le projet que vous venez de rejoindre a de toute façon déjà choisi le sien.

Les tests

Deux lanceurs de tests dominent l’écosystème. PHPUnit est le lanceur de style xUnit sur lequel tous les autres outils de test PHP s’appuient, et Pest est une couche describe-et-it posée sur le moteur de PHPUnit. Ils partagent les assertions, les mocks, la configuration et la machinerie de couverture, et ne diffèrent que par la façon dont un test se lit.

La fonction à tester :

<?php
declare(strict_types=1);

namespace App;

function slugify(string $title): string
{
    $slug = strtolower(trim($title));
    $slug = preg_replace('/[^a-z0-9]+/', '-', $slug);

    return trim($slug, '-');
}

Une fonction dans un espace de noms n’est pas une classe, donc PSR-4 ne peut pas la trouver : le fichier va dans une entrée files du bloc autoload de composer.json, et Composer le charge avec require à chaque exécution.

Le même test, PHPUnit d’abord :

<?php
declare(strict_types=1);

namespace App\Tests;

use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\TestCase;
use function App\slugify;

final class SlugifyTest extends TestCase
{
    #[Test]
    public function itLowercasesAndJoinsWithDashes(): void
    {
        self::assertSame('hello-world', slugify('Hello World'));
    }

    #[Test]
    #[DataProvider('edgeCases')]
    public function itHandlesEdgeCases(string $input, string $expected): void
    {
        self::assertSame($expected, slugify($input));
    }

    public static function edgeCases(): iterable
    {
        yield 'leading punctuation' => ['!!Hi', 'hi'];
        yield 'empty' => ['', ''];
        yield 'unicode is stripped' => ['café', 'caf'];
    }
}

Puis Pest :

<?php
declare(strict_types=1);

use function App\slugify;

it('lowercases and joins with dashes', function () {
    expect(slugify('Hello World'))->toBe('hello-world');
});

it('handles edge cases', function (string $input, string $expected) {
    expect(slugify($input))->toBe($expected);
})->with([
    'leading punctuation' => ['!!Hi', 'hi'],
    'empty' => ['', ''],
    'unicode is stripped' => ['café', 'caf'],
]);

Lancez-les avec vendor/bin/phpunit ou vendor/bin/pest. La configuration vit dans phpunit.xml à la racine du projet, et Pest lit le même fichier : on y déclare quels dossiers contiennent les tests, s’il faut échouer sur un warning, et quelles variables d’environnement définir.

Les conventions PHPUnit à connaître dès le premier jour : une classe de test se termine par Test et étend TestCase, une méthode de test porte l’attribut #[Test] ou commence par test, setUp() s’exécute avant chaque test, self::assertSame() est l’assertion stricte (il existe un assertEquals(), qui jongle avec les types comme ==, donc préférez assertSame()), et $this->createMock(SomeInterface::class) renvoie un double de test que vous configurez avec ->method('name')->willReturn($value).

La couverture n’est pas intégrée au langage et demande une extension qui observe quelles lignes s’exécutent, soit Xdebug (avec xdebug.mode=coverage), soit PCOV, qui ne fait que de la couverture et le fait plus vite. Dans les deux cas, vendor/bin/phpunit --coverage-text affiche le rapport.

Le test unicode ci-dessus documente un bug : slugify('café') supprime le é au lieu de le translittérer. Un test qui fige le comportement actuel reste un test utile, et vous corrigerez la fonction plus tard avec le Transliterator d’intl.

L’analyse statique

PHP vérifie les types à l’exécution, un appel à la fois, et il ne vous dira donc jamais qu’une fonction située trois fichiers plus loin peut renvoyer null sans que vous le gériez. PHPStan et Psalm jouent le rôle du compilateur que PHP n’a pas : ils lisent toute la base de code, suivent chaque type à travers chaque appel, et signalent ce qui échouerait avant que quoi que ce soit ne s’exécute, comme mypy le fait pour Python ou le vérificateur de types de tsc pour TypeScript.

<?php
declare(strict_types=1);

function findUser(int $id): ?User
{
    return $id === 1 ? new User('Ada') : null;
}

echo findUser(2)->name;

PHP exécute ce code et plante sur la seconde ligne avec « Attempt to read property on null », alors que les deux analyseurs le refusent avant même de l’exécuter :

Cannot access property $name on User|null.

Les deux outils fonctionnent par niveaux : PHPStan va de 0 (erreurs évidentes seulement) à 10 (chaque mixed doit être précisé), et Psalm compte dans l’autre sens, de 8 (permissif) à 1 (strict). Un nouveau projet démarre au niveau le plus strict qu’il peut tenir et n’en redescend jamais, tandis qu’un projet ancien génère une baseline, un fichier qui liste toutes les erreurs actuelles pour que seules les nouvelles fassent échouer le build, puis la réduit au fil du temps.

Un phpstan.neon minimal :

parameters:
    level: 8
    paths:
        - src
        - tests

Les deux outils lisent les docblocks pour ce que le langage ne sait pas exprimer : @param list<int> $ids, @return array<string, User>, et les génériques @template présentés dans Le système de types. C’est dans ces docblocks que vivent les génériques en PHP : le moteur les ignore et l’analyseur les fait respecter.

Le style de code

PER Coding Style, publié par le PHP-FIG, est le guide de style de référence. Il a succédé à PSR-12, qui avait succédé à PSR-2, et tous les frameworks et la plupart des bibliothèques le suivent : quatre espaces, accolades sur leur propre ligne pour les classes et les fonctions, sur la même ligne pour les structures de contrôle, une classe par fichier. Vous n’avez pas à l’apprendre par cœur, puisqu’un outil l’applique pour vous.

PHP-CS-Fixer réécrit les fichiers pour respecter un jeu de règles. PHP_CodeSniffer signale les violations avec phpcs et corrige ce qu’il peut avec phpcbf. Les deux acceptent PER en une ligne de configuration. Pour PHP-CS-Fixer, .php-cs-fixer.dist.php :

<?php
declare(strict_types=1);

$finder = PhpCsFixer\Finder::create()->in([__DIR__ . '/src', __DIR__ . '/tests']);

return (new PhpCsFixer\Config())
    ->setRules(['@PER-CS' => true])
    ->setFinder($finder);

Pour PHP_CodeSniffer, phpcs.xml :

<?xml version="1.0"?>
<ruleset name="project">
    <rule ref="PSR12"/>
    <file>src</file>
    <file>tests</file>
</ruleset>

Choisissez-en un et lancez-le en CI, ce qui met fin aux discussions sur le placement des accolades en revue de code.

Les migrations

Rector réécrit votre code vers une version plus récente de PHP, ou d’un framework, automatiquement. Il sait que Foo $x = null doit devenir ?Foo $x = null, qu’un switch qui renvoie une valeur est un match, qu’un constructeur qui affecte des propriétés peut les promouvoir. Donnez-lui une version cible et il fait la partie mécanique d’une migration :

<?php
declare(strict_types=1);

use Rector\Config\RectorConfig;
use Rector\ValueObject\PhpVersion;

return RectorConfig::configure()
    ->withPaths([__DIR__ . '/src', __DIR__ . '/tests'])
    ->withPhpVersion(PhpVersion::PHP_84)
    ->withPreparedSets(deadCode: true, codeQuality: true);

vendor/bin/rector --dry-run montre le diff. Sans l’option, il l’applique. Le chapitre Revenir à PHP après des années est, en pratique, la liste de ce que Rector fera au code que vous avez laissé derrière vous.

Le débogage

var_dump($value) affiche une valeur avec son type sans interrompre l’exécution, et var_dump($value); exit; reste le débogueur le plus rapide qui soit. Les frameworks ajoutent un dump() et un dd() (dump and die) plus agréables à lire, mais celui du langage a l’avantage de marcher partout.

Xdebug est le seul débogueur pas à pas de l’écosystème. Une fois l’extension installée et xdebug.mode=debug placé dans php.ini, votre éditeur s’arrête sur les points d’arrêt, montre la pile et vous laisse inspecter les variables, dans les requêtes web comme dans les scripts CLI. C’est une extension réservée au développement, parce qu’elle ralentit tout : les builds de production s’en passent, et quand il vous faut de la vitesse en local, php -d xdebug.mode=off script.php la désactive le temps d’une exécution.

Côté éditeurs, PhpStorm intègre le langage et VS Code a besoin d’une extension PHP. Les deux lisent les mêmes docblocks que les analyseurs, donc les génériques que vous écrivez pour PHPStan ou Psalm alimentent aussi l’autocomplétion.

Relier le tout

Les scripts Composer donnent au projet un vocabulaire unique, quels que soient les outils choisis. Dans composer.json :

{
    "scripts": {
        "test": "phpunit",
        "lint": "php-cs-fixer fix --dry-run --diff",
        "lint:fix": "php-cs-fixer fix",
        "analyse": "phpstan analyse",
        "check": ["@lint", "@analyse", "@test"]
    }
}

composer check lance les trois. Composer place vendor/bin dans le chemin des scripts, donc les noms d’outils n’ont pas besoin de préfixe. Un nouveau membre de l’équipe lit composer.json et sait comment le projet est vérifié sans ouvrir de README.

La CI lance les mêmes commandes, sur chaque version de PHP que le projet prend en charge (la contrainte php de composer.json dit lesquelles), plus composer audit, qui confronte composer.lock à la base des vulnérabilités connues et échoue à la première trouvée. composer outdated liste ce qui a une version plus récente ; un robot de mise à jour des dépendances peut ouvrir les pull requests pour vous.

Pour un runtime local, php -S localhost:8000 -t public sert le projet comme l’a montré Une requête web, sans framework, et l’image Docker officielle php:8.5-cli donne à tout le monde le même interpréteur. N’importe quel réglage de php.ini peut être surchargé pour une commande avec php -d memory_limit=1G. Sachez enfin que les fichiers .env sont une convention de bibliothèques, que plusieurs paquets chargent dans l’environnement, et non quelque chose que PHP lit de lui-même.

Le piège

Les deux erreurs classiques tiennent au moment où l’on fait les choses.

La première consiste à écrire des tests qui touchent la base de données par défaut : ils passent sur la machine de l’auteur, prennent des minutes en CI, et finissent par ne plus être lancés. Testez la fonction, passez la dépendance par le constructeur, et gardez les tests d’intégration dans leur propre dossier avec leur propre suite dans phpunit.xml, pour qu’ils s’exécutent quand on le décide.

La seconde consiste à lancer l’analyse statique à la fin du projet. Une base de code qui atteint le niveau 8 dès le premier jour y reste sans y penser, alors qu’une base de code qui rencontre PHPStan après deux ans l’accueille avec quatre mille erreurs et une baseline que personne ne réduit. Ajoutez l’analyseur au premier commit, au niveau le plus élevé qui passe, et montez-le dès que c’est possible.

Une fois les outils en place, il reste la question que tout développeur polyglotte pose la première semaine, celle de l’asynchrone, et Concurrence et performance y répond.

Concurrence et performance

PHP est synchrone : un processus exécute une requête, bloque à chaque appel d’entrée-sortie, et ce comportement est voulu. Il n’y a pas de boucle d’événements à alimenter, pas de mot-clé async à écrire, pas de goroutine à lancer, parce que la concurrence vient de l’extérieur du processus : le pool FPM fait tourner autant de copies de votre script que vous en avez configurées, chacune seule dans sa mémoire, et le système d’exploitation les répartit sur les cœurs.

Si vous venez de Node, cela ressemble à un retour en arrière, mais la comparaison ne tient pas. Node a besoin d’une boucle d’événements parce qu’un seul processus sert toutes les connexions, si bien qu’un seul appel bloquant les figerait toutes. PHP a donné à chaque requête son propre processus, donc un appel bloquant ne coûte rien que quiconque puisse voir : une requête en base qui prend 40 millisecondes occupe un worker pendant 40 millisecondes, et les autres workers ne s’en aperçoivent pas.

Ce que vous n’avez pas

Il n’y a pas de threads côté utilisateur. Une extension parallel existe pour les builds thread-safe (ZTS), et presque personne ne s’en sert. Le build standard est NTS, non thread-safe, parce que le modèle sans état partagé n’a jamais eu besoin de threads.

Il n’y a pas non plus d’ordonnanceur intégré. Les Fibers (PHP 8.1) sont des coroutines à pile : une fonction peut se suspendre, et celui qui détient la fiber peut la reprendre plus tard, sans que rien dans le langage ne décide du moment de la reprise ni ne multiplexe les sockets. Une fiber est une brique de base, et les bibliothèques asynchrones s’en servent pour qu’un code d’apparence ordinaire puisse céder la main au milieu d’un appel bloquant.

<?php
declare(strict_types=1);

$fiber = new Fiber(function (string $greeting): string {
    $name = Fiber::suspend('who is there?');

    return "$greeting, $name";
});

$question = $fiber->start('Hello');   // runs until suspend()
echo $question, PHP_EOL;              // who is there?

$fiber->resume('Ada');                // runs to the return
echo $fiber->getReturn(), PHP_EOL;    // Hello, Ada

Vous lirez du code comme celui-ci dans une bibliothèque, mais vous ne l’écrirez pas dans une application. L’équivalent Python serait une coroutine à base de générateurs comme on en écrivait avant asyncio, c’est-à-dire le mécanisme sans le runtime.

Quand vous avez vraiment besoin d’asynchrone

Certaines charges ne rentrent pas dans le modèle « une requête, un processus » : un serveur websocket qui tient dix mille connexions inactives, du long polling, un crawler qui fait cent appels HTTP sortants à la fois. Pour celles-là, PHP a des runtimes asynchrones, et ce sont des bibliothèques, pas des fonctionnalités du langage. Par ordre alphabétique : AMPHP, ReactPHP, et Swoole ou son fork OpenSwoole, qui est une extension. Les deux premiers sont du PHP pur bâti sur les fibers et la sélection de flux ; Swoole apporte sa propre boucle d’événements en C.

Les runtimes worker de Comment PHP s’exécute, FrankenPHP et RoadRunner, sont une autre réponse à une autre question : ils gardent votre application amorcée entre les requêtes, toujours une requête à la fois par worker. Ils suppriment le coût de démarrage, mais ils ne rendent pas votre code concurrent.

Avant de vous tourner vers l’un d’eux, demandez-vous si le problème est vraiment la concurrence, parce qu’une application web classique n’en a jamais besoin et que dix workers FPM de plus ne coûtent qu’une ligne de configuration.

Le travail en arrière-plan

Une requête dispose de trente secondes et doit envoyer une réponse, donc tout ce qui prend plus longtemps, ou tout ce que l’utilisateur n’attend pas, doit sortir de la requête.

L’idiome consiste à associer une file d’attente et un worker. La requête dépose un travail (une ligne dans une table, un message dans un broker) et rend la main. Un script CLI, lancé par un superviseur de processus, boucle indéfiniment en tirant les travaux et en les exécutant. Il n’a ni limite de temps ni limite de mémoire à moins que vous ne les fixiez, donc fixez-les : memory_limit dans l’ini, et un compteur qui sort proprement après quelques milliers de travaux pour que le superviseur relance un processus neuf. Une fuite mémoire dans une boucle sans fin est le seul cas où le nettoyage par requête de PHP ne vous sauve pas.

Cron couvre le cas planifié. La CLI a le reste de la boîte à outils : proc_open() lance un sous-processus avec des tubes, pcntl_fork() duplique le processus courant (CLI seulement, jamais sous FPM), et curl_multi_exec() effectue des requêtes HTTP en parallèle sans la moindre bibliothèque :

<?php
declare(strict_types=1);

$urls = ['https://example.com/a', 'https://example.com/b', 'https://example.com/c'];
$multi = curl_multi_init();
$handles = [];

foreach ($urls as $url) {
    $handle = curl_init($url);
    curl_setopt($handle, CURLOPT_RETURNTRANSFER, true);
    curl_multi_add_handle($multi, $handle);
    $handles[$url] = $handle;
}

do {
    $status = curl_multi_exec($multi, $running);
    if ($running) {
        curl_multi_select($multi);
    }
} while ($running && $status === CURLM_OK);

foreach ($handles as $url => $handle) {
    echo $url, ': ', strlen((string) curl_multi_getcontent($handle)), " bytes\n";
    curl_multi_remove_handle($multi, $handle);
}

Trois requêtes partent en même temps pour une seule attente, et c’est tout le parallélisme dont la plupart des scripts auront jamais besoin.

Où passe le temps

L’interpréteur est rarement le goulot d’étranglement. Une requête passe son temps à attendre la base de données, le cache, le système de fichiers et d’autres services. Optimiser une boucle qui tourne en deux millisecondes pendant qu’une requête SQL en prend quatre-vingts est l’erreur classique, et elle ne dépend pas du langage.

Le seul réglage qui compte est OPcache, décrit dans Comment PHP s’exécute. Assurez-vous qu’il est actif et que opcache.memory_consumption est assez grand pour toute la base de code (opcache_get_status() vous le dit). Deux raffinements viennent par-dessus :

• Le préchargement (opcache.preload=preload.php) compile une liste de fichiers une fois au démarrage de FPM et les garde liés en mémoire, si bien que les classes n’ont plus besoin d’autoloading du tout. Il faut un redémarrage pour prendre en compte les changements, et c’est pourquoi c’est un réglage de production.
• Le JIT compile les chemins chauds en code machine. Il accélère le travail gourmand en CPU, parfois beaucoup, et accélère très peu une requête web ordinaire. Activez-le (opcache.jit=tracing, opcache.jit_buffer_size=64M), mesurez, gardez-le s’il a aidé.

L’autoloading a un coût, et Composer peut en supprimer l’essentiel. composer dump-autoload -o génère une carte de classes pour qu’aucune recherche sur le système de fichiers n’ait lieu par classe ; --classmap-authoritative va plus loin et ne touche jamais au système de fichiers pour une classe absente de la carte. Les deux ont leur place dans le script de déploiement. realpath_cache_size dans l’ini, quelques mégaoctets, évite à PHP de résoudre à nouveau les chemins à chaque requête.

Mesurer

Rien de ce qui précède ne vaut la peine avant une mesure. Le langage fournit les deux primitives :

<?php
declare(strict_types=1);

$numbers = range(1, 1_000_000);

$start = hrtime(true);
$doubled = array_map(fn (int $n): int => $n * 2, $numbers);
$mapTime = hrtime(true) - $start;

$start = hrtime(true);
$doubled = [];
foreach ($numbers as $n) {
    $doubled[] = $n * 2;
}
$loopTime = hrtime(true) - $start;

printf("array_map: %.1f ms\n", $mapTime / 1e6);
printf("foreach:   %.1f ms\n", $loopTime / 1e6);
printf("peak memory: %.1f MB\n", memory_get_peak_usage() / 1e6);

Les deux mesures tombent dans les dizaines de millisecondes pour un million d’éléments, avec un écart faible qui dépend de la version de PHP. La leçon n’est pas de savoir lequel gagne, mais qu’un million d’itérations coûte moins qu’une seule requête SQL lente, ce qui vous laisse libre d’écrire la version la plus lisible.

Pour un vrai profil, Xdebug a un mode profileur (xdebug.mode=profile) qui écrit des graphes d’appels que votre éditeur peut ouvrir, et des profileurs par échantillonnage existent sous forme d’extensions pour la production, où le surcoût de Xdebug est inacceptable. Pointez l’un ou l’autre sur une requête lente et lisez le haut de la liste.

La mémoire suit la même règle. Une requête qui construit un tableau de cent mille lignes et meurt sur memory_limit a besoin d’un générateur, comme l’a montré Fonctions et closures, pas d’une limite plus haute. unset() libère une variable, et le ramasse-miettes gère seul les cycles de références ; gc_collect_cycles() force une passe, qu’un worker de longue durée peut appeler entre deux travaux.

Le piège

La première erreur consiste à importer un modèle de concurrence parce que le langage précédent en avait besoin. Un runtime asynchrone sous une application CRUD ajoute une couche, un jeu de bibliothèques qui doivent être compatibles avec les fibers, et une classe de bugs (l’état partagé entre les requêtes) que FPM rendait impossibles. Le gain est nul, parce que les requêtes ne s’attendaient jamais les unes les autres.

La seconde consiste à optimiser sans chiffre. L’option JIT, la carte de classes ou la boucle réécrite sont autant d’hypothèses, et seule une mesure avec hrtime() sur le chemin lent, avant et après, en fait des résultats.

Le runtime, le langage et les outils sont maintenant couverts, et il reste un lecteur à servir : Revenir à PHP après des années s’adresse au développeur dont le dernier PHP contenait encore mysql_query.

Revenir à PHP après des années

Vous avez écrit du PHP il y a des années, peut-être beaucoup, en 2008 ou en 2015 sur un projet qui était déjà vieux à l’époque. Vous vous souvenez de mysql_query, de array(), du require_once en tête de chaque fichier, et d’un langage qui laissait tout passer. Maintenant que vous y revenez, la première chose à savoir est que presque toutes les habitudes dont vous vous souvenez ont un remplaçant moderne, et que la plupart des anciennes formes sont dépréciées ou supprimées.

Ce chapitre est une liste de paires qui met en regard ce dont vous vous souvenez et ce que vous écrivez aujourd’hui. Le reste du livre détaille chaque remplaçant, et ce chapitre sert de carte pour s’y retrouver.

La base de données

Vous vous souvenez d’avoir assemblé du SQL à la main pour le passer à mysql_query(). Les fonctions mysql_* ont été supprimées en PHP 7.0, si bien que le code qui les appelle ne tourne sur aucune version encore maintenue du langage. Le remplaçant est PDO avec des requêtes préparées, ce qui referme au passage la faille d’injection que l’ancien style ouvrait :

<?php
declare(strict_types=1);

// then
// $result = mysql_query("SELECT * FROM users WHERE id = " . $_GET['id']);

// now
$pdo = new PDO('sqlite::memory:', options: [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]);
$stmt = $pdo->prepare('SELECT * FROM users WHERE id = :id');
$stmt->execute(['id' => (int) ($_GET['id'] ?? 0)]);
$user = $stmt->fetch(PDO::FETCH_ASSOC);

mysqli existe toujours et fonctionne très bien, mais PDO parle à toutes les bases avec une seule API. Une requête web, sans framework le montre en situation.

Charger le code

Vous vous souvenez d’un mur de lignes require_once, ou d’une fonction __autoload() maison. Aujourd’hui, une seule ligne charge tout : require __DIR__ . '/vendor/autoload.php';. Composer génère ce fichier à partir d’une correspondance espace de noms vers dossier déclarée dans composer.json, et __autoload() elle-même a été supprimée en 8.0. Les classes vivent à raison d’une par fichier, nommé d’après la classe, et sont trouvées à la première utilisation. Namespaces, Composer et autoloading décrit la mise en place, qui prend cinq minutes.

Composer a aussi remplacé l’habitude de copier une bibliothèque dans son projet. Depuis 2012, composer require vendor/package la récupère sur Packagist, fige la version dans un fichier de verrouillage, et la met à jour quand vous le demandez.

Une syntaxe qui a raccourci

Ce sont de petits changements, mais vous les verrez sur chaque ligne.

// then
$list = array(1, 2, 3);
$name = isset($_GET['n']) ? $_GET['n'] : 'anon';
$double = function ($x) use ($factor) {
    return $x * $factor;
};
$callback = array($obj, 'method');
call_user_func_array($callback, array(1));

// now
$list = [1, 2, 3];
$name = $_GET['n'] ?? 'anon';
$double = fn($x) => $x * $factor;
$callback = $obj->method(...);
$callback(1);

[] est arrivé en 5.4, ?? en 7.0, les fonctions fléchées fn en 7.4, et la syntaxe de callable de première classe $obj->method(...) en 8.1. Les callables sous forme de chaîne comme 'Class::method' et call_user_func() fonctionnent toujours ; plus personne ne les écrit, parce que la nouvelle forme est vérifiée par l’éditeur et par l’analyseur, et qu’un callable s’appelle tout simplement avec des parenthèses.

Les types

Vous vous souvenez de fonctions qui acceptaient n’importe quoi et renvoyaient ce qui venait. Aujourd’hui les fonctions déclarent leurs types, et une ligne par fichier oblige PHP à les faire respecter.

<?php
declare(strict_types=1);

// then
// function total($items, $rate) { ... }

// now
function total(array $items, float $rate): float
{
    return array_sum($items) * $rate;
}

total([10, 20], '1.2'); // TypeError: must be of type float, string given

Les types scalaires sont arrivés en 7.0, les types de retour avec eux, le nullable ?int en 7.1, les types union en 8.0, et les propriétés typées en 7.4. declare(strict_types=1) désactive la conversion silencieuse pour les appels faits depuis ce fichier. Le système de types donne les règles précises.

Flux de contrôle et constantes

Vous vous souvenez de switch, de son fallthrough et de sa comparaison lâche, et d’une classe remplie de const STATUS_ACTIVE = 'active';. match a remplacé le premier, les énumérations le second.

<?php
declare(strict_types=1);

enum Status: string
{
    case Active = 'active';
    case Archived = 'archived';
}

function label(Status $status): string
{
    return match ($status) {
        Status::Active => 'In use',
        Status::Archived => 'Put away',
    };
}

match (8.0) compare avec ===, ne traverse pas les branches, et lève une exception si aucune ne convient. Les énumérations (8.1) sont de vrais types : une fonction typée Status ne peut pas recevoir la chaîne 'deleted'. Énumérations et match va plus loin.

Les classes

Vous vous souvenez d’une propriété privée, d’un getter et d’un setter, multipliés par dix dans chaque classe. La promotion de propriétés dans le constructeur et readonly ramènent tout cela à une ligne par propriété.

<?php
declare(strict_types=1);

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

$price = new Money(1999, 'EUR');
echo $price->cents; // 1999
$price->cents = 0;  // Error: Cannot modify readonly property

La promotion est arrivée en 8.0, readonly en 8.1. Les hooks de propriété (PHP 8.4) couvrent le cas où un getter calculait vraiment quelque chose, en attachant des blocs get et set à la propriété elle-même. Les classes montre tout cela.

Parmi ce dont vous vous souvenez, deux pratiques sont désormais supprimées ou dépréciées. Les constructeurs à la PHP 4, où la méthode portait le nom de la classe, ont été supprimés en 8.0. Les propriétés dynamiques, affecter $obj->whatever sans l’avoir déclarée, sont dépréciées depuis 8.2 et doivent devenir une erreur dans la prochaine version majeure.

Les erreurs

Vous vous souvenez de @mysql_connect(...) or die('no db'), et d’avertissements imprimés au beau milieu de la page. Aujourd’hui les erreurs sont des exceptions, et vous les rattrapez. Les fonctions internes lèvent TypeError et ValueError au lieu de renvoyer false avec un avertissement, la division par zéro lève une exception, et les frameworks convertissent les avertissements restants en exceptions avec un gestionnaire d’erreurs. @ existe toujours, mais considérez-le comme le signe d’un problème à corriger. Erreurs et exceptions explique la hiérarchie.

Les globales

Vous vous souvenez de global $db; en tête de chaque fonction. Aujourd’hui la dépendance entre par le constructeur.

<?php
declare(strict_types=1);

final class UserRepository
{
    public function __construct(private readonly PDO $pdo)
    {
    }
}

L’objet qui a besoin d’une base de données en reçoit une, ce qui permet de le tester avec une autre. Les frameworks automatisent ce câblage avec un conteneur, mais l’idée elle-même n’en a pas besoin.

register_globals, qui transformait chaque paramètre de requête en variable, a été supprimé en 5.4. $_REQUEST existe toujours et personne ne s’en sert : lisez $_GET ou $_POST et dites lequel vous voulez. extract() et les variables variables ($$name) restent légales et n’apparaissent dans aucune base de code moderne.

Texte et dates

Vous vous souvenez de date('Y-m-d', $timestamp) et de utf8_encode(). Les dates sont des objets DateTimeImmutable, et le texte est en UTF-8 partout.

<?php
declare(strict_types=1);

$due = new DateTimeImmutable('2026-03-01', new DateTimeZone('UTC'));
echo $due->modify('+30 days')->format('Y-m-d'); // 2026-03-31

utf8_encode() et utf8_decode() n’ont jamais géré que le Latin-1 et sont dépréciées depuis 8.2 ; mb_convert_encoding() fait le travail pour n’importe quel encodage. ereg_* a été supprimé en 7.0, preg_* est resté. La forme ${var} d’interpolation dans les chaînes est dépréciée depuis 8.2 ; écrivez {$var}. Chaînes, nombres, dates et JSON a le reste.

Petites choses disparues

• each() et create_function(), supprimées en 8.0. Utilisez foreach et les closures.
• Le cast (unset), supprimé en 8.0.
• Les paramètres implicitement nullables, Foo $x = null sans le ?, dépréciés en 8.4. Écrivez ?Foo $x = null.
• split(), supprimée en 7.0. Utilisez explode() ou preg_split().
• mb_internal_encoding('UTF-8') en tête des fichiers. Le défaut est UTF-8 depuis 5.6.

Faire passer une base de code PHP 5 sur PHP 8

Elle ne tournera pas telle quelle, les appels mysql_* à eux seuls le garantissent. La partie mécanique, au moins, est automatisée : Rector réécrit l’ancienne syntaxe en syntaxe nouvelle, version par version, à partir d’une configuration qui nomme votre cible. Pointez-le sur le code, relisez le diff, lancez les tests que vous avez, espérons-le, et recommencez. PHPStan ou Psalm trouvent ensuite ce que Rector n’a pas pu faire. Tests, analyse statique et outillage présente les deux.

Prévoyez ce travail dans votre planning, car un site qui tourne encore sous PHP 5 aujourd’hui utilise une version qui ne reçoit plus de correctifs de sécurité depuis 2018, et il représente un risque avant même d’être une base de code.

Le rythme des versions

PHP publie désormais une version mineure chaque novembre : 8.0 en 2020, 8.1 en 2021, et ainsi de suite jusqu’à 8.5 en 2025. Chaque version reçoit deux ans de support actif puis deux ans de correctifs de sécurité ; php.net/supported-versions donne les dates. Une version par an, c’est une petite liste de dépréciations à lire chaque année, et une base de code qui ne s’éloigne jamais beaucoup du présent.

Jugez le langage sur ses notes de version plutôt que sur la base de code que vous retrouvez, parce que cette base de code est une photo de l’époque où elle a été écrite, alors que le langage a continué d’avancer.

Pour aller plus loin liste les endroits où vous tenir à jour.

Pour aller plus loin

Le livre s’arrête ici, mais le langage continue d’évoluer, et le projet qu’on vous a confié aussi. Quelques sources vous permettent de rester à jour, et aucune n’appartient à un éditeur commercial.

Le manuel

php.net est la référence, et une bonne référence : chaque fonction a sa page, avec sa signature, son historique par version, et des exemples qui tournent. Les notes contribuées par les utilisateurs sous chaque page sont inégales, alors que le texte officiel au-dessus est fiable. Mettez en favori les guides de migration, un par version (php.net/manual/fr/migration85.php et ses voisins) : ils listent chaque dépréciation et chaque nouveauté, et lire celui de la prochaine version de votre projet est la préparation de montée de version la moins chère que vous ferez.

Le wiki des RFC

Chaque changement du langage passe par une proposition publique, une discussion sur la liste de diffusion internals, et un vote des développeurs du cœur. Les propositions vivent sur wiki.php.net/rfc, acceptées, refusées et en cours. Lire les RFC acceptées d’une version vous dit non seulement ce qui a changé, mais pourquoi, avec les alternatives écartées et les arguments contre. Quand une fonctionnalité paraît étrange, sa RFC explique en général la contrainte qui l’a rendue ainsi.

La Fondation et le FIG

La PHP Foundation finance les développeurs du cœur qui maintiennent l’interpréteur et accompagne la direction du langage. Son blog rend compte des versions et des chantiers en cours. Le PHP-FIG (Framework Interoperability Group) publie les PSR et le PER Coding Style, les interfaces et conventions qui permettent à des bibliothèques d’auteurs différents de fonctionner ensemble. Quand une base de code mentionne PSR-quelque chose, le site du FIG a la spécification en deux pages.

Le framework de votre projet

La plupart des projets PHP reposent sur un framework, et la documentation du framework est l’endroit où l’apprendre. Frameworks complets : CakePHP, Laminas, Laravel, Symfony, Yii. Micro-frameworks bâtis autour des middlewares PSR-15 : Mezzio, Slim. Plateformes de contenu avec leurs propres conventions : Drupal, Joomla, TYPO3, WordPress.

Une habitude paie dès le premier jour : quand vous lisez du code de framework, triez ce que vous voyez entre ce qui relève du langage et ce qui relève du framework. Un constructeur promu readonly, une énumération dans un match ou une chaîne de ?-> sont du PHP, et ils veulent dire la même chose partout. Une façade, une liaison dans un conteneur de services ou un __call magique qui redirige vers un constructeur de requêtes appartiennent au framework, et c’est sa documentation qui les explique. Ceux qui confondent les deux finissent par croire que PHP est ce à quoi leur premier framework l’a fait ressembler.

Un chemin plus long

Ce livre a sauté les bases volontairement. Si vous voulez la version qui part de zéro, avec un petit jeu, un outil en ligne de commande et une application web construite sans framework, le volume compagnon, The PHP Book, prend ce chemin à un rythme plus lent, et il est publié depuis le même dépôt que celui-ci.

Au-delà de l’écrit, PHP a des groupes d’utilisateurs dans la plupart des grandes villes et des conférences sur la plupart des continents, et une salle pleine de gens qui ont déjà résolu le problème que vous allez rencontrer vaut largement l’après-midi qu’on y passe.

Ce que vous savez maintenant

Il y a deux ou trois heures, vous avez ouvert une base de code et vu des $this->, des :: et un modèle d’exécution que vous ne reconnaissiez pas. Vous savez maintenant comment PHP s’exécute, comment il type, comment il organise le code en paquets, et où il va vous surprendre, et l’ancienne réputation du langage a retrouvé sa place, dans le chapitre consacré au passé. Cette base de code est devenue lisible, et vous pouvez retourner la lire.

Annexes

Ces trois annexes sont des tables de référence, pour les moments où il vous faut un fait précis plutôt qu’un chapitre. A - Venir de Python, JavaScript ou Java fait correspondre les constructions que vous connaissez déjà à leur écriture PHP, une ligne chacune. B - PHP 8.0 à 8.5 en un coup d’œil liste ce que chaque version a apporté, pour que vous sachiez ce que le PHP de votre projet peut utiliser. C - Vocabulaire définit les mots qui reviennent dans les conversations PHP et nulle part ailleurs.

A - Venir de Python, JavaScript ou Java

Une ligne par construction, l’écriture que vous connaissez à gauche, l’écriture PHP moderne à droite. Quand PHP propose une ancienne forme et une nouvelle, seule la nouvelle figure ici.

Les différences qui ne sont pas qu’une question d’écriture

• Une requête part de rien et finit sans rien, parce qu’aucun processus ne reste en vie entre deux requêtes. Voir Comment PHP s’exécute.
• Les tableaux sont des valeurs : affecter ou passer un tableau en produit une copie, alors que les objets circulent par identifiant. Voir Les tableaux.
• Les closures capturent par valeur, au moment de leur création, et une modification ultérieure de la variable extérieure ne leur parvient pas. Voir Fonctions et closures.
• Le typage strict est un interrupteur par fichier : declare(strict_types=1) régit les appels faits depuis ce fichier, et seulement lui. Voir Le système de types.

B - PHP 8.0 à 8.5 en un coup d’œil

Cette annexe consacre une section à chaque version, avec les nouveautés principales seulement. Trouvez la version de votre projet, puis lisez vers le bas à partir de là pour voir ce que vous pouvez utiliser.

PHP 8.0, novembre 2020

• Arguments nommés : str_pad(string: 'a', length: 3).
• Attributs : #[Route('/home')], des métadonnées structurées lues par réflexion.
• Promotion de propriétés dans le constructeur : public function __construct(private int $x) {}.
• Types union : int|string $id.
• Expression match : comparaison stricte, pas de fallthrough, exhaustive.
• Opérateur nullsafe : $user?->address?->city.
• mixed et static comme types.
• throw comme expression : $x = $y ?? throw new Exception();.
• str_contains(), str_starts_with(), str_ends_with().
• Interface Stringable, implémentée automatiquement par toute classe qui définit __toString().
• WeakMap.
• Compilateur JIT, à l’intérieur d’OPcache.
• Comparaisons chaîne-nombre assainies : 0 == 'foo' vaut false.
• Virgule finale autorisée dans les listes de paramètres.
• Les fonctions internes lèvent TypeError et ValueError au lieu d’émettre un avertissement et de renvoyer null ou false.

PHP 8.1, novembre 2021

• Énumérations, pures et adossées : enum Suit: string { case Hearts = 'H'; }.
• Propriétés readonly : public readonly int $x.
• Syntaxe de callable de première classe : strlen(...).
• Fibers : des coroutines à pile, la brique de base des bibliothèques asynchrones.
• new dans les initialiseurs : public function __construct(private Logger $l = new NullLogger()) {}.
• Types intersection purs : Countable&Traversable.
• Type de retour never.
• Constantes de classe final.
• Dépliage de tableaux avec clés textuelles : [...$defaults, ...$options].
• array_is_list().
• Notation octale explicite : 0o16.

PHP 8.2, décembre 2022

• Classes readonly : final readonly class Point {}.
• Types en forme normale disjonctive : (A&B)|null.
• Types true, false et null autonomes.
• Propriétés dynamiques dépréciées ; #[\AllowDynamicProperties] réautorise une classe.
• #[\SensitiveParameter] pour masquer un argument dans les traces d’appel.
• Constantes dans les traits.
• Random\Randomizer et l’extension random.
• Cas d’énumération utilisables dans les expressions constantes.

PHP 8.3, novembre 2023

• Constantes de classe typées : const string NAME = 'x';.
• Attribut #[\Override] : le moteur vérifie qu’une méthode parente existe.
• json_validate().
• Accès dynamique aux constantes de classe : Foo::{$name}.
• Les propriétés readonly peuvent être réinitialisées dans __clone().
• Randomizer::getBytesFromString(), Randomizer::getFloat().
• Les indices négatifs de tableau se comportent de façon cohérente.
• mb_str_pad().

PHP 8.4, novembre 2024

• Hooks de propriété : public string $name { get => ...; set => ...; }.
• Visibilité asymétrique : public private(set) int $x.
• new sans parenthèses dans un chaînage : new Foo()->bar().
• Objets paresseux : ReflectionClass::newLazyGhost(), newLazyProxy().
• Attribut #[\Deprecated] pour votre propre code.
• array_find(), array_find_key(), array_any(), array_all().
• mb_trim(), mb_ltrim(), mb_rtrim(), mb_ucfirst(), mb_lcfirst().
• Nouvelle extension DOM avec un analyseur HTML5 : Dom\HTMLDocument.
• API objet pour BCMath : BcMath\Number.
• Sous-classes PDO par pilote : Pdo\Sqlite, Pdo\Mysql, Pdo\Pgsql, via Pdo::connect().
• request_parse_body() pour les corps de formulaire quelle que soit la méthode HTTP.
• Paramètres implicitement nullables (Foo $x = null sans ?) dépréciés.
• exit et die sont désormais des fonctions.

PHP 8.5, novembre 2025

• Opérateur pipe : $slug = $title |> trim(...) |> strtolower(...);.
• clone avec mise à jour de propriétés : clone($point, ['x' => 3]).
• Attribut #[\NoDiscard], qui avertit quand une valeur de retour est ignorée ; cast (void) pour le faire taire volontairement.
• array_first(), array_last().
• Closures et callables de première classe dans les expressions constantes (arguments d’attributs, valeurs par défaut, constantes).
• Attributs sur les constantes.
• Nouvelle extension uri : Uri\Rfc3986\Uri, Uri\WhatWg\Url.
• Les erreurs fatales incluent désormais une trace d’appel.
• get_error_handler(), get_exception_handler().
• #[\DelayedTargetValidation].
• Constante PHP_BUILD_DATE.
• L’opérateur d’exécution shell entre accents graves est déprécié.

Politique de support

Chaque version reçoit deux ans de support actif (corrections de bugs) suivis de deux ans de correctifs de sécurité seulement. Une version publiée en novembre 2025 est donc en support actif jusqu’à fin 2027 et corrigée jusqu’à fin 2029. Les dates bougent à chaque version, et php.net/supported-versions tient la table à jour. Faire tourner une version au-delà de sa fenêtre de sécurité est un risque, et mieux vaut le prendre en connaissance de cause que le découvrir après coup.

Trouver la version de votre projet

php -v affiche l’interpréteur que vous exécutez en local. composer.json déclare ce que le projet prend en charge sous require.php ("php": "^8.3"), et config.platform.php fige la version contre laquelle Composer résout, celle à croire quand les deux diffèrent. La production peut encore tourner sur autre chose, et seul un phpinfo() ou un php -v sur le serveur permet de trancher.

C - Vocabulaire

Cette annexe définit, en une ou deux phrases chacun, les mots qui reviennent dans les conversations PHP et rarement ailleurs.

SAPI. Server API : la couche qui relie l’interpréteur à ce qui l’exécute. La ligne de commande, PHP-FPM, mod_php et les runtimes embarqués sont tous des SAPI au-dessus du même moteur.

CLI. La SAPI en ligne de commande, invoquée par php file.php. Elle n’a par défaut ni limite de temps d’exécution ni limite de mémoire, contrairement aux SAPI web.

FPM. FastCGI Process Manager : un pool de processus PHP qui attendent les requêtes derrière un serveur web. La façon standard de servir PHP.

FastCGI. Le protocole par lequel le serveur web transmet une requête à FPM et relit la réponse.

mod_php. Le module Apache qui embarque PHP dans le processus du serveur web lui-même. Plus ancien que FPM, et toujours présent.

OPcache. Le cache de bytecode. Les fichiers compilés restent en mémoire partagée, et la requête suivante s’épargne l’analyse. Activé dans toute installation sérieuse.

JIT. Compilation à la volée du code chaud en code machine, à l’intérieur d’OPcache, depuis 8.0. Aide les scripts gourmands en CPU ; change peu de chose pour le trafic web ordinaire.

Preloading (préchargement). Une option d’OPcache qui compile et lie un ensemble de fichiers une fois au démarrage du serveur, pour que chaque requête commence avec eux déjà chargés.

APCu. Un cache mémoire partagé entre les processus PHP d’une même machine. Pour les valeurs calculées une fois et lues souvent, quand un stockage externe serait disproportionné.

Extension. Un module C compilé qui ajoute des fonctions ou des classes à PHP : pdo_mysql, intl, mbstring, xdebug. php -m liste celles qui sont chargées.

PECL. Le dépôt historique des extensions non livrées avec PHP, avec son propre installeur.

PIE. L’installeur d’extensions plus récent, dans l’esprit de Composer, appelé à succéder au circuit PECL.

ZTS et NTS. Les builds thread-safe et non-thread-safe de l’interpréteur. NTS est le défaut et celui qu’utilise FPM ; ZTS existe pour les rares SAPI multithreadées et l’extension parallel.

php.ini. Le fichier de configuration. La CLI et FPM en lisent des différents, ce qui explique la plupart des mystères du type « ça marche dans le terminal ».

Composer. Le gestionnaire de paquets. Lit composer.json, écrit composer.lock, remplit vendor/, génère l’autoloader.

Packagist. Le registre public de paquets où Composer s’approvisionne.

vendor. Le dossier où Composer installe les paquets, qu’on ne modifie jamais à la main et qu’on ne commite pas.

Autoload. Le mécanisme qui charge le fichier d’une classe à sa première utilisation, si bien qu’on n’écrit plus jamais une ligne require à la main.

PSR-4. La correspondance standard entre espace de noms et dossier que suivent les autoloaders : App\Billing\Invoice vit dans src/Billing/Invoice.php.

PHP-FIG. Framework Interoperability Group : l’organisme qui publie les PSR et le style de code.

PSR. PHP Standards Recommendation : une interface ou une convention numérotée (PSR-3 pour les logs, PSR-7 pour les messages HTTP, PSR-15 pour les middlewares) sur laquelle les bibliothèques s’accordent afin d’être interchangeables.

PER Coding Style. Le standard de style de code actuel du FIG, successeur de PSR-12. Ce que les formateurs font respecter.

RFC. Request for Comments : la proposition publique par laquelle passe tout changement du langage avant un vote des développeurs du cœur.

PHP Foundation. L’organisation à but non lucratif qui, depuis 2021, salarie des développeurs du cœur pour maintenir et faire avancer l’interpréteur.

php-src. Le dépôt source de l’interpréteur lui-même, écrit en C.

Zend Engine. Le cœur de l’interpréteur : le compilateur et l’exécuteur. Le nom survit dans quelques réglages et messages d’erreur.

Superglobal (superglobale). Un tableau intégré au langage, visible dans toutes les portées : $_GET, $_POST, $_SERVER, $_COOKIE, $_FILES, $_SESSION, $_ENV.

Docblock. Un commentaire /** ... */ au-dessus d’un symbole, portant des annotations @param et @return que lisent les éditeurs et les analyseurs statiques. C’est là que vivent les génériques.

Attribute (attribut). Des métadonnées structurées attachées à une classe, une méthode, une propriété ou un paramètre avec #[...], lues par réflexion. Ce que les annotations étaient en Java.

Trait. Un bloc de méthodes et de propriétés copié dans toute classe qui le use. De la réutilisation horizontale sans héritage.

Enum (énumération). Un type avec un ensemble fixe de cas nommés, éventuellement adossés à un entier ou une chaîne, avec méthodes et interfaces. Depuis 8.1.

Fiber. Une coroutine à pile qui peut se suspendre et reprendre depuis n’importe quel point de sa pile d’appels. La primitive sur laquelle s’appuient les bibliothèques asynchrones ; pas quelque chose que le code applicatif pilote directement.

Generator (générateur). Une fonction qui produit des valeurs une à une avec yield et conserve son état entre les appels. De l’itération paresseuse sans construire de tableau.

SPL. Standard PHP Library : l’ensemble intégré de structures de données, d’itérateurs, d’exceptions et d’interfaces tels que ArrayIterator, SplQueue, Countable, RuntimeException.

PDO. PHP Data Objects : l’abstraction de base de données avec une seule API pour tous les pilotes, requêtes préparées comprises.

mbstring. L’extension de chaînes multi-octets. mb_strlen, mb_substr et leurs semblables comptent des caractères là où les fonctions ordinaires comptent des octets.

intl. L’extension d’internationalisation : collation, formatage des nombres et des dates, normalisation Unicode, au-dessus de la bibliothèque ICU.

Xdebug. Le débogueur pas à pas et profileur, réservé au développement.

PHPUnit. Le framework de test de style xUnit avec lequel la plupart des tests PHP sont écrits.

Pest. Un framework de test à la syntaxe describe et expect, qui tourne sur le moteur de PHPUnit.

PHPStan. Un analyseur statique qui trouve les erreurs de type et le code impossible sans l’exécuter, avec des niveaux de 0 à 10.

Psalm. L’autre analyseur statique, avec des niveaux de 8 à 1 et un accent sur la solidité des types et l’analyse de souillure (taint analysis).

Rector. Un outil de refactoring automatisé qui réécrit le code vers une version plus récente de PHP ou une API de bibliothèque plus récente.

phpt. Le format des fichiers de test de l’interpréteur lui-même, dans php-src. Vous le croisez si vous contribuez à PHP ou lisez ses rapports de bug.

strict_types. La déclaration par fichier declare(strict_types=1); qui fait lever une exception, au lieu de convertir, sur les incompatibilités de types scalaires dans les appels faits depuis ce fichier.

Copy-on-write (copie à l’écriture). L’astuce du moteur qui rend l’affectation de tableaux bon marché : la copie partage la mémoire de l’original jusqu’à ce que l’un des deux soit modifié.

Late static binding (liaison statique tardive). static:: qui se résout vers la classe sur laquelle l’appel a été fait, pas celle où la méthode est écrite. self:: est l’autre.

Magic method (méthode magique). Une méthode au nom réservé à double tiret bas que le moteur appelle de lui-même : __construct, __toString, __get, __call, __clone, __invoke.