Applications avancées de programmation fonctionnelle en JavaScript

JavaScript est un langage qui prend en charge la programmation fonctionnelle. L'idée principale de la programmation fonctionnelle est de séparer les données et les fonctions, en soulignant l'immuabilité et l'absence d'effets secondaires du programme. La programmation fonctionnelle a une syntaxe concise et présente de grands avantages en termes d'organisation et de test du code. Cet article présentera quelques applications avancées de programmation fonctionnelle en JavaScript.

1. Fonction pure

En programmation fonctionnelle, l'un des concepts les plus fondamentaux est la pureté de la fonction. Une fonction pure signifie qu'une fonction qui saisit les mêmes paramètres à tout moment obtiendra le même résultat sans effets secondaires. L'avantage de ce type de fonction est qu'elle est facile à mettre en cache dans un environnement concurrent, et elle est également utile pour gérer la récursion et éviter des calculs répétés inutiles. Un ajout peut être implémenté via la fonction suivante :

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

Cette fonction est une fonction pure typique. Parce qu'il n'aura de sortie que sous une entrée spécifique. Cependant, un effet secondaire courant est qu'une fonction affecte l'environnement dans lequel elle se trouve, comme par exemple en modifiant la valeur de certaines variables ou en appelant des fonctions externes. Par conséquent, dans la programmation fonctionnelle, ces effets secondaires doivent être évités autant que possible, c'est-à-dire que des fonctions pures doivent être écrites autant que possible.

2. Fonctions d'ordre supérieur

Une fonction d'ordre supérieur est une fonction qui reçoit une ou plusieurs fonctions en tant que paramètres ou renvoie une fonction en tant que valeur de retour. Ce type de fonction peut répondre aux exigences de manière plus flexible et réduire la duplication de code. La fonction suivante est un exemple de fonction d'ordre supérieur, qui peut accepter une fonction comme paramètre et renvoyer une nouvelle fonction :

function compose(fn1, fn2) {
  return function(value) {
    return fn1(fn2(value));
  };
}

Cette fonction renvoie une nouvelle fonction, qui appellera d'abord fn2 puis transmettra le résultat à fn1 comme paramètre. Vous pouvez utiliser cette fonction pour combiner plusieurs fonctions, comme indiqué ci-dessous :

function add10(val) {
  return val + 10;
}

function square(val) {
  return val * val;
}

var result = compose(add10, square)(5);
console.log(result); // 35 (5 + 10) * (5 + 10)

Dans cet exemple, nous ajoutons 10 et square à la fonction de composition. Cette fonction renvoie une nouvelle fonction. Nous transmettons à cette nouvelle fonction une valeur 5. Finalement, les résultats que nous attendions ont été renvoyés.

3. Currying

Le currying est une technique qui transforme une fonction en une forme n'acceptant qu'un seul argument à la fois. La conversion de la valeur d'une fonction multiparamétrique en une chaîne de fonctions à un seul paramètre peut également être considérée comme une sorte de « prétraitement » de la fonction, afin qu'elle puisse être utilisée de manière plus flexible. La fonction suivante peut implémenter la somme de plusieurs valeurs :

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

add(1, 2, 3); // 6

Et cette fonction peut être implémentée étape par étape via le currying :

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

add(1)(2)(3); // 6

Comme vous pouvez le voir, grâce au currying, la fonction add reçoit d'abord le premier paramètre et renverra une fonction qui reçoit un deuxième argument. Maintenant, nous pouvons transmettre les paramètres un par un, en renvoyant une nouvelle fonction à chaque fois, jusqu'à ce que finalement la fonction soit renvoyée.

4. Composition de fonctions

La composition de fonctions consiste à combiner deux ou plusieurs fonctions ensemble pour générer une nouvelle fonction. Cette nouvelle fonction appellera les fonctions entrantes de gauche à droite, puis combinera leurs résultats ensemble. En programmation fonctionnelle, la composition de fonctions est le moyen le plus efficace de combiner de petites fonctions en grandes fonctions. Nous pouvons combiner plusieurs fonctions à l’aide de la fonction composer. Voici un exemple de composition de fonction :

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

function multiply(b) {
  return b * 2;
}

const addingAndMultiplying = compose(multiply, add);

addingAndMultiplying (10); // 40                                                        

Dans cet exemple, nous définissons d'abord deux fonctions simples ajouter et multiplier, puis utiliser la fonction de composition composer pour les combiner en une nouvelle fonction. Cette nouvelle fonction peut appeler plusieurs fonctions à la fois et combiner leurs résultats. Lorsque nous passons 10 à la fonction addAndMultiplying, elle appelle d'abord la fonction add, qui ajoute 10 à 10, nous donnant 20. Ensuite, il transmet le résultat à la fonction multiplier, qui multiplie 20 par 2, nous donnant le résultat final de 40.

5. L'application combinée de la fonction curry et de la composition

La combinaison de la fonction curry et de la composition est souvent utilisée dans la programmation fonctionnelle. Par exemple, nous pouvons définir et composer certaines fonctions pour effectuer certaines opérations :

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

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

function subtract(a) {
  return function(b) {
    return b - a;
  };
}

function divide(a) {
  return function(b) {
    return b / a;
  };
}

const discount = compose(subtract(10), multiply(0.1), add(20), divide(2));

discount(50); // 5

Dans cet exemple, nous définissons d'abord quatre fonctions simples ajouter, multiplier, soustraire et diviser, et les transformer à l'aide de la fonction currying . En utilisant le combinateur de fonctions composer, nous pouvons associer toutes les opérations et obtenir le résultat final. Cet exemple montre comment combiner plusieurs fonctions simples en une seule fonction à l'aide du curry et de la composition.

Conclusion

Cet article a présenté certaines applications avancées pour l'implémentation de la programmation fonctionnelle en JavaScript, telles que les fonctions pures, les fonctions d'ordre supérieur, le curry, la composition de fonctions et la composition de fonctions au curry. Ces concepts sont basés sur certaines idées fondamentales de la programmation fonctionnelle, telles que la pureté et l'immuabilité des fonctions. Ces techniques peuvent aider à écrire du code plus flexible, réutilisable et facilement testable. Si vous souhaitez en savoir plus sur la programmation fonctionnelle, vous pouvez consulter la documentation de Ramda.js, une bibliothèque qui fournit une multitude d'outils de programmation fonctionnelle.

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!