Chapitre 2.8 — PHP ↔ TypeScript : le mémo de survie

Partie 2 : PHP moderne — Chapitre 8/8 Version de référence : PHP 8.4 pour Symfony 7.4.

⏱️ TL;DR

• Ce chapitre est une table de correspondance de référence : gardez-le sous la main pendant tout le cours.
• Les faux-amis à ne jamais oublier : . (pas +) pour concaténer ; === (jamais ==) ; typage nominal (pas structurel) ; pas d’async/await ; array = liste et map ; $this (pas this) ; ->/::.
• Les idiomes fonctionnels existent : array_map/array_filter/array_reduce ≈ map/filter/reduce, ... = spread, [$a, $b] = … = destructuring.
• JSON : json_encode / json_decode($s, true) ↔ JSON.stringify / JSON.parse.
• À la fin : vous lisez et écrivez du PHP moderne en traduisant mentalement depuis TypeScript, presque sans friction.

🎯 Objectifs

• Disposer d’une table de traduction TS → PHP réutilisable.
• Mémoriser les faux-amis qui piègent les devs JS.
• Traduire les idiomes courants (itération, transformation, JSON, dates).

1. Syntaxe de base

2. Fonctions

3. Types

4. Tableaux et objets (le grand piège)

En JS, [] (Array) et {} (Object) sont deux types. En PHP, array fait les deux :

Quand la donnée a une forme fixe et connue, préférez une classe/DTO (typée) à un array associatif « fourre-tout ». Réservez les arrays associatifs aux structures dynamiques.

5. Itération et transformation (fonctionnel)

⚠️ Piège : dans array_map($f, $arr), l’ordre des arguments est (fonction, tableau) — l’inverse de arr.map(f). Idem array_filter($arr, $f) prend (tableau, fonction). Ces incohérences historiques de l’ordre des paramètres sont la rançon de la vieille bibliothèque standard de PHP. En cas de doute, vérifiez la signature (l’IDE l’affiche).

6. Chaînes, JSON, dates

⚠️ Piège dates : préférez \DateTimeImmutable à \DateTime (mutable, source de bugs quand on le passe et qu’un code le modifie « à distance »). Symfony et Doctrine gèrent parfaitement l’immuable. Traitez DateTimeImmutable comme vous traiteriez une date immuable en TS.

7. Les 7 faux-amis à ne jamais oublier

1. Concaténation : . — jamais +.
2. Égalité : === — jamais ==.
3. Typage nominal : pour « compatible par contrat », implémenter l’interface.
4. Pas d’async/await : le différé passe par Messenger/workers.
5. array joue liste et dictionnaire ; pour une forme fixe, préférez un DTO.
6. $this (avec $), -> pour l’instance, :: pour le statique.
7. declare(strict_types=1); en tête de chaque fichier.

8. Un exemple de « traduction » complète

TypeScript :

interface Booking { id: number; email: string; status: "pending" | "confirmed" }
 
function activeEmails(bookings: Booking[]): string[] {
  return bookings
    .filter(b => b.status === "confirmed")
    .map(b => b.email);
}

PHP 8.4 :

declare(strict_types=1);
 
enum BookingStatus: string {
    case Pending = 'pending';
    case Confirmed = 'confirmed';
}
 
final readonly class Booking {
    public function __construct(
        public int $id,
        public string $email,
        public BookingStatus $status,
    ) {}
}
 
/**
 * @param Booking[] $bookings
 * @return string[]
 */
function activeEmails(array $bookings): array
{
    $confirmed = array_filter(
        $bookings,
        fn (Booking $b) => $b->status === BookingStatus::Confirmed,
    );
    return array_map(fn (Booking $b) => $b->email, $confirmed);
}

Même intention, mêmes idées ; seule la syntaxe change (et l’union de littéraux devient une enum, mieux typée). Vous savez maintenant faire ce va-et-vient dans les deux sens.

✏️ Exercices

Exercice 1. Traduisez en PHP 8.4 : const total = items.reduce((sum, i) => sum + i.price, 0); (où items est un tableau d’objets avec une propriété price: number).

$total = array_reduce(
    $items,
    fn (int $sum, Item $i) => $sum + $i->price,
    0,
);

Exercice 2. Repérez et corrigez les faux-amis dans ce code :

$parts = ['a', 'b'];
$joined = $parts[0] + '-' + $parts[1];
if ($user.role == 'admin') { echo "Bonjour ${user.name}"; }

$parts = ['a', 'b'];
$joined = $parts[0] . '-' . $parts[1];      // . pour concaténer, pas +
if ($user->role === 'admin') {              // -> pour l'objet, === strict
    echo "Bonjour {$user->name}";           // interpolation PHP : {$user->name}
}

Exercice 3. Donnez l’équivalent PHP de JSON.parse(body) puis, dans l’autre sens, de JSON.stringify({ ok: true }).

$data = json_decode($body, true);          // true → tableau associatif (sinon objet stdClass)
$json = json_encode(['ok' => true]);       // '{"ok":true}'

🧠 Quiz de révision

Fin de la Partie 2. Vous avez récupéré le langage : types, enums, attributs, classes modernes, Composer/PSR-4, erreurs, et la table de traduction TS→PHP. Le code Symfony ne vous paraîtra plus « exotique ».

Prochaine étape : Partie 3 — Installation & environnement de dev — on installe PHP 8.4, Composer, la Symfony CLI, on met en place Docker/FrankenPHP, et on crée le squelette de BookLab.