PHP 8.4 : rattrapage de retard ou véritable modernisation ?

Novembre 2024 marque la sortie de PHP 8.4 avec une version qui répare des choix de conception vieux de vingt ans. Les Property Hooks débarquent, la visibilité asymétrique devient réalité, et le parser HTML5 rejoint enfin l'ère moderne. Pour un langage qui alimente encore une large portion du web, ces améliorations arrivent tard mais tombent juste. Pas de révolution, juste du pragmatisme et du rattrapage intelligent.

Property Hooks

Les Property Hooks permettent de définir des getters et setters directement sur les propriétés. À la manière de C#, Kotlin, ou Swift. PHP rattrape quinze ans de retard en une release.

class User {
    // Avant PHP 8.4 : le cauchemar verbeux
    private string $name;
    
    public function getName(): string {
        return $this->name;
    }
    
    public function setName(string $value): void {
        $this->name = ucfirst($value);
    }
}

// Avec PHP 8.4 : direct au but
class User {
    public string $name {
        get => $this->name;
        set => ucfirst($value);
    }
}

La syntaxe est propre. Elle économise des lignes. Les développeurs qui migraient vers TypeScript pour ce genre de fonctionnalités vont devoir reconsidérer.

Visibilité asymétrique

Vous voulez exposer une propriété en lecture mais bloquer l'écriture externe ? PHP 8.4 vous écoute. La visibilité asymétrique fait exactement ça.

class Product {
    // Lecture publique, écriture privée
    public private(set) string $id;
    public private(set) float $price;
    
    public function __construct(string $id, float $price) {
        $this->id = $id;
        $this->price = $price;
    }
    
    public function applyDiscount(float $percentage): void {
        // OK : on est dans la classe
        $this->price *= (1 - $percentage / 100);
    }
}

$product = new Product('ABC123', 99.99);
echo $product->price; // OK : lecture publique
$product->price = 50; // Erreur : écriture privée

Cette fonctionnalité répond à un besoin réel. Protéger l'état interne sans sacrifier l'accessibilité. Le genre d'amélioration qui ne fait pas les gros titres mais qui change le quotidien du code.

Instanciation sans parenthèses

Détail qui compte : les parenthèses vides deviennent optionnelles lors de l'instanciation. PHP rejoint enfin la plupart des langages modernes.

// Avant : obligatoire
$result = (new QueryBuilder())->select('*')->from('users')->get();

// PHP 8.4 : optionnel
$result = new QueryBuilder()->select('*')->from('users')->get();

// Également valide pour les attributs
#[Route('/api/users')]
class UserController {}

Chaque caractère économisé compte. Chaque simplification syntaxique rend le langage plus accessible.

Nouvelles fonctions de tableaux

Les tableaux PHP ont une API historique. PHP 8.4 ajoute array_find(), array_any(), et array_all(). Des fonctions qui auraient dû exister depuis PHP 5.

$users = [
    ['name' => 'Alice', 'age' => 25],
    ['name' => 'Bob', 'age' => 30],
    ['name' => 'Charlie', 'age' => 35],
];

// array_find : premier élément qui correspond
$adult = array_find($users, fn($user) => $user['age'] >= 18);
// ['name' => 'Alice', 'age' => 25]

// array_any : au moins un élément correspond
$hasAdult = array_any($users, fn($user) => $user['age'] >= 18);
// true

// array_all : tous les éléments correspondent
$allAdults = array_all($users, fn($user) => $user['age'] >= 18);
// true

// Également : array_find_key pour récupérer la clé
$key = array_find_key($users, fn($user) => $user['name'] === 'Bob');
// 1

Parser HTML5

L'extension DOM intègre maintenant un parser HTML5 natif. Pour un langage historiquement lié au web, c'était une lacune embarrassante.

// Avant : DOMDocument parsait en XML/HTML4
$dom = new DOMDocument();
@$dom->loadHTML($html); // Le @ pour masquer les warnings

// PHP 8.4 : parser HTML5 natif
$dom = DOM\HTMLDocument::createFromString($html);
// Parse comme un navigateur moderne
// Gère les balises HTML5
// Pas de warnings pour du HTML valide

Cette mise à jour signifie que PHP peut enfin parser le HTML comme les navigateurs le font. Avec les spécifications actuelles. Le genre d'amélioration infrastructurelle qui ne se voit pas mais qui compte.

Autres améliorations notables

PHP 8.4 apporte son lot de corrections et d'optimisations. Rien de révolutionnaire, tout d'utile.

// PDO : nouvelle méthode pour obtenir le driver
$driver = $pdo->getDriver();

// BCMath : support des nombres comme objets
$num = new BcMath\Number('123.456');
$result = $num->add('78.9');

// Propriétés lazy : évaluation à la demande
class Report {
    public string $data {
        get {
            // Calculé seulement lors de l'accès
            return $this->generateExpensiveData();
        }
    }
}

Le mot de la fin

PHP 8.4 ne cherche pas à éblouir. Le langage avance par améliorations pragmatiques, comblant méthodiquement les lacunes qui handicapaient son usage au quotidien. Property Hooks, visibilité asymétrique, parser HTML5 : chaque ajout répond à un besoin concret, documenté par des années de frustration développeur.

Le langage reste critiqué, souvent déclaré obsolète. Pourtant il tient et il équipe toujours une part massive du web. Il évolue donc sans rupture, permettant aux millions de projets existants de progresser à leur rythme.

Cette version 8.4 illustre une approche : celle d'un langage qui assume son héritage tout en corrigeant ses erreurs. Alors pas de refonte totale, pas de belles promesses pour l'avenir avec des outils plus cohérents pour écrire du meilleur code.