TypeScript Academy · Leçon

Programmation orientée flux

Enchaîner des opérations susceptibles d’échouer sans try/catch.

Programmation orientée flux est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

La métaphore du chemin de fer

La programmation orientée chemin de fer représente un calcul comme deux voies parallèles : une voie de réussite et une voie d'échec. Une fois passé sur la voie d'échec, le calcul y reste et ignore la suite.

Enchaîner des fonctions Résultat

Chaque étape prend une valeur et renvoie un Result. Nous voulons relier les étapes afin que la première erreur interrompe la chaîne et soit propagée jusqu'au bout.

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

map : transformer la valeur de réussite

map applique une fonction ordinaire à la valeur lorsque le Résultat est valide, et transmet les échecs sans les modifier. Il reste sur la voie de réussite.

function map<T, U, E>(r: Result<T, E>, f: (t: T) => U): Result<U, E> {
  return r.ok ? ok(f(r.value)) : r;
}
console.log(map(ok(2), n => n + 1)); // { ok: true, value: 3 }

flatMap : enchaîner les étapes susceptibles d'échouer

Lorsque l'étape suivante renvoie elle-même un Résultat, utilisez flatMap (également appelé andThen). Cela évite d'imbriquer les Résultats et interrompt la chaîne en cas d'échec.

function flatMap<T, U, E>(r: Result<T, E>, f: (t: T) => Result<U, E>): Result<U, E> {
  return r.ok ? f(r.value) : r;
}

Pourquoi utiliser flatMap plutôt que map

Si vous utilisiez map avec une fonction renvoyant un Résultat, vous obtiendriez Result<Result<U,E>,E>. flatMap aplatit ce résultat d'un niveau et conserve un seul Résultat.

Interrompre la chaîne à la première erreur

Dès qu'une étape renvoie err, chaque appel ultérieur à flatMap le transmet sans le modifier. Les étapes restantes ne s'exécutent jamais, exactement comme lorsqu'on passe sur la voie d'échec.

const start = err("boom") as Result<number, string>;
const out = flatMap(start, n => ok(n + 1));
console.log(out); // { ok: false, error: "boom" }

Construire une chaîne de traitement

Composez des étapes de validation qui renvoient chacune un Résultat. La première erreur devient le résultat de la chaîne ; si toutes les étapes réussissent, la valeur de réussite est propagée jusqu'au bout.

function parseNum(s: string): Result<number, string> {
  const n = Number(s);
  return Number.isNaN(n) ? err("not a number") : ok(n);
}
function positive(n: number): Result<number, string> {
  return n > 0 ? ok(n) : err("must be positive");
}

Exécuter la chaîne de traitement

Enchaîner les appels à flatMap fait passer la valeur à travers chaque étape susceptible d'échouer. Une erreur à n'importe quel endroit arrête la chaîne et fait remonter cette erreur.

const good = flatMap(parseNum("5"), positive);
console.log(good); // { ok: true, value: 5 }
const bad = flatMap(parseNum("-3"), positive);
console.log(bad); // { ok: false, error: "must be positive" }

Combiner map et flatMap

Utilisez flatMap pour les étapes susceptibles d'échouer et map pour les transformations pures. Ensemble, ils gardent le chemin nominal linéaire et gèrent automatiquement les erreurs.

const result = map(flatMap(parseNum("10"), positive), n => n * 2);
console.log(result); // { ok: true, value: 20 }

Pas besoin de try/catch

L'ensemble de la chaîne exprime la réussite et l'échec au moyen de valeurs. Il n'y a pas de try/catch, et le type de chaque étape rend le chemin d'erreur explicite et impossible à éviter.

Pourquoi cette approche passe à l'échelle

Le code fondé sur la programmation orientée chemin de fer garde les flux de travail complexes lisibles : chaque étape est petite et pure, les erreurs se propagent automatiquement et l'ajout d'une étape ne complique pas la gestion des erreurs existante.

Vérification rapide

Vérification rapide de cette leçon.

Récapitulatif

La programmation orientée chemin de fer enchaîne des étapes qui renvoient un Result avec map (transformer la réussite) et flatMap/andThen (enchaîner les étapes susceptibles d'échouer en aplatissant les Résultats imbriqués). La première occurrence de err interrompt le reste et se propage jusqu'au bout, sans try/catch.

Questions Fréquemment Posées

La leçon « Programmation orientée flux » est-elle gratuite ?

Oui — le texte complet de « Programmation orientée flux » 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 « Programmation orientée flux » ?

Enchaîner des opérations susceptibles d’échouer sans try/catch. 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 4 sur 4.

Combien de temps prend la leçon « Programmation orientée flux » ?

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