Currying : débloquer la superpuissance modulaire de JavaScript

Table des matières

• Introduction
• Qu'est-ce que c'est que le curry ?
• Guide étape par étape du curry
• Pourquoi devriez-vous vous soucier du curry ?
• Automatiser le curry (parce que la vie est trop courte)
• TypeScript et Curry : Friends Forever
• Une note rapide sur les pièges
• Conclusion

---

Présentation

Avez-vous déjà regardé votre code et pensé : « Wow, c'est à peu près aussi organisé que mon tiroir à chaussettes ? » Eh bien, vous n'êtes pas seul. JavaScript, malgré toutes ses bizarreries et ses charmes, peut devenir compliqué. Entrez dans le currying, une technique magique issue de la programmation fonctionnelle qui rend votre code modulaire, réutilisable et, oserais-je dire, élégant. Si cela ressemble à de la magie, attachez votre ceinture. Nous sommes sur le point de plonger.

---

Qu'est-ce que c'est que le curry ?

Le currying ressemble à quelque chose que vous feriez en cuisine, mais en JavaScript, c'est l'art de transformer une fonction avec plusieurs arguments en une séquence de fonctions, chacune prenant un seul argument. Pensez-y comme à décomposer une recette compliquée en petites étapes.

Voici un exemple simple :

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

Cool, non ? Mais cette fonction exige les deux arguments dès le départ. Si vous n'êtes pas prêt à vous engager dans les deux (qui l'est vraiment ?), le curry vous permet de l'appeler ainsi :

const curriedMultiply = (a: number) => (b: number) => a * b;

// Create reusable specialized functions
const double = curriedMultiply(2);
const triple = curriedMultiply(3);

console.log(double(4)); // Output: 8
console.log(triple(4)); // Output: 12

Boum ! Vous pouvez désormais transmettre un argument à la fois, comme préparer un sandwich. Maintenant que vous avez vu une fonction simple au curry, apprenons à en créer une étape par étape.

---

Guide étape par étape du curry

1. Commencez avec une fonction multi-arguments
   Imaginez que vous ayez une fonction qui prend plusieurs arguments :
   

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

2. Enveloppez-le en couches
   Transformez-le en une séquence de fonctions :
   

   const curriedAdd = 
     (a: number) => (b: number) => (c: number) => a + b + c;
   

3. Passez les arguments un par un
   Appelez chaque couche une à la fois :
   

   const step1 = curriedAdd(2); // Fixes the first argument (a = 2)
   const step2 = step1(3);      // Fixes the second argument (b = 3)
   const result = step2(4);     // Fixes the third argument (c = 4)
   
   console.log(result);         // Output: 9
   

4. Profitez de la flexibilité
   Vous disposez désormais de petites étapes réutilisables qui rendent votre code plus modulaire.

---

Pourquoi devriez-vous vous soucier du curry ?

Le curry peut sembler sophistiqué, mais il présente des avantages concrets :

• Modularité : divisez les grandes fonctions en petits éléments testables.
• Réutilisabilité : utilisez le code existant pour créer des versions de fonctions spécialisées.
• Lisibilité : Votre code devient explicite, comme un roman bien écrit (ou du moins décent).

Prenons un moment pour rappeler pourquoi la lisibilité est importante. Le code n’est pas seulement écrit pour les machines : elles comprendront tout ce que vous leur lancerez. Il est écrit pour les humains : vos collègues, votre futur moi et la prochaine personne qui devra le modifier. Un bon code doit viser à être facile à comprendre, à tester et à modifier. Le curry aide à y parvenir en divisant la logique en éléments plus petits et clairs qui ont un sens en un coup d'œil.

Disons que vous filtrez une liste d'objets :

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

Ou calculer les taxes :

const curriedMultiply = (a: number) => (b: number) => a * b;

// Create reusable specialized functions
const double = curriedMultiply(2);
const triple = curriedMultiply(3);

console.log(double(4)); // Output: 8
console.log(triple(4)); // Output: 12

Chaque fonction fait une chose, ce qui rend votre code plus facile à lire, à comprendre et à tester. En créant des fonctions plus petites et spécialisées, le currying rend la logique complexe simple, réutilisable et maintenable pour les humains qui y travailleront plus tard.

---

Automatiser le curry (parce que la vie est trop courte)

Vous tapez manuellement toutes ces fonctions imbriquées ? Non merci. Automatisons le curry :

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

Voici comment cela fonctionne :

1. Si le nombre d'arguments correspond à la fonction d'origine, il appelle la fonction.
2. Sinon, il renvoie une nouvelle fonction qui attend plus d'arguments.

Exemple :

const curriedAdd = 
  (a: number) => (b: number) => (c: number) => a + b + c;

C'est comme un distributeur automatique d'arguments : mettez-en un à la fois ou tous d'un coup.

---

TypeScript et Curry : Friends Forever

Faites passer le curry au niveau supérieur avec la sécurité des types dans TypeScript :

const step1 = curriedAdd(2); // Fixes the first argument (a = 2)
const step2 = step1(3);      // Fixes the second argument (b = 3)
const result = step2(4);     // Fixes the third argument (c = 4)

console.log(result);         // Output: 9

Exemple avec TypeScript :

const filterByKey = (key: string) => (value: any) => (data: any[]) =>
  data.filter((item) => item[key] === value);

// Create a reusable filter for colors
const filterByColor = filterByKey("color");
const redItems = filterByColor("red");

console.log(redItems([{ color: "red" }, { color: "blue" }])); 
// Output: [{ color: "red" }]

Votre IDE vous guidera à chaque étape du processus.

---

Une note rapide sur les pièges

Les fonctions curry perdent leur originalité dans ce contexte. Si vous devez utiliser une méthode d'une classe avec curry, utilisez les fonctions .bind(this) ou fléchées.

---

Conclusion ?

Currying, c'est comme mettre à niveau votre jeu de codage avec des codes de triche. En décomposant les fonctions en éléments plus petits et gérables, vous gagnez en flexibilité, en lisibilité et en un sentiment d'accomplissement (ou du moins moins de problèmes de débogage). Que vous l'automatisiez ou l'écriviez à la main, le curry transforme votre code en une centrale propre et modulaire.

Comme Haskell Curry (l'homme derrière le nom) aurait pu le dire :

« Écrivez moins, faites plus… un argument à la fois !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!