Interfaces, unions et narrowing

Quand on ne peut plus se contenter de primitifs, on décrit des formes d'objets et on combine des possibles.

🧱 Interface ou type ?

Une interface est un contrat qui décrit la forme d'un objet (ses propriétés et leurs types). Elle peut être étendue (extends) et fusionnée (déclarée deux fois = fusion). Privilégiée pour les formes d'objets.

Un type est un alias qui peut décrire n'importe quoi : une union, une intersection, un tuple, un alias de primitive. Plus flexible que interface pour les combinaisons.

L'intersection (A & B) fusionne deux types en un seul. Le résultat a toutes les propriétés de A ET de B. Ex: User & { role: Role } = un User avec en plus un role.

interface User {
  id: number
  nom: string
}

type Role = "admin" | "user" | "invite"
type UserAvecRole = User & { role: Role }

🔀 Unions

L'union (A | B) est un type qui accepte aussi bien A que B. Une variable de type string | number peut contenir une chaîne OU un nombre. Le narrowing permet d'affiner.

Une union A | B accepte aussi bien A que B :

type Resultat =
  | { ok: true; valeur: number }
  | { ok: false; erreur: string }

const bon: Resultat = { ok: true, valeur: 42 }
const mauvais: Resultat = { ok: false, erreur: "échec" }

🔍 Narrowing

Le narrowing (rétrécissement) est le processus par lequel TypeScript affine le type d'une variable dans une branche conditionnelle. Après if (typeof x === "string"), x est string dans la branche.

Une garde de type (type guard) est un test qui restreint le type. typeof, in, Array.isArray, instanceof sont des gardes built-in. Les fonctions v is T sont des gardes personnalisées.

Le narrowing restreint le type dans une branche :

function afficher(val: string | number) {
  if (typeof val === "string") {
    return val.toUpperCase()   // ici val est string
  }
  return val.toFixed(2)        // ici val est number
}

Gardes disponibles

function traiter(val: string | number[] | null) {
  if (val === null) return "vide"
  if (Array.isArray(val)) return val.length
  return val.length   // string
}

Le littéral discriminé est une union dont chaque variante partage une propriété commune (souvent kind ou type). TypeScript utilise cette propriété pour automatiquement savoir dans quelle variante on se trouve.

📋 Points clés

• Interface : contrat pour les formes d'objets (extensible).
• Type : alias pour unions, intersections, combinaisons.
• Intersection (&) : fusionne deux types.
• Union (|) : accepte plusieurs types possibles.
• Narrowing : affine le type dans une branche conditionnelle.
• Garde : test qui restreint le type (typeof, in, Array.isArray).
• Littéral discriminé : propriété commune pour identifier automatiquement la variante.

📦 Enums

Un enum est un type qui nomme un ensemble de valeurs constantes. Les enums créent leur propre type et leurs propres valeurs au runtime. Utiles pour modéliser des choix fixes (statuts, rôles, directions).

Enum numérique (valeurs auto-incrémentées) :

enum Statut {
  EnAttente,  // 0
  Valide,     // 1
  Refuse,     // 2
}

const s: Statut = Statut.Valide // 1

Enum string (valeurs explicites, plus lisibles) :

enum Couleur {
  Rouge = "rouge",
  Vert = "vert",
  Bleu = "bleu",
}

const c: Couleur = Couleur.Rouge // "rouge"

✅ Vérification des acquis