Qu'est-ce que le typage structurel dans TypeScript ?

Question

Accepted Answer

TypeScript utilise le **typage structurel** ("duck typing") : deux types sont compatibles s'ils ont la même **forme**, indépendamment de leur nom ou du lieu où ils ont été déclarés. Cela contraste avec le typage *nominal* (Java, C#) où la compatibilité dépend du nom de type déclaré.

```ts
interface Point { x: number; y: number; }

function print(p: Point) { console.log(p.x, p.y); }

// No `: Point` annotation anywhere, but the shape matches:
const obj = { x: 1, y: 2, z: 3 };
print(obj); // ✅ works — obj has x and y (extra z is fine)
```

`obj` n'a jamais été déclaré comme un `Point`, mais il est accepté parce qu'il satisfait *structurellement* la forme. Les propriétés supplémentaires sont autorisées lors de la transmission d'une variable existante.

## Pourquoi c'est important

```ts
print({ x: 1, y: 2, z: 3 }); // ❌ Error: 'z' does not exist in type 'Point'
```

Les **littéraux** d'objet passés directement reçoivent une vérification plus stricte des "propriétés excédentaires" pour détecter les fautes de frappe — mais assignez-le d'abord à une variable et il passera. C'est un équilibre délibéré entre la flexibilité et la détection des erreurs.

## Exception à la vérification des propriétés excédentaires

Le typage structurel rend TypeScript flexible et ergonomique — vous pouvez satisfaire une interface sans l'implémenter explicitement, ce qui correspond au style des objets littéraux de JavaScript.

Le compromis : les types qui partagent accidentellement une forme sont interchangeables même s'ils sont conceptuellement sans rapport (la raison pour laquelle les gens utilisent les *types marqués* lorsqu'ils ont besoin d'une distinction de type nominal).