0Pricing
TypeScript Academy · Leçon

Types de style Result/Either

Modélisez explicitement la réussite ou l’échec avec une union Result/Either, ajoutez des fonctions auxiliaires (map/flatMap/mapError) et gardez des flux prévisibles sans utiliser try/catch partout.

Types de style Result/Either est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 2. 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 2 leçons au total.

Introduction

Objectif : rendre les échecs visibles. Vous modéliserez les résultats avec une union discriminée, composerez des opérations avec des fonctions utilitaires et convertirez les exceptions à la frontière.

  • Type de résultat
  • map/flatMap/mapError
  • Intégration HTTP

Fondamentaux du résultat

Créez un petit utilitaire de résultat : les constructeurs ok/err ainsi que map, flatMap et mapError pour la composition.

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

export const ok = <T>(value: T): Ok<T> => ({ ok: true, value })
export const err = <E>(error: E): Err<E> => ({ ok: false, error })

export function map<T, E, U>(r: Result<T, E>, f: (t: T) => U): Result<U, E> {
  return r.ok ? ok(f(r.value)) : r
}
export function flatMap<T, E, U>(r: Result<T, E>, f: (t: T) => Result<U, E>): Result<U, E> {
  return r.ok ? f(r.value) : r
}
export function mapError<T, E, F>(r: Result<T, E>, g: (e: E) => F): Result<T, F> {
  return r.ok ? r : err(g(r.error))
}

Erreurs du domaine

Modélisez les erreurs du domaine comme une union discriminée avec un tag. Chaque branche contient des données précises pour produire de bons messages.

export type CreateUserError =
  | { tag: "InvalidEmail"; detail?: string }
  | { tag: "Duplicate"; email: string }

export function validateEmail(email: string): Result<string, CreateUserError> {
  const okEmail = /.+@.+/.test(email)
  return okEmail ? ok(email.toLowerCase()) : err({ tag: "InvalidEmail", detail: "bad format" })
}

const existing = new Set(["ada@example.com"]) // pretend DB
export function saveUser(email: string): Result<{ id: string }, CreateUserError> {
  if (existing.has(email)) return err({ tag: "Duplicate", email })
  return ok({ id: Math.random().toString(36).slice(2) })
}

Composition des flux

Composez les validations avec flatMap. Utilisez une instruction switch avec une vérification never pour imposer l’exhaustivité à la compilation.

export function createUser(flowEmail: string) {
  return flatMap(validateEmail(flowEmail), email => saveUser(email))
}

// Use
const r = createUser("Ada@example.com")
if (r.ok) {
  console.log("id:", r.value.id)
} else {
  switch (r.error.tag) {
    case "InvalidEmail": console.error("invalid email:", r.error.detail); break
    case "Duplicate": console.error("already used:", r.error.email); break
    default: ((x: never) => x)(r.error) // exhaustiveness
  }
}

Exception → résultat

Aux frontières des entrées-sorties, enveloppez les exceptions et convertissez-les en Result. Les appelants disposent ainsi d’un chemin d’erreur unique à gérer.

export async function fromPromise<T>(p: Promise<T>): Promise<Result<T, { tag: "Exception"; message: string }>> {
  try { return ok(await p) }
  catch (e) { return err({ tag: "Exception", message: e instanceof Error ? e.message : String(e) }) }
}

// Example: wrap a fetch
export async function fetchJson<T>(url: string): Promise<Result<T, { tag: "Exception"; message: string }>> {
  return fromPromise(fetch(url).then(r => r.json() as T))
}

Conseils de conversion HTTP

Intégration HTTP : convertissez les erreurs du domaine en 400/409 et les exceptions d’entrées-sorties en 502/503. Gardez une petite fonction de conversion afin que les contrôleurs restent clairs et prévisibles.

Vérification de l’avantage du résultat

Vérification rapide : pourquoi préférer une union de résultats discriminée ?

Récapitulatif

Récapitulatif : définissez un petit type de résultat, composez avec map/flatMap, modélisez les erreurs du domaine comme des unions et convertissez les exceptions aux frontières.

Questions Fréquemment Posées

La leçon « Types de style Result/Either » est-elle gratuite ?

Oui — le texte complet de « Types de style Result/Either » 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 2 leçons au total.

Qu'est-ce que j'apprendrai dans « Types de style Result/Either » ?

Modélisez explicitement la réussite ou l’échec avec une union Result/Either, ajoutez des fonctions auxiliaires (map/flatMap/mapError) et gardez des flux prévisibles sans utiliser try/catch partout. 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 1 sur 2.

Combien de temps prend la leçon « Types de style Result/Either » ?

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

  1. Types de style Result/Either
  2. Gestion exhaustive des erreurs avec des unions discriminées
← Retour à TypeScript Academy