PHP avancé pour développeurs confirmés

Typage strict, internals, gestion de la mémoire, concurrence et performance : le référentiel PHP de Codara couvre ce qui sépare un code qui fonctionne d’un code qui tient en production.

Typage avancé et génériques

PHP 8.4 étend le typage au-delà des types scalaires : union et intersection types, types DNF, propriétés et paramètres typés, génériques documentés via PHPDoc. L’analyse statique (PHPStan, Psalm) transforme ces annotations en contrôles réels au moment du développement. Un bon modèle de typage rend les états impossibles représentables et réduit la classe d’erreurs détectées trop tard.

/**
 * @template T
 * @param iterable<T> $items
 * @return list<T>
 */
function collect(iterable $items): array {
    return is_array($items) ? array_values($items) : iterator_to_array($items, false);
}

Mémoire, références et ramasse-miettes

PHP utilise un comptage de références complété par un cycle collector. Les fuites viennent rarement du moteur : elles naissent de références retenues (listeners statiques, caches par instance, closures capturant le contexte). Les générateurs permettent de traiter des volumes qui ne tiendraient pas en mémoire, à condition de consommer l’itération sans matérialiser la collection.

function readLines(string $path): \Generator {
    $handle = fopen($path, 'rb');
    try {
        while (($line = fgets($handle)) !== false) {
            yield rtrim($line, "\r\n");
        }
    } finally {
        fclose($handle);
    }
}

Comprendre les internals pour optimiser

Une string, un array et un objet n’ont pas le même coût : les arrays sont des hash maps ordonnées avec un coût de copie en écriture (`copy-on-write`), les objets sont manipulés par handle. Les opérations sur les arrays volumineux doivent éviter les copies implicites dans les boucles. `Opcache` compile le bytecode une fois et évite la phase de parsing à chaque requête ; un cache saturé se paie en recompilations constantes.

// Éviter : $big est copié à chaque itération si on le modifie
foreach ($big as &$value) {
    $value = normalize($value);
}
unset($value); // libérer la référence résiduelle

Concurrence sans framework : fibers et process

PHP reste un langage à thread unique, mais les Fibers offrent une suspension coopérative utile pour les I/O concurrentes dans une boucle d’événements. Pour le vrai parallélisme, `pcntl_fork` et `proc_open` restent les outils de référence, au prix d’une gestion explicite de l’état partagé. Le modèle dominant en production reste l’asynchrone par file de messages : des workers indépendants consomment des jobs sans partager de mémoire.

$fiber = new Fiber(function (): void {
    $result = http_get('https://api.example.com/jobs');
    Fiber::suspend($result);
});

$started = $fiber->start();
// I/O concurrentes possibles ici
$result = $fiber->resume();