Démystifier les fonctions JavaScript / blogs / perficient

Comprendre le curry en javascript

La programmation fonctionnelle a gagné une traction significative dans le développement moderne de JavaScript, et parmi les nombreux concepts qu’il introduit, le curry se distingue comme une technique puissante. Dans cet article, nous explorerons ce qu’est le curry, ses avantages et ses cas d’utilisation pratiques en JavaScript.

Qu’est-ce que le curry?

Le curry est un processus de transformation d’une fonction qui prend plusieurs arguments en une série de fonctions, chacune prenant un seul argument. Cela vous permet de décomposer des fonctions complexes en plus simples, ce qui les rend plus faciles à gérer et à réutiliser.

Exemple de curry

Considérez une fonction simple qui ajoute deux nombres:

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

Au lieu d’appeler Add (2, 3), nous pouvons le curry:

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

Voici comment vous pouvez utiliser la fonction curry:

const addTwo = curriedAdd(2);  
console.log(addTwo(3)); // Outputs: 5

Pourquoi utiliser le curry?

1. Réutilisabilité du code: Le curry vous permet de créer efficacement des fonctions spécialisées. Par exemple, si vous avez souvent besoin d’ajouter une valeur spécifique, vous pouvez créer une fonction spécifique avec cette valeur pré-remplie.
2. Fonctions d’ordre supérieur: Le curry s’aligne magnifiquement avec des fonctions d’ordre supérieur, vous permettant de passer les fonctions comme des arguments ou de les renvoyer comme des valeurs, améliorant le paradigme de programmation fonctionnelle.
3. Application partielle: Le curry permet une application partielle, ce qui signifie que vous pouvez créer une nouvelle fonction en fixant certains des arguments de la fonction d’origine. Cela peut conduire à un code plus propre et à une meilleure abstraction.

Implémentation de curry en javascript

Bien que vous puissiez implémenter manuellement le curry comme indiqué ci-dessus, les bibliothèques comme Lodash fournissent une méthode de curry intégrée. Voici comment l’utiliser:

const _ = require('lodash');  
const curriedMultiply = _.curry((a, b) => a * b);  
const double = curriedMultiply(2);  
console.log(double(5)); // Outputs: 10  

Cas d’utilisation du monde réel

Gestion des événements: Le curry peut simplifier les fonctions de gestionnaire d’événements où vous souhaitez transmettre des paramètres supplémentaires sans avoir besoin de fermetures excessives.

const handleClick = (param) => (event) => {  
    console.log(param, event);  
};  
const buttonClickHandler = handleClick('Button 1');  
document.querySelector('#myButton').addEventListener('click', buttonClickHandler);

Demandes d’API: Lors de la création de fonctions pour effectuer des appels d’API qui nécessitent que certains paramètres soient corrigés, le curry vous permet de créer facilement des méthodes dédiées pour des points de terminaison spécifiques.

Fonctions du middleware: Dans des frameworks comme Express.js et des bibliothèques comme Redux, vous pouvez utiliser le curry pour créer du middleware qui nécessite une configuration spécifique, ce qui rend votre code plus propre et plus modulaire.

Exemples:

Amélioration du middleware redux

// A curried function for creating action creators  
const createAction = (type) => (payload) => ({ type, payload });  

// Using the curried action creator  
const addTodo = createAction('ADD_TODO');  
const action = addTodo({ text: 'Learn currying' });  
// action is now { type: 'ADD_TODO', payload: { text: 'Learn currying' } }

Dans Redux, le curry peut être utilisé dans les créateurs d’action pour créer des actions avec des types ou des charges utiles spécifiques.

const logger = (level) => (store) => (next) => (action) => {  
    console.log(`[${level}] Dispatched action:`, action);  
    return next(action);  
};  
// Usage in store configuration  
const store = createStore(  
    reducer,  
    applyMiddleware(logger('INFO'))  // Applying the logger middleware  
);  

Composition de la fonction: Le curry simplifie la composition de la fonction dans les scénarios où vous souhaitez combiner plusieurs fonctions.

const compose = (f) => (g) => (x) => f(g(x));  
const addOne = (x) => x + 1;  
const double = (x) => x * 2;  
const addOneThenDouble = compose(double)(addOne);  
const result = addOneThenDouble(4);  // Result is 10 ((4 + 1) * 2)  

Conclusion

Le curry est une technique puissante en JavaScript qui améliore la réutilisabilité du code, la lisibilité et la maintenabilité. Lorsque vous adoptez des principes de programmation fonctionnelle, l’incorporation de curry peut conduire à des solutions élégantes à des problèmes complexes.