Wat is structureel typen in TypeScript?

Question

Accepted Answer

TypeScript gebruikt **structureel typen** ("duck typing"): twee types zijn compatibel als ze dezelfde **vorm** hebben, ongeacht hun naam of waar ze werden gedeclareerd. Dit staat in contrast met *nominaal* typen (Java, C#) waarbij compatibiliteit afhangt van de gedeclareerde typenaam.

```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` werd nooit gedeclareerd als een `Point`, maar wordt toch geaccepteerd omdat het *structureel* aan de vorm voldoet. Extra eigenschappen zijn toegestaan bij het doorgeven van een bestaande variabele.

## De excess-property check uitzondering

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

Object **literals** die direct worden doorgegeven krijgen een striktere "excess property check" om typfouten op te vangen — maar wijs het eerst toe aan een variabele en het slaagt. Dit is een bewuste balans tussen flexibiliteit en het voorkomen van fouten.

## Waarom het belangrijk is

Structureel typen maakt TypeScript flexibel en ergonomisch — je kunt een interface bevrredigen zonder deze expliciet te implementeren, wat goed aansluit bij JavaScripts object-literal stijl.

Het nadeel: types die toevallig dezelfde vorm hebben zijn uitwisselbaar, zelfs als ze conceptueel niet gerelateerd zijn (een reden waarom mensen *branded types* gebruiken wanneer ze nominaal-achtige onderscheiding nodig hebben).