TypeScript Academy · Leçon

Modéliser les types Result

Représenter la réussite et l’échec sous forme de données avec Result.

Modéliser les types Result est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.

Le type Résultat

Un Résultat modélise une opération qui réussit avec une valeur ou échoue avec une erreur, sous la forme d'une union discriminée que vous pouvez renvoyer au lieu de lever une exception.

Définir le type Résultat

La structure classique utilise le discriminant ok. Lorsque ok vaut true, une value est présente ; lorsqu'il vaut false, une error est présente.

type Result<T, E> =
  | { ok: true; value: T }
  | { ok: false; error: E };

Fonctions auxiliaires de construction

De petites fonctions auxiliaires ok et err rendent la construction des résultats concise et lisible, au lieu de devoir écrire les littéraux d'objet manuellement à chaque fois.

const ok = <T>(value: T): Result<T, never> => ({ ok: true, value });
const err = <E>(error: E): Result<never, E> => ({ ok: false, error });

Renvoyer un résultat

Une fonction susceptible d'échouer renvoie ok(value) ou err(error). Son type de retour annonce les deux possibilités à chaque appelant.

function divide(a: number, b: number): Result<number, string> {
  return b === 0 ? err("divide by zero") : ok(a / b);
}

Affiner le type avec ok

Vérifier result.ok affine l'union. Dans la branche vraie, TypeScript sait que value existe ; dans la branche fausse, il sait que error existe.

const r = divide(10, 2);
if (r.ok) console.log(r.value); // 5
else console.log(r.error);

Le discriminant garantit la sécurité

Le champ ok est le discriminant qui permet au compilateur de choisir la branche appropriée. Vous ne pouvez pas accéder à value sans avoir d'abord prouvé que ok vaut true.

const r = divide(1, 0);
// r.value here is a type error until we check r.ok
if (!r.ok) console.log("err:", r.error);

Erreurs typées

Les erreurs peuvent être plus riches que de simples chaînes. Une union d'erreurs typées permet aux appelants de gérer précisément chaque catégorie après l'affinement du type.

type DivErr = { kind: "zero" } | { kind: "overflow" };
function div(a: number, b: number): Result<number, DivErr> {
  if (b === 0) return err({ kind: "zero" });
  return ok(a / b);
}

Gestion exhaustive des erreurs

Comme le type d'erreur est une union, un switch sur son discriminant peut être vérifié pour garantir l'exhaustivité, ce qui assure que chaque mode d'échec est géré.

const r = div(1, 0);
if (!r.ok) {
  switch (r.error.kind) {
    case "zero": console.log("no zero"); break;
    case "overflow": console.log("too big"); break;
  }
}

Une fonction auxiliaire avec valeur de repli

Parfois, vous voulez simplement obtenir la valeur ou une valeur de repli. Une petite fonction unwrapOr se lit clairement et garde la gestion de l'échec à l'endroit concerné.

function unwrapOr<T, E>(r: Result<T, E>, fallback: T): T {
  return r.ok ? r.value : fallback;
}
console.log(unwrapOr(divide(1, 0), -1)); // -1

Résultat ou exception

Result fait entrer l'échec dans le type de retour, de sorte que les appelants doivent le prendre en compte. En contrepartie, le code est plus explicite, ce qui en vaut généralement la peine pour les erreurs attendues.

Exemple complet

Pour tout réunir : définissez des fonctions auxiliaires, renvoyez des résultats et affinez le type avant l'utilisation. Le compilateur garantit que la branche d'erreur est prise en compte.

function safeParse(s: string): Result<number, string> {
  const n = Number(s);
  return Number.isNaN(n) ? err("NaN") : ok(n);
}
const p = safeParse("42");
console.log(p.ok ? p.value : p.error); // 42

Vérification rapide

Vérification rapide de cette leçon.

Récapitulatif

Résultat<T, E> est une union discriminée : { ok: true; value } ou { ok: false; error }. Construisez-la avec les fonctions auxiliaires ok/err, puis affinez le type avec ok pour accéder en toute sécurité à value ou error ; les erreurs typées permettent une gestion exhaustive.

Questions Fréquemment Posées

La leçon « Modéliser les types Result » est-elle gratuite ?

Oui — le texte complet de « Modéliser les types Result » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Modéliser les types Result » ?

Représenter la réussite et l’échec sous forme de données avec Result. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer TypeScript Academy ?

Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Modéliser les types Result » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?

Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à TypeScript Academy