TypeScript : les types qui évitent les bugs

Le meilleur test est celui que le compilateur écrit pour vous.

Le but

Rendre les états impossibles impossibles à représenter.

Un type bien pensé empêche des bugs entiers de catégories.

Éviter `any`

typescript

// ❌ Aucune vérification
function parse(data: any) {
  return data.user.name;
}

// ✅ On force à vérifier
function parse(data: unknown) {
  if (typeof data === "object" && data !== null && "user" in data) {
    // ...
  }
}

unknown oblige à prouver le type avant de s'en servir.

Unions discriminées

typescript

type Resultat =
  | { statut: "ok"; donnees: string[] }
  | { statut: "erreur"; message: string };

function afficher(r: Resultat) {
  if (r.statut === "ok") {
    return r.donnees.join(", ");
  }
  return r.message;
}

Impossible d'avoir à la fois donnees et message.

Vérifier l'exhaustivité

typescript

function traiter(r: Resultat) {
  switch (r.statut) {
    case "ok":
      return r.donnees;
    case "erreur":
      return r.message;
    default: {
      const jamais: never = r;
      return jamais;
    }
  }
}

Si l'on ajoute un statut, le compilateur signale les switch oubliés.

`satisfies`

typescript

const couleurs = {
  marque: "#7c5cff",
  succes: "#2dd4bf",
} satisfies Record<string, string>;

couleurs.marque.toUpperCase(); // le type littéral est conservé

On valide la forme sans perdre la précision du type.

Génériques

typescript

function premier<T>(liste: T[]): T | undefined {
  return liste[0];
}

const n = premier([1, 2, 3]); // number | undefined

Un seul code, type préservé.

Quelques réglages utiles

strict: true
noUncheckedIndexedAccess
noImplicitOverride

Ils sont stricts, et c'est justement leur intérêt.

À retenir

unknown plutôt que any
Modélisez les états avec des unions discriminées
Laissez le compilateur vérifier l'exhaustivité