Un guide débutant pour le curry dans JavaScript fonctionnel

Le curry, ou application partielle, est l'une des techniques fonctionnelles qui peuvent sembler déroutantes pour les personnes familières avec des façons plus traditionnelles d'écrire JavaScript. Mais lorsqu'il est appliqué correctement, il peut réellement rendre votre JavaScript fonctionnel plus lisible.

Les plats clés

• Le curry est une technique de programmation fonctionnelle qui permet l'application partielle des arguments d'une fonction, ce qui signifie que vous pouvez passer tout ou un sous-ensemble des arguments à laquelle une fonction attend. Si un sous-ensemble est passé, une fonction est renvoyée qui attend les arguments restants.
• Le curry peut rendre le code JavaScript plus lisible et flexible. Il permet la création d'une bibliothèque de petites fonctions facilement configurées qui se comportent de manière cohérente, sont rapides à utiliser et peuvent être comprises lors de la lecture de votre code.
• L'ordre des arguments est important lors du curry. L'argument qui est le plus susceptible d'être remplacé d'une variation à un autre devrait être le dernier argument transmis à la fonction d'origine.
• Certaines bibliothèques JavaScript fonctionnelles, telles que RAMDA, offrent des fonctions de curry flexibles qui peuvent éclater les paramètres requis pour une fonction et vous permettre de les passer individuellement ou en groupes pour créer des variations currences personnalisées. Si vous prévoyez d'utiliser le curry largement, l'utilisation de ces bibliothèques est recommandée.

plus lisible et plus flexible

L'un des avantages présentés pour le JavaScript fonctionnel est un code plus court, plus serré qui revient au point dans le moins de lignes possible, et avec moins de répétition. Parfois, cela peut se faire au détriment de la lisibilité; Jusqu'à ce que vous soyez familier avec le fonctionnement de la programmation fonctionnelle, le code écrit de cette manière peut être plus difficile à lire et à comprendre.

Si vous avez déjà rencontré le terme curry, mais je n'ai jamais su ce que cela signifiait, vous pouvez être pardonné de le considérer comme une technique exotique et épicée que vous n'aviez pas besoin de vous soucier. Mais le curry est en fait un concept très simple, et il aborde certains problèmes familiers lorsqu'il s'agit d'arguments de fonction, tout en ouvrant une gamme d'options flexibles pour le développeur.

Qu'est-ce que le curry?

brièvement, le curry est un moyen de construire des fonctions qui permet l'application partielle des arguments d'une fonction. Cela signifie que vous pouvez transmettre tous les arguments à laquelle une fonction attend et obtenir le résultat, ou transmettre un sous-ensemble de ces arguments et récupérer une fonction qui attend le reste des arguments. C'est vraiment aussi simple.

Le curry est élémentaire dans des langues telles que Haskell et Scala, qui sont construites autour de concepts fonctionnels. JavaScript a des capacités fonctionnelles, mais le curry n'est pas intégré par défaut (du moins pas dans les versions actuelles de la langue). Mais nous connaissons déjà des astuces fonctionnelles, et nous pouvons aussi faire du curry, un travail pour nous en javascript.

Pour vous donner une idée de la façon dont cela pourrait fonctionner, créons notre première fonction au curry en JavaScript, en utilisant une syntaxe familière pour construire la fonctionnalité de curry que nous voulons. Par exemple, imaginons une fonction qui accueille quelqu'un par son nom. Nous savons tous comment créer une fonction de salut simple qui prend un nom et une salutation, et enregistre la salutation avec le nom à la console:

var greet = function(greeting, name) {
  console.log(greeting + ", " + name);
};
greet("Hello", "Heidi"); //"Hello, Heidi"

Cette fonction nécessite à la fois le nom et la salutation pour être transmis comme arguments afin de fonctionner correctement. Mais nous avons pu réécrire cette fonction en utilisant un curry imbriqué simple, afin que la fonction de base ne nécessite qu'une salutation, et elle renvoie une autre fonction qui prend le nom de la personne que nous voulons saluer.

