Quand faut-il utiliser des types et quand des interfaces en TypeScript?

Les types (type) doivent être utilisés pour :

• Unions (unions) et intersections (intersections) :

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

• Types primitifs et littéraux :

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

• Tuples :

  type RgbColor = [number, number, number];
  

• Création d'alias pour des types existants :

  type StringOrNumber = string | number;
  

• Types conditionnels :

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

Les interfaces (interface) doivent être utilisées pour :

• Description de la structure des objets :

  interface User {
    id: number;
    name: string;
    age?: number; // propriété optionnelle
  }
  

• Implémentation par des classes (implements) :

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

• Extension d'autres interfaces (extends) :

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

• Fusion déclarative (declaration merging) : Cela permet d'étendre une interface existante en la déclarant à nouveau. Avec les types, ce n'est pas possible.

  interface Box {
    width: number;
  }
  
  interface Box { // Cela ajoutera la propriété height à l'interface Box
    height: number;
  }
  

Résumé comparatif :

Caractéristique	type	interface
Types union	Oui	Non
Types intersection	Oui	Non
Types primitifs/littéraux	Oui	Non
Tuples	Oui	Non
Alias de types	Oui	Non
Types conditionnels	Oui	Non
Description d'objets	Oui	Oui
Implémentation avec classes	Non	Oui
Extension	Oui (avec &)	Oui (avec extends)
Fusion déclarative	Non	Oui

En général, pour décrire la structure des objets, il est préférable d'utiliser interface, car ils conviennent mieux à l'approche orientée objet et supportent la fusion déclarative. Pour tout le reste, notamment pour la combinaison et la création de nouveaux types à partir de types existants, type est plus flexible.