Maîtriser le curry en JavaScript : améliorer la réutilisabilité et la flexibilité du code

Comprendre le curry en JavaScript

Le

Currying est une technique de programmation fonctionnelle utilisée en JavaScript où une fonction qui prend plusieurs arguments est transformée en une séquence de fonctions, chacune acceptant un seul argument. Cela vous permet d'appliquer partiellement des arguments, offrant ainsi une manière plus flexible de travailler avec les fonctions.

1. Qu'est-ce que le curry ?

Le currying est le processus de transformation d'une fonction qui prend plusieurs arguments en une série de fonctions qui prennent chacune un seul argument. La première fonction prendra le premier argument, renverra une nouvelle fonction qui prendra le deuxième argument, et ainsi de suite, jusqu'à ce que tous les arguments aient été fournis.

Exemple de curry :

Un exemple de base de curry peut être illustré comme suit :

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

const addFive = add(5); // The first function is called with 5
console.log(addFive(3)); // Output: 8 (5 + 3)

Dans l'exemple ci-dessus :

• add prend un argument a et renvoie une fonction qui prend le deuxième argument b.
• Lorsque vous appelez add(5), il renvoie une fonction où a est fixé à 5. La nouvelle fonction prend maintenant b et l'ajoute à 5.

2. Curry avec plusieurs arguments

Le currying est plus utile lorsque vous avez une fonction qui prend plusieurs arguments et que vous souhaitez la diviser en morceaux plus petits et réutilisables. Voici un exemple de curry avec plusieurs arguments :

Exemple de curry avec plusieurs arguments :

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

const multiplyBy2 = multiply(2);  // First argument is fixed as 2
const multiplyBy2And3 = multiplyBy2(3); // Second argument is fixed as 3
console.log(multiplyBy2And3(4)); // Output: 24 (2 * 3 * 4)

Dans ce cas :

• multiplier(2) renvoie une fonction qui prend b.
• La fonction renvoyée prend b et renvoie une autre fonction qui prend c.
• Lorsque multiplieBy2And3(4) est appelé, il calcule 2 * 3 * 4.

3. Exemple de curry : implémentation personnalisée

Vous pouvez implémenter le curry manuellement en créant une fonction qui prend un certain nombre d'arguments et renvoie une fonction qui accumule ces arguments.

Fonction de curry personnalisée :

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

// Example function
function sum(a, b, c) {
  return a + b + c;
}

const curriedSum = curry(sum);
console.log(curriedSum(1)(2)(3)); // Output: 6

Dans l'exemple ci-dessus :

• Nous avons créé une fonction curry personnalisée qui peut curry n'importe quelle fonction.
• sum(1, 2, 3) est divisé en plusieurs appels : curriedSum(1)(2)(3).

4. Pourquoi utiliser le curry ?

Currying vous permet de créer davantage de fonctions réutilisables et composables. Cela peut simplifier le code dans certains scénarios et faciliter le travail avec des fonctions partageant des arguments communs.

Avantages du curry :

1. Application de fonctions partielles : Le currying permet une application partielle de fonctions, ce qui signifie que vous pouvez créer des fonctions spécialisées en corrigeant certains arguments et en laissant d'autres être fournis plus tard.

2. Composition des fonctions : Vous pouvez combiner des fonctions curry pour créer des opérations plus complexes sans avoir à répéter le code.

3. Lisibilité améliorée : le currying indique clairement les arguments dont une fonction a besoin et permet un code plus propre et plus concis.

Exemple d'application de fonction partielle :

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

const addFive = add(5); // The first function is called with 5
console.log(addFive(3)); // Output: 8 (5 + 3)

Ici, multiplieBy10 est une fonction spécialisée dont le premier argument est fixé à 10. Celui-ci peut être réutilisé à plusieurs endroits.

5. Exemple pratique : Curry avec une requête API

Supposons que vous effectuez une série de requêtes API avec des paramètres communs. Le curry peut être utilisé pour simplifier ce processus.

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

const multiplyBy2 = multiply(2);  // First argument is fixed as 2
const multiplyBy2And3 = multiplyBy2(3); // Second argument is fixed as 3
console.log(multiplyBy2And3(4)); // Output: 24 (2 * 3 * 4)

6. Comparaison avec une candidature partielle

Alors que le currying transforme une fonction en une série de fonctions unaires, l'application partielle est le processus de correction de certains arguments d'une fonction et de renvoi d'une nouvelle fonction qui accepte les arguments restants. Le curry est un moyen d'obtenir une application partielle.

Exemple de candidature partielle :

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

// Example function
function sum(a, b, c) {
  return a + b + c;
}

const curriedSum = curry(sum);
console.log(curriedSum(1)(2)(3)); // Output: 6

Ici, nous avons partiellement appliqué « Bonjour » à la fonction greet en utilisant bind().

Conclusion

• Currying est une technique qui permet d'appeler une fonction avec un argument à la fois, renvoyant une nouvelle fonction jusqu'à ce que tous les arguments soient fournis.
• C'est utile pour l'application partielle, la composition de fonctions et pour améliorer la réutilisabilité et la lisibilité du code.
• Bien que le curry soit principalement utilisé pour simplifier des fonctions avec plusieurs arguments, c'est un outil puissant en programmation fonctionnelle.

---

Bonjour, je m'appelle Abhay Singh Kathayat !
Je suis un développeur full-stack avec une expertise dans les technologies front-end et back-end. Je travaille avec une variété de langages et de frameworks de programmation pour créer des applications efficaces, évolutives et conviviales.
N'hésitez pas à me contacter à mon e-mail professionnel : kaashshorts28@gmail.com.

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!