Le typage structurel, ou la forme avant le nom Structural typing, or shape before name

Un objet qui n'a jamais entendu parler du type. Et qui passe.An object that never heard of the type. And it passes.

Sept lignes que tout le monde écrit le premier jour. Elles compilent — et le fait qu'elles compilent, ici, n'est pas une tolérance : c'est tout le modèle de TypeScript qui tient dans un seul appel. La compatibilité se décide sur la forme, pas sur le nom.Seven lines everyone writes on day one. They compile — and that they compile, here, is no leniency: it's all of TypeScript's model fitting inside a single call. Compatibility is decided by shape, not by name.

interface Point { x: number; y: number }

function dist(p: Point) {
  return Math.hypot(p.x, p.y);
}

const here = { x: 3, y: 4, label: "home" };
dist(here);   // ✓ accepté — here n'a jamais entendu parler de Point

Ailleurs, il faut déclarer le lien. Ici, il suffit de l'avoir.Elsewhere you must declare the link. Here you just have it.

Quand on vient de Java ou de C#, « être d'un type » veut dire « avoir écrit implements quelque part ». Le lien est nominal : explicite, déclaré, vérifié par le nom. TypeScript prend le contre-pied — le lien n'est jamais déclaré, il est constaté sur la forme.Coming from Java or C#, 'being a type' means 'having written implements somewhere'. The link is nominal: explicit, declared, checked by name. TypeScript takes the opposite stance — the link is never declared, it's observed on the shape.

// Java / C# — typage nominal
interface Named { String name(); }

class Dog { String name() { return "Rex"; } }
//    ^ Dog ne déclare PAS « implements Named »

Named n = new Dog();   // ✗ refusé à la compilation
//        incompatible types: Dog cannot be converted to Named

Dog a bien une méthode name(), mais il n'a jamais signé le contrat Named. Le compilateur regarde l'arbre des déclarations, pas la forme : pas de implements, pas de compatibilité. Le nom fait foi.Dog does have a name() method, but it never signed the Named contract. The compiler looks at the declaration tree, not the shape: no implements, no compatibility. The name is what counts.

« Au moins » la forme demandée. Plus, jamais moins."At least" the required shape. More, never less.

La règle d'assignabilité tient en une phrase : une valeur est acceptée si elle possède au moins tous les membres requis, chacun d'un type compatible. Des champs en plus ? Sans importance. Un champ qui manque ? Refus immédiat. Le sens de la flèche n'est pas symétrique.The assignability rule fits in one sentence: a value is accepted if it has at least all the required members, each of a compatible type. Extra fields? They don't matter. A missing field? Immediate refusal. The arrow's direction is not symmetric.

type Target = { id: number };

const wide = { id: 1, name: "a", active: true };
const t: Target = wide;     // ✓ plus de champs que demandé = OK

const narrow = { name: "a" };
const t2: Target = narrow;  // ✗ Property 'id' is missing in type
                            //   { name: string } is not assignable to Target

Le littéral est refusé. La même valeur, via une variable, passe.The literal is refused. The same value, through a variable, passes.

Il existe une entorse au structurel — une seule. Un littéral d'objet « frais », assigné directement à un type, voit ses propriétés en trop refusées. Sortez la même valeur dans une variable d'abord, et tout passe. Ce n'est pas une garantie de structure : c'est un garde-fou contre les fautes de frappe.There's one exception to structural typing — exactly one. A 'fresh' object literal, assigned straight to a type, has its excess properties rejected. Pull the same value into a variable first, and it all passes. This is no structural guarantee: it's a guardrail against typos.

type Config = { width: number; height: number };

const c: Config = { width: 10, height: 20, depth: 5 };
//                                          ^^^^^^^^
// error: Object literal may only specify known properties,
//        and 'depth' does not exist in type 'Config'

Sur un littéral écrit à l'endroit même de l'affectation, TypeScript fait un contrôle en plus du structurel : il refuse les champs inconnus. L'intention est généreuse — attraper le widht mal tapé qui, sinon, partirait silencieusement.On a literal written at the assignment site, TypeScript adds a check on top of structural typing: it rejects unknown fields. The intent is kind — catch the mistyped widht that would otherwise slip through silently.

type Meters  = { value: number };
type Seconds = { value: number };

function wait(s: Seconds) { /* ... */ }

const distance: Meters = { value: 100 };
wait(distance);   // ✓ accepté — même forme, TS ne voit aucune différence
//   100 mètres passés à une fonction qui attend des secondes

Meters et Seconds ont la même forme : pour TypeScript, ce sont le même type. Passer des mètres à une fonction qui attend des secondes ne déclenche aucune erreur — le structurel ne connaît pas l'intention, seulement la structure. Le rendre impossible demande de brander le type : c'est le Vol 3 · №03.Meters and Seconds share a shape: to TypeScript, they're the same type. Passing meters to a function expecting seconds raises no error — structural typing doesn't know intent, only structure. Making it impossible means branding the type: that's Vol 3 · №03.