TypeScript Academy · Leçon

Composition de fonctions avec les types

Composer des fonctions tout en préservant la sécurité du typage.

Composition de fonctions avec les types est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Qu’est-ce que la composition ?

La composition de fonctions combine de petites fonctions pour en former une plus grande. compose(f, g) produit une fonction qui applique d’abord g, puis transmet le résultat à f.

La définition fondamentale

Mathématiquement, compose(f, g)(x) = f(g(x)). Les fonctions s’exécutent de droite à gauche : la plus à droite s’exécute en premier.

const compose = (f: (n: number) => number, g: (n: number) => number) =>
  (x: number) => f(g(x));
const inc = (n: number) => n + 1;
const dbl = (n: number) => n * 2;
console.log(compose(inc, dbl)(5)); // 11 (5*2 then +1)

L’ordre de droite à gauche

L’ordre est important. compose(inc, dbl) double d’abord, puis incrémente, tandis que compose(dbl, inc) incrémente d’abord. Lisez la composition de l’intérieur vers l’extérieur.

console.log(compose(dbl, inc)(5)); // 12 (5+1 then *2)

Typer la composition avec des génériques

Les génériques permettent aux types d’entrée et de sortie de différer. g associe A à B, f associe B à C, et le résultat associe A à C.

function compose<A, B, C>(f: (b: B) => C, g: (a: A) => B): (a: A) => C {
  return a => f(g(a));
}

Changer de types en cours de route

Comme les génériques s’enchaînent selon A -> B -> C, la composition peut transformer une valeur en lui faisant traverser plusieurs formes, par exemple d’une chaîne vers un nombre, puis vers une chaîne.

const length = (s: string) => s.length;
const toStr = (n: number) => "len=" + n;
const describe = compose(toStr, length);
console.log(describe("hello")); // len=5

La frontière entre les types doit correspondre

La sortie de g doit correspondre à l’entrée de f. En cas de désaccord, le compilateur rejette la composition et détecte rapidement les erreurs de câblage.

// compose(length, toStr) would error:
// toStr returns string, length expects string -> ok here,
// but mismatched pairs are flagged by the compiler.

Composer trois fonctions

Vous pouvez imbriquer des compositions ou écrire une version à trois arguments. La règle de droite à gauche s’applique toujours dans les deux cas.

const compose3 = <A, B, C, D>(
  f: (c: C) => D, g: (b: B) => C, h: (a: A) => B
) => (a: A): D => f(g(h(a)));
const inc = (n: number) => n + 1;
const dbl = (n: number) => n * 2;
const neg = (n: number) => -n;
console.log(compose3(neg, dbl, inc)(3)); // -8

La composition construit des chaînes de traitement

En composant de petites fonctions pures, vous assemblez des transformations complexes de manière déclarative. Chaque élément reste vérifiable isolément.

const trim = (s: string) => s.trim();
const upper = (s: string) => s.toUpperCase();
const clean = compose(upper, trim);
console.log(clean("  hi ")); // HI

Pourquoi les fonctions pures se composent mieux

La composition suppose que chaque fonction dépend uniquement de son entrée. Les fonctions pures le garantissent ; leur composition produit donc une autre fonction pure et prévisible.

compose vs pipe

compose s’exécute de droite à gauche et rappelle la notation mathématique. Beaucoup de personnes préfèrent une lecture de gauche à droite, que fournit pipe, présenté ensuite.

Garder des éléments petits

La composition est particulièrement efficace lorsque chaque fonction n’effectue qu’une seule petite tâche. Des étapes courtes, nommées et pures rendent la chaîne de traitement composée explicite et facile à réorganiser.

Vérification rapide

Vérification rapide de cette leçon.

Récapitulatif

compose(f, g)(x) = f(g(x)) s’exécute de droite à gauche. L’enchaînement générique des types A -> B -> C exige que la sortie de g corresponde à l’entrée de f, ce qui permet au compilateur de vérifier la chaîne de traitement composée de petites fonctions pures.

Questions Fréquemment Posées

La leçon « Composition de fonctions avec les types » est-elle gratuite ?

Oui — le texte complet de « Composition de fonctions avec les types » 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 « Composition de fonctions avec les types » ?

Composer des fonctions tout en préservant la sécurité du typage. 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 3 sur 4.

Combien de temps prend la leçon « Composition de fonctions avec les types » ?

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