Antwoord

In TypeScript kun je types uitbreiden (erfgen) zowel met interface extends als met type & type (intersectietypes). Ook kunnen interfaces types uitbreiden, en omgekeerd.

Interfaces gebruiken het sleutelwoord extends om eigenschappen te erfen:

interface Dier {
  naam: string;
}
interface Vogel extends Dier {
  vleugels: number;
}

Types kunnen worden samengevoegd met &:

type Dier = { naam: string };
type Vogel = Dier & { vleugels: number };

Ook kan een interface een ander type uitbreiden:

type Basis = { id: number };
interface Afgeleide extends Basis {
  beschrijving: string;
}

Bijzonderheden:

• Interfaces ondersteunen declaratieve samenvoeging (declaration merging), types niet.
• Interfaces worden aanbevolen als uitbreiding van andere entiteiten wordt verwacht (bijvoorbeeld voor bibliotheken).
• Geneste extends kunnen leiden tot complexe hiërarchie, het onderhoud bemoeilijken en naamconflicten veroorzaken.

Valentijnsvraag

Kan een type (type) worden uitgebreid via een interface of omgekeerd? Welke fout maken de meesten?

Veel mensen denken dat alleen interfaces via interfaces kunnen worden uitgebreid, maar in werkelijkheid kan een interface een type uitbreiden:

type Basis = { vlag: boolean };
interface Extra extends Basis {
  naam: string;
}

Maar een type kan geen andere types uitbreiden via extends — alleen via intersecties (&).

Voorbeelden van echte fouten door onbekendheid met de nuances van het onderwerp

---

Verhaal

In een groot project werden interfaces samengevoegd via extends, zonder te beseffen dat identieke eigenschappen qua type overeen moeten komen. Wanneer iemand het type van een eigenschap in de bovenliggende interface wijzigde, ontstonden er silent conflicts in de afgeleiden, waardoor de database niet meer overeenkwam met de API.

Verhaal

In een bibliotheek werden type-aliases geschreven met overlappende eigenschappen via & (intersecties), maar sommige eigenschappen werden incompatibel qua type gemaakt. TypeScript negeerde dit tijdens het compileren, maar in werkelijkheid kwamen er ongedefinieerde velden in het runtime-systeem.

Verhaal

Het team dacht dat je een interface niet met een type kon uitbreiden, en herschreef alle structuren van type naar interface om gemeenschappelijke functionaliteit uit te breiden, wat veel tijd en moeite kostte - terwijl ze bestaande types eenvoudig op een onconventionele manier hadden kunnen uitbreiden.