L’un des principes que chaque programmeur cherche à respecter est SEC (Ne vous répétez pas), avec Currying, nous verrons comment faire cela avec nos fonctions est assez simple et utile.
Ce contenu que j’ai publié en premier dans ma newsletter, la semaine suivant la publication de la newsletter publique dans mon blog, si vous voulez être le premier à le lire abonnez-vous
La façon dont nous écrivons normalement nos fonctions est:
//ES2015const divisible = (num, mod) => num % mod;//ES5var divisible = function(num, mod) { return num % mod;}Pour exécuter cette fonction, nous devons passer deux arguments, mais si nous voulions avoir une fonction qui vérifie exclusivement si un nombre est pair, nous devrions écrire une nouvelle fonction. À ce stade, il est utile d’avoir une fonction currifiée.
Car avant de comprendre comment fonctionne une fonction currifiée, nous devons connaître certains concepts.
les fonctions sont des citoyens de première classe, cela signifie que les fonctions sont des objets, vous pouvez les passer en arguments, stockés dans des variables, et renvoyer dans d’autres fonctions des fonctions d’ordre élevé en JavaScript
Une fermeture est lorsqu’une fonction est capable de se souvenir et d’accéder à une portée lexicale, même lorsque la fonction est exécutée en dehors de la portée lexicale. Comprendre les fermetures en JavaScript
Si une fonction reçoit plus d’un paramètre, elle peut être réécrite en tant que, une fonction qui prend un paramètre et renvoie une fonction, reçoit à son tour un paramètre et renvoie le résultat. Je calcule lambda en JavaScript
¿ Qu’est-ce que le Currying?
Curry est capable d’appeler une fonction avec moins de paramètres que prévu, il renvoie une fonction qui attend les paramètres restants et renvoie le résultat.
de cette façon, nous pourrions réécrire la fonction au début comme
//ES2015const divisible = mod => num => num % mod;//ES5var divisible = function (mod) { return function (num) { return num % mod; }}Pour appeler cette fonction, nous avons deux options
- Passer les arguments en exécutant les fonctions
divisible(10)(2)- Passer un argument et recevoir une fonction qui se souvient de cet argument
const divisibleEn3 = divisible(3);divisibleEn3(10)Comme nous écrivons une fonction, currificada n’est pas compliqué, mais nous pourrions le faire un peu plus naturellement comme fonction escribimoscualquier.
Pour cela, nous pouvons utiliser Lodash ou Ramda qui ont une méthode de curry, ce qui nous permet de carifier n’importe quelle fonction de cette manière.
import { __, curry, map } from 'ramda';const composeNombre = curry( (primer, apellido) => `${primer} ${apellido}`);const familiaJaimes = composeNombre(__, 'Jaimes')const nombres = console.log(map(familiaJaimes, nombres))Regardons un exemple plus utile tiré d’un guide de programmation fonctionnelle principalement adéquat
import { curry } from 'ramda';// Estas funciones las puedes conseguir dentro de Ramda o Lodashvar match = curry(function(what, str) { return str.match(what);});var replace = curry(function(what, replacement, str) { return str.replace(what, replacement);});var filter = curry(function(f, ary) { return ary.filter(f);});var map = curry(function(f, ary) { return ary.map(f);});var hasSpaces = match(/\s+/g);hasSpaces("hello world");// hasSpaces("spaceless");// nullfilter(hasSpaces, );// var findSpaces = filter(hasSpaces);// function(xs) { return xs.filter(function(x) { return x.match(/\s+/g) }) }findSpaces();// Avantages de Currying
- nous pouvons créer de nouvelles fonctions en passant simplement nos fonctions de base avec certains paramètres.
- Nous pouvons transformer n’importe quelle fonction qui fonctionne avec un seul élément en une fonction qui fonctionne avec une liste en l’enveloppant dans une carte.
- Vous pouvez écrire de petits morceaux de code plus faciles à réutiliser.
- Il est facile de les raisonner.
- Écrire des fonctions currifiées nous permettra de composer des fonctions.