Notre premier curry

var greetCurried = function(greeting) {
  return function(name) {
    console.log(greeting + ", " + name);
  };
};

Ce petit ajustement à la façon dont nous avons écrit la fonction nous permet de créer une nouvelle fonction pour tout type de salutation et de passer cette nouvelle fonction le nom de la personne que nous voulons saluer:

var greetHello = greetCurried("Hello");
greetHello("Heidi"); //"Hello, Heidi"
greetHello("Eddie"); //"Hello, Eddie"

Nous pouvons également appeler directement la fonction du curry d'origine, simplement en passant chacun des paramètres dans un ensemble séparé de parenthèses, l'une juste après l'autre:

greetCurried("Hi there")("Howard"); //"Hi there, Howard"

Pourquoi ne pas essayer ceci dans votre navigateur?

Curry toutes les choses!

Ce qui est cool, c'est maintenant que nous avons appris à modifier notre fonction traditionnelle pour utiliser cette approche pour gérer les arguments, nous pouvons le faire avec autant d'arguments que nous le souhaitons:

var greetDeeplyCurried = function(greeting) {
  return function(separator) {
    return function(emphasis) {
      return function(name) {
        console.log(greeting + separator + name + emphasis);
      };
    };
  };
};

Nous avons la même flexibilité avec quatre arguments que nous en avons avec deux. Peu importe jusqu'où la nidification va, nous pouvons créer de nouvelles fonctions personnalisées pour saluer autant de personnes que nous choisissons de nombreuses façons que de nos objectifs:

var greetAwkwardly = greetDeeplyCurried("Hello")("...")("?");
greetAwkwardly("Heidi"); //"Hello...Heidi?"
greetAwkwardly("Eddie"); //"Hello...Eddie?"

De plus, nous pouvons passer autant de paramètres que nous le souhaitons lors de la création de variations personnalisées sur notre fonction au curry d'origine, créant de nouvelles fonctions qui sont capables de prendre le nombre approprié de paramètres supplémentaires, chacun passé séparément dans son propre ensemble de parenthèses:

var sayHello = greetDeeplyCurried("Hello")(", ");
sayHello(".")("Heidi"); //"Hello, Heidi."
sayHello(".")("Eddie"); //"Hello, Eddie."

et nous pouvons définir les variations subordonnées tout aussi facilement:

var askHello = sayHello("?");
askHello("Heidi"); //"Hello, Heidi?"
askHello("Eddie"); //"Hello, Eddie?"

Currying Fonctions traditionnelles

Vous pouvez voir à quel point cette approche est puissante, surtout si vous devez créer de nombreuses fonctions personnalisées très détaillées. Le seul problème est la syntaxe. Au fur et à mesure que vous créez ces fonctions au curry, vous devez garder les fonctions renvoyées à la nidification et les appeler avec de nouvelles fonctions qui nécessitent plusieurs ensembles de parenthèses, chacun contenant son propre argument isolé. Il peut devenir désordonné.

Pour résoudre ce problème, une approche consiste à créer une fonction de curry rapide et sale qui prendra le nom d'une fonction existante qui a été écrite sans tous les rendements imbriqués. Une fonction de curry devrait retirer la liste des arguments pour cette fonction et les utiliser pour renvoyer une version au curry de la fonction d'origine:

var greet = function(greeting, name) {
  console.log(greeting + ", " + name);
};
greet("Hello", "Heidi"); //"Hello, Heidi"

Pour l'utiliser, nous lui transmettons le nom d'une fonction qui prend un certain nombre d'arguments, ainsi que autant d'arguments que nous voulons pré-populer. Ce que nous récupérons est une fonction qui attend les arguments restants:

var greetCurried = function(greeting) {
  return function(name) {
    console.log(greeting + ", " + name);
  };
};

Et comme auparavant, nous ne sommes pas limités en termes de nombre d'arguments que nous voulons utiliser lors de la construction de fonctions dérivées de notre fonction originale au curry:

var greetHello = greetCurried("Hello");
greetHello("Heidi"); //"Hello, Heidi"
greetHello("Eddie"); //"Hello, Eddie"

devenir sérieux au sujet du curry

Notre petite fonction de curry peut ne pas gérer tous les cas de bord, tels que les paramètres manquants ou facultatifs, mais il fait un travail raisonnable tant que nous restons stricts sur la syntaxe pour passer des arguments.

Certaines bibliothèques JavaScript fonctionnelles telles que RAMDA ont des fonctions de curry plus flexibles qui peuvent éclater les paramètres requis pour une fonction et vous permettre de les passer individuellement ou en groupes pour créer des variations currencales personnalisées. Si vous voulez utiliser le curry largement, c'est probablement la voie à suivre.

quelle que soit la façon dont vous choisissez d'ajouter du curry à votre programmation, que vous souhaitiez simplement utiliser des parenthèses imbriquées ou que vous préférez inclure une fonction de transport plus robuste, proposer une convention de dénomination cohérente pour vos fonctions au curry vous aidera à faire de votre code votre code plus lisible. Chaque variation dérivée d'une fonction devrait avoir un nom qui indique clairement comment il se comporte et quels arguments il attend.

Ordre d'argument

Une chose qui est importante à garder à l'esprit lorsque le curry est l'ordre des arguments. En utilisant l'approche que nous avons décrite, vous voulez évidemment l'argument que vous êtes le plus susceptible de remplacer d'une variation à la suivante pour être le dernier argument transmis à la fonction d'origine.

Réfléchir à l'avance à l'ordre des arguments facilitera la planification du curry et l'appliquera à votre travail. Et considérer l'ordre de vos arguments en termes de moins le plus susceptible de changer n'est pas une mauvaise habitude de se lancer de toute façon lors de la conception de fonctions.

Conclusion

Le currying est une technique incroyablement utile de JavaScript fonctionnel. Il vous permet de générer une bibliothèque de petites fonctions facilement configurées qui se comportent de manière cohérente, sont rapides à utiliser et qui peuvent être comprises lors de la lecture de votre code. L'ajout de curry à votre pratique de codage encouragera l'utilisation de fonctions partiellement appliquées tout au long de votre code, en évitant beaucoup de répétitions potentielles, et peut vous aider à faire de meilleures habitudes sur la dénomination et la gestion des arguments de fonction.

Si vous avez apprécié, ce post, vous pourriez également aimer certains des autres de la série:

• Une introduction au JavaScript fonctionnel
• Fonctions d'ordre supérieur en javascript
• Recursion dans JavaScript fonctionnel

Questions fréquemment posées (FAQ) sur le curry dans JavaScript fonctionnel

Quelle est la principale différence entre le curry et l'application partielle dans JavaScript?

Le curry et l'application partielle sont les deux techniques en JavaScript qui vous permettent de pré-remplir certains des arguments d'une fonction. Cependant, ils diffèrent dans leur mise en œuvre et leur utilisation. Le curry est un processus de programmation fonctionnelle où une fonction avec plusieurs arguments est transformée en une séquence de fonctions, chacune avec un seul argument. D'un autre côté, l'application partielle fait référence au processus de fixation d'un certain nombre d'arguments à une fonction, produisant une autre fonction d'arité plus petite. Alors que le curry produit toujours des fonctions unares (1-arity) imbriquées, l'application partielle peut produire des fonctions de toute aité.

Comment le curry améliore-t-il la lisibilité et la maintenabilité du code dans JavaScript?

Le curry peut améliorer considérablement le code du code lisibilité et maintenabilité en JavaScript. En décomposant les fonctions complexes en fonctions unares plus simples, le curry rend le code plus lisible et plus facile à comprendre. Il favorise également un code plus propre et plus modulaire, car chaque fonction exécute une seule tâche. Cette modularité rend le code plus facile à maintenir et à déboguer, car les problèmes peuvent être isolés à des fonctions spécifiques.

Pouvez-vous fournir un exemple de curry en javascript?

Bien sûr, considérons un exemple simple de une fonction qui ajoute trois nombres. Sans curry, la fonction peut ressembler à ceci:

Fonction Ajouter (a, b, c) {
renvoie un b c;
}
console.log (add (1, 2, 3 )); // Sorties: 6

Avec le curry, la même fonction serait écrite comme:

Fonction Add (a) {
return function (b) {
function de retour (c ) {
Renvoie un b c;
}
}
}
console.log (add (1) (2) (3)); // Sorties: 6

Quelles sont les limites ou les inconvénients de l'utilisation de curry en javascript?

Bien que le curry ait ses avantages, il a également certaines limites. L'un des principaux inconvénients est qu'il peut rendre le code plus difficile à comprendre pour ceux qui ne connaissent pas le concept, en particulier lorsqu'ils traitent des fonctions avec un grand nombre d'arguments. Il peut également conduire à des frais généraux en raison de la création de fermetures supplémentaires. En outre, il peut rendre les appels de fonction plus verbeux, car chaque argument doit être transmis dans un ensemble distinct de parenthèses.

Comment le curry est-il lié aux fonctions d'ordre supérieur en javascript?

Le curry est étroitement est étroitement. lié au concept de fonctions d'ordre supérieur en JavaScript. Une fonction d'ordre supérieur est une fonction qui prend une ou plusieurs fonctions comme des arguments, renvoie une fonction comme résultat, ou les deux. Étant donné que le curry consiste à transformer une fonction en une séquence d'appels de fonction, il implique intrinsèquement l'utilisation de fonctions d'ordre supérieur.

Le curry peut être utilisé avec les fonctions de flèche en javascript?

Oui, le curry peut être utilisé avec les fonctions fléchées en javascript. En fait, la syntaxe des fonctions de flèche les rend particulièrement bien adaptés au curry. Voici comment la fonction ADD précédente pourrait être écrite à l'aide de fonctions fléchées:

const Add = a => b => c => a b c;
console.log (add (1) (2) (3) )); // Sorties: 6

Le curry est-il utilisé dans les bibliothèques ou les frameworks JavaScript populaires?

Oui, le currying est utilisé dans plusieurs bibliothèques et frameworks JavaScript populaires. Par exemple, il s'agit d'un concept fondamental dans des bibliothèques comme Ramda et Lodash, qui fournissent des fonctions d'utilité pour la programmation fonctionnelle en JavaScript. Il est également utilisé dans Redux, une bibliothèque de gestion d'État populaire pour React.

Comment le currying aide-t-il à la composition des fonctions en JavaScript?

Le curry peut être très utile en ce qui concerne la composition de la fonction en JavaScript. La composition de la fonction est le processus de combinaison de deux ou plusieurs fonctions pour créer une nouvelle fonction. Étant donné que le curry vous permet de créer des fonctions unaires, il simplifie la composition des fonctions en vous assurant que chaque fonction a exactement une entrée et une sortie.

Toutes les fonctions JavaScript peuvent-elles être curry?

En théorie, n'importe quel javascript La fonction avec deux arguments ou plus peut être curry. Cependant, dans la pratique, il peut ne pas toujours être pratique ou bénéfique de currer une fonction. Par exemple, le curry peut ne pas être utile pour les fonctions qui doivent être appelées avec différents nombres d'arguments à différents moments.

Comment le curry affecte-t-il les performances du code javascrip Votre code plus lisible et modulaire, il peut également avoir un léger impact sur les performances. C'est parce que chaque fois que vous currez une fonction, vous créez de nouvelles fermetures. Cependant, dans la plupart des cas, l'impact sur les performances est négligeable et est contrebalancé par les avantages d'une amélioration de la lisibilité et de la maintenabilité du code.

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!