Fonctions pures en JavaScript et comment les créer

Les fonctions pures sont des fonctions qui ne produisent pas d'effets secondaires et, lorsqu'elles sont appelées avec les mêmes paramètres d'entrée, renverront toujours la même sortie.

Vous pouvez utiliser des fonctions pures pour vous assurer que votre code est propre, maintenable et testable. Ces fonctions sont idéales pour ces tâches car elles sont prévisibles et ne modifient pas les états externes.

Ils sont également plus faciles à déboguer, ce qui les rend utiles pour développer des systèmes logiciels complexes. Ici, vous explorerez les fonctions pures en JavaScript, leurs caractéristiques et leurs avantages.

Caractéristiques d'une fonction pure

Pour une fonction pour être « pure », elle doit satisfaire à quelques exigences.

Valeur de retour constante

Une fonction pure doit toujours renvoyer la même valeur avec la même entrée, quel que soit le nombre de fois où elle est appelée.

Par exemple, considérons la fonction ci-dessous :

fonctionmultiplier(un B) {
retour un B;
}

Le multiplier fonction dans l'exemple ci-dessus renverra toujours le produit de ses deux arguments. Étant donné le même ensemble d'arguments, il a une valeur de retour constante.

Appeler cette fonction plusieurs fois avec les mêmes arguments donnera le même résultat à chaque fois. Par exemple:

multiplier(2, 3); // renvoie 6
multiplier(2, 3); // renvoie 6
multiplier(2, 3); // renvoie 6

Sinon, considérez l'exemple ci-dessous :

fonctionmultiplieRandomNumber(nombre) {
retour nombre * Mathématiques.sol(Mathématiques.aléatoire() * 10);
}
multiplieNombreRandom(5); // Résultats imprévisibles
multiplieNombreRandom(5); // Résultats imprévisibles
multiplieNombreRandom(5); // Résultats imprévisibles

Le multiplieRandomNumber fonction ci-dessus renverra des résultats différents à chaque fois que vous l'appelez, ce qui la rend impure. Les résultats de cette fonction sont imprévisibles, il est donc difficile de tester les composants qui en dépendent.

Pas d'effets secondaires

Une fonction pure ne doit produire aucun effet secondaire. Un effet secondaire fait référence à toute modification d'état ou de comportement en dehors de la portée de la fonction, telle que la modification de variables globales, la sortie de la console, les requêtes réseau ou la manipulation du DOM.

Lorsqu'une fonction pure a un effet secondaire, elle n'est plus pure car elle affecte l'état externe et viole le principe de l'absence d'effets secondaires observables. Par conséquent, les fonctions pures évitent les effets secondaires pour s'assurer qu'elles ne modifient pas l'état du programme.

Par exemple, considérons l'exemple ci-dessous :

laisser compter = 0;
fonctionincrément() {
 compter++ ;
console.log (compter);
}
incrément(); // Journaux 1
incrément(); // Journaux 2
incrément(); // Journaux 3

Le incrément fonction dans cet exemple a pour effet secondaire de modifier le compter variable en dehors de son champ d'application. Il se connecte également à la console.

Cette fonction n'est pas pure car elle a un effet secondaire, ce qui peut rendre plus difficile la prédiction de sa sortie et son test isolément. Pour le rendre pur, vous pouvez le modifier pour prendre en compter variable comme argument et renvoie la valeur incrémentée sans modifier aucun état externe.

Ainsi:

fonctionincrément(compter) {
retour compter + 1;
}
incrément(1); // renvoie 2
incrément(1); // renvoie 2
incrément(1); // renvoie 2

La version du incrément La fonction dans l'exemple ci-dessus n'a aucun effet secondaire car elle ne modifie aucune variable externe et n'enregistre aucune valeur. De plus, quel que soit le nombre de fois que vous l'appelez, il renvoie la même valeur pour la même entrée. C'est donc une fonction pure.

Autres caractéristiques

En plus d'avoir une valeur de retour constante et de ne produire aucun effet secondaire, vous devez respecter les règles suivantes lorsque vous êtes création d'une fonction JavaScript que tu veux être pur :

• Votre fonction ne doit modifier aucun de ses arguments. Au lieu de cela, si une opération nécessite une mutation, faites une copie de l'argument et faites muter la copie.
• Votre fonction doit toujours avoir une valeur de retour. Si votre fonction n'a pas de valeur de retour ou d'effets secondaires, elle ne peut rien faire!
• Votre fonction ne doit dépendre d'aucun état extérieur.

Avantages des fonctions pures

Les fonctions pures présentent certains avantages par rapport aux fonctions impures, dont certaines incluent les suivantes.

Testabilité

Les fonctions pures sont faciles à tester car leur comportement d'entrée/sortie est bien défini. De plus, les fonctions pures ne dépendent pas de l'état externe ou des effets secondaires. Par conséquent, vous pouvez les tester de manière isolée sans vous soucier des dépendances ou des interactions avec d'autres parties du programme.

En revanche, tester des fonctions impures qui dépendent d'un état externe ou produisent des effets secondaires peut être plus difficile car leur comportement peut dépendre de l'état du programme ou d'autres facteurs externes. Cela peut compliquer la création de scénarios de test complets et garantir que la fonction se comporte correctement dans tous les scénarios.

Mémoïsation

Étant donné que les fonctions pures produisent toujours la même sortie pour la même entrée et ne produisent aucun effet secondaire, vous pouvez facilement les mémoriser.

En vous appuyant sur ces propriétés et en utilisant la mémorisation, vous pouvez mettre en cache le résultat d'un appel de fonction pur pour une entrée spécifique. Votre fonction peut alors renvoyer le résultat mis en cache la prochaine fois qu'elle est appelée avec la même entrée.

Mémoïsation des fonctions pures peut améliorer les performances d'un programme, en particulier pour les calculs coûteux qui traitent à plusieurs reprises la même entrée, sans se soucier des interférences avec l'état du programme.

En revanche, les fonctions impures peuvent produire des résultats différents pour la même entrée, en fonction de l'état du programme ou de facteurs externes. Cela les rend difficiles à mémoriser car le résultat mis en cache peut ne plus être valide si les dépendances ou l'état externe de la fonction changent entre les appels.

Concurrence

Étant donné que les fonctions pures ne modifient aucun état externe ni ne produisent d'effets secondaires, elles sont thread-safe. Vous pouvez les exécuter simultanément sans vous soucier des conditions de concurrence ou des problèmes de synchronisation.

En revanche, les fonctions impures peuvent être difficiles à exécuter simultanément car elles peuvent interférer les unes avec les autres ou produire un comportement inattendu lorsqu'elles sont exécutées en parallèle. Par exemple, si deux threads accèdent à la même variable globale et la modifient, ils peuvent écraser les modifications de l'autre ou produire des résultats incohérents.

Fonctions pures vs. Fonctions impures

Vous pouvez écrire des programmes en utilisant une combinaison de fonctions pures et impures, puisque chaque type a ses utilisations.

Les fonctions pures sont faciles à optimiser, tester et paralléliser, ce qui les rend adaptées à des cas d'utilisation tels que la programmation fonctionnelle, la mise en cache, les tests, la programmation parallèle et les tâches de traitement de données.

Cependant, les fonctions impures posent des problèmes de test et de simultanéité, mais sont utiles lorsque vous travaillez avec des structures de données modifiables ou lorsque vous interagissez avec des systèmes et des ressources externes.