JavaScript Academy · Leçon

Currification des fonctions

Transformez des fonctions à plusieurs arguments en chaînes d’appels.

Currification des fonctions est une leçon JavaScript 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 JavaScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours JavaScript Academy comprend 4 leçons au total.

Qu’est-ce que la curryfication

La curryfication transforme une fonction qui prend plusieurs arguments en une suite de fonctions qui prennent chacune un argument.

Au lieu d’appeler add(1, 2, 3), vous appelez add(1)(2)(3). Chaque appel renvoie la fonction suivante jusqu’à ce que tous les arguments soient réunis.

Faire la curryfication manuellement

La manière la plus claire de comprendre la curryfication consiste à écrire des fonctions imbriquées, dont chacune renvoie la suivante et capture les arguments précédents.

function add(a) {
  return function (b) {
    return function (c) {
      return a + b + c;
    };
  };
}

console.log(add(1)(2)(3));

Retours de fonctions fléchées imbriquées

Les fonctions fléchées rendent les définitions curryfiées plus courtes. Chaque => renvoie la fonction fléchée suivante, et la dernière effectue le travail.

const add = a => b => c => a + b + c;

console.log(add(1)(2)(3));
console.log(add(10)(20)(30));

Les fermetures mémorisent les arguments

La curryfication repose sur les fermetures. Chaque fonction renvoyée conserve une référence vers les variables de sa portée externe, de sorte que les arguments précédents restent disponibles jusqu’à l’exécution du dernier appel.

const greet = greeting => name => greeting + ', ' + name + '!';

const sayHi = greet('Hi');
console.log(sayHi('Ada'));
console.log(sayHi('Grace'));

Appeler étape par étape

Vous n’avez pas besoin de fournir tous les arguments en une seule fois. Vous pouvez vous arrêter en cours de route et conserver le résultat partiel dans une variable pour le réutiliser.

const add = a => b => c => a + b + c;

const addOne = add(1);
const addOneAndTwo = addOne(2);

console.log(addOneAndTwo(3));
console.log(addOneAndTwo(100));

Un assistant générique de curryfication

Écrire manuellement des fonctions imbriquées est fastidieux. Un assistant générique curry rassemble les arguments jusqu’à en avoir suffisamment, puis appelle la fonction d’origine.

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    }
    return (...more) => curried(...args, ...more);
  };
}

const add = curry((a, b, c) => a + b + c);
console.log(add(1)(2)(3));

Appels flexibles avec curry

Un bon auxiliaire curry accepte les arguments regroupés de n’importe quelle manière. fn.length lui indique combien de paramètres la fonction d’origine a déclarés.

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    }
    return (...more) => curried(...args, ...more);
  };
}

const add = curry((a, b, c) => a + b + c);
console.log(add(1, 2, 3));
console.log(add(1, 2)(3));
console.log(add(1)(2, 3));

La curryfication pour la spécialisation

La curryfication rend la spécialisation naturelle : appliquez le premier argument, puis réutilisez la fonction renvoyée lors de nombreux appels.

const multiply = a => b => a * b;

const double = multiply(2);
const triple = multiply(3);

console.log(double(5));
console.log(triple(5));

La curryfication avec les méthodes de tableau

Les fonctions curryfiées s’insèrent parfaitement dans map et filter, car chacune produit une fonction à un argument prête à recevoir chaque élément.

const greaterThan = min => value => value > min;

const over10 = greaterThan(10);
console.log([5, 12, 8, 20].filter(over10));

Curryfication et application partielle

L’application partielle fixe certains arguments et laisse les autres pour un seul appel ultérieur. La curryfication décompose toujours une fonction en une chaîne d’appels à un seul argument.

La curryfication est une forme spécifique et entièrement décomposée de l’application partielle.

const partial = (a, b) => c => a + b + c;
const curried = a => b => c => a + b + c;

console.log(partial(1, 2)(3));
console.log(curried(1)(2)(3));

Pourquoi utiliser curry

La curryfication favorise les petites fonctions composables et réutilisables. Elle s’accorde naturellement avec la composition de fonctions, que vous allez explorer ensuite. L’idée essentielle est qu’une fonction curryfiée n’est jamais « incomplète » : elle renvoie simplement une autre fonction jusqu’à ce que tous les arguments soient fournis.

const tag = name => content => '<' + name + '>' + content + '</' + name + '>';

const bold = tag('b');
console.log(bold('important'));
console.log(tag('i')('slanted'));

Vérification rapide

Étant donné const add = a => b => c => a + b + c;, à quoi s’évalue add(1)(2) ?

Récapitulatif : curryfication

Vous avez appris à décomposer les fonctions en chaînes d’arguments uniques :

Les fonctions curryfiées renvoient une nouvelle fonction pour chaque argument grâce aux fermetures.
Les fonctions fléchées imbriquées permettent de définir des fonctions curryfiées de façon concise.
Un auxiliaire générique curry utilise fn.length pour savoir quand suffisamment d’arguments ont été reçus.
La curryfication permet une spécialisation efficace et une composition.

Questions Fréquemment Posées

La leçon « Currification des fonctions » est-elle gratuite ?

Oui — le texte complet de « Currification des fonctions » 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 JavaScript Academy, passe à CoddyKit PRO. Le cours JavaScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Currification des fonctions » ?

Transformez des fonctions à plusieurs arguments en chaînes d’appels. Tu pratiques JavaScript 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 JavaScript Academy ?

Aucune expérience préalable n'est requise. JavaScript 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 « Currification des fonctions » ?

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 JavaScript Academy ?

Oui. Chaque leçon JavaScript 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 à JavaScript Academy