Wanneer moet je types en wanneer interfaces gebruiken in TypeScript?

Types (type) moeten worden gebruikt voor:

• Unies (unions) en intersecties (intersections):

  type Status = "pending" | "completed" | "failed";
  type UserWithAddress = User & Address;
  

• Primitieve types en literals:

  type ID = string | number;
  type Direction = "up" | "down" | "left" | "right";
  

• Tuples:

  type RgbColor = [number, number, number];
  

• Aanmaken van aliasen voor bestaande types:

  type StringOrNumber = string | number;
  

• Voorwaardelijke types:

  type TypeOfProp<T, K extends keyof T> = T[K];
  

Interfaces (interface) moeten worden gebruikt voor:

• Omschrijving van de structuur van objecten:

  interface User {
    id: number;
    name: string;
    age?: number; // Optionele eigenschap
  }
  

• Implementatie door klassen (implements):

  interface Logger {
    log(message: string): void;
  }
  
  class ConsoleLogger implements Logger {
    log(message: string) {
      console.log(message);
    }
  }
  

• Uitbreiding van andere interfaces (extends):

  interface Person {
    name: string;
  }
  
  interface Employee extends Person {
    employeeId: number;
  }
  

• Declaratief samenvoegen (declaration merging): Dit stelt je in staat om een bestaande interface uit te breiden door deze opnieuw te declareren. Bij types is dit niet mogelijk.

  interface Box {
    width: number;
  }
  
  interface Box { // Dit voegt de property height toe aan de interface Box
    height: number;
  }
  

Kort overzicht:

Eigenschap	type	interface
Unietypes	Ja	Nee
Intersectietypes	Ja	Nee
Primitieve types/literals	Ja	Nee
Tuples	Ja	Nee
Alias voor types	Ja	Nee
Voorwaardelijke types	Ja	Nee
Objectbeschrijving	Ja	Ja
Implementatie met klassen	Nee	Ja
Uitbreiding	Ja (met &)	Ja (met extends)
Declaratief samenvoegen	Nee	Ja

Over het algemeen is het beter om interface te gebruiken voor het beschrijven van objectstructuren, omdat ze beter passen bij de objectgeoriënteerde aanpak en declaratief samenvoegen ondersteunen. Voor alles wat anders is, vooral voor combinaties en het maken van nieuwe types uit bestaande types, is type flexibeler.