Currying est un concept puissant de programmation fonctionnelle qui transforme une fonction avec plusieurs arguments en une séquence de fonctions, chacune prenant un seul argument. Cette technique permet un code plus modulaire et réutilisable. En JavaScript, le curry peut être implémenté de différentes manières. Ce blog explorera le currying, fournira des exemples et discutera de différentes méthodes pour réaliser le currying d'arguments.

Qu’est-ce que le curry ?

Le currying est le processus de conversion d'une fonction qui prend plusieurs arguments en une série de fonctions qui prennent chacune un seul argument. Par exemple, une fonction f(a, b, c) peut être transformée en f(a)(b)(c).

Pourquoi utiliser le curry ?

• Application partielle : Le currying vous permet de corriger certains arguments d'une fonction et de créer une nouvelle fonction.
• Fonctions d'ordre supérieur : cela facilite l'utilisation de fonctions d'ordre supérieur, qui prennent d'autres fonctions comme arguments ou les renvoient.
• Réutilisabilité du code : les fonctions Curry sont plus réutilisables et composables.
• Composition fonctionnelle : le currying permet une meilleure composition fonctionnelle, où des fonctions complexes sont construites en combinant des fonctions plus simples, conduisant à un code plus propre et plus maintenable.

Exemple de curry simple

Commençons par un exemple de base pour comprendre le fonctionnement du curry.

Fonction non currée

Voici une fonction simple qui ajoute trois nombres :

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

console.log(add(1, 2, 3)); // Output: 6

Explication : Cette fonction add prend trois arguments a, b et c et renvoie leur somme. Lorsque nous appelons add(1, 2, 3), il renvoie 6.

Fonction curry

Maintenant, convertissons cette fonction en une version au curry :

function curryAdd(a) {
  return function(b) {
    return function(c) {
      return a   b   c;
    };
  };
}

console.log(curryAdd(1)(2)(3)); // Output: 6

Explication : La fonction curryAdd prend un argument a et renvoie une fonction qui prend un argument b, qui à son tour renvoie une fonction qui prend un argument c. La fonction finale renvoie la somme de a, b et c. Lorsque nous appelons curryAdd(1)(2)(3), il transmet séquentiellement les arguments 1, 2 et 3 via les fonctions imbriquées, ce qui donne 6.

Curry avec les fonctions fléchées

Les fonctions fléchées de JavaScript offrent un moyen concis de créer des fonctions au curry.

const curryAddArrow = a => b => c => a   b   c;

console.log(curryAddArrow(1)(2)(3)); // Output: 6

Explication : La fonction curryAddArrow est une fonction flèche qui prend un argument a et renvoie une autre fonction flèche qui prend b, qui renvoie encore une autre fonction flèche qui prend c. La fonction flèche finale renvoie la somme de a, b et c. Lorsque nous appelons curryAddArrow(1)(2)(3), il transmet séquentiellement les arguments 1, 2 et 3 via les fonctions fléchées imbriquées, ce qui donne 6.

Cas d'utilisation

1.Fonctions de configuration

Les fonctions de configuration sont un cas d'utilisation courant du curry. Par exemple, imaginez que vous créez un utilitaire de journalisation dans lequel vous souhaitez configurer séparément le niveau de journalisation et le format du message.

function logger(level) {
  return function (message) {
    console.log(`[${level}] ${message}`);
  };
}

const infoLogger = logger('INFO');
const errorLogger = logger('ERROR');

infoLogger('This is an info message');
errorLogger('This is an error message');

2. Formateur de chaîne

Considérons un exemple pratique où le curry peut être utilisé pour créer un formateur de chaîne. Ce formateur vous permettra de configurer le préfixe et le suffixe séparément.

function formatter(prefix) {
  return function (suffix) {
    return function (str) {
      return `${prefix}${str}${suffix}`;
    };
  };
}

const htmlFormatter = formatter('')('');
console.log(htmlFormatter('Hello')); // Hello

const parensFormatter = formatter('(')(')');
console.log(parensFormatter('123')); // (123)

Curry dans les bibliothèques JavaScript modernes

Le currying est couramment utilisé dans les bibliothèques JavaScript modernes comme Lodash et Ramda. Par exemple, dans Lodash, vous pouvez utiliser la méthode _.curry pour créer facilement des fonctions au curry.

const _ = require('lodash');

function multiply(a, b, c) {
  return a * b * c;
}

const curriedMultiply = _.curry(multiply);

console.log(curriedMultiply(2)(3)(4)); // 24
console.log(curriedMultiply(2, 3)(4)); // 24

Curry avec N arguments

Voyons ci-dessous l'exemple de curry avec une fonction récursive qui ajoute n arguments. Nous utiliserons le curry pour créer une fonction capable d'accepter n'importe quel nombre d'arguments, un à la fois, et de les additionner.

function curryAddition(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    } else {
      return function(...nextArgs) {
        return curried(...args, ...nextArgs);
      };
    }
  };
}

// This function sums an array of numbers
function add(...nums) {
  return nums.reduce((acc, num) => acc   num, 0);
}

// Creating a curried version of the addition function
const curriedAdd = curryAddition(add);

// Function to handle n arguments
function curriedAddN(...initialArgs) {
  function adder(...args) {
    if (args.length === 0) {
      return curriedAdd(...initialArgs);
    }
    initialArgs.push(...args);
    return adder;
  }
  return adder;
}

// Examples
const addFiveNumbers = curriedAddN();
console.log(addFiveNumbers(1)(2)(3)(4)(5)()); // 15

const addThreeNumbers = curriedAddN(1)(2)(3);
console.log(addThreeNumbers()); // 6

const addNumbersInSteps = curriedAddN(1, 2)(3)(4, 5);
console.log(addNumbersInSteps()); // 15

Conclusion

Le currying est une technique puissante de programmation fonctionnelle qui améliore la modularité et la réutilisabilité du code. En transformant les fonctions en chaînes de fonctions à argument unique, le curry permet une application partielle et une composition flexible des fonctions. Qu'il s'agisse de configuration, de formatage de chaîne ou de calculs complexes, le curry peut rendre votre code plus expressif et adaptable.