Programmation fonctionnelle en JavaScript : de A à Z pour Node.js

Programmation fonctionnelle en JavaScript : de A à Z

La programmation fonctionnelle (PF) est un paradigme qui considère les calculs comme l'évaluation de fonctions mathématiques et évite les changements d'état et les données mutables. Dans le contexte de JavaScript (Node.js), la PF devient un outil puissant pour créer un code prévisible, testable et évolutif. Dans cet article, nous allons explorer les concepts clés de la PF, des bases aux techniques avancées, en étayant la théorie par des exemples pratiques.

Les bases : Fonctions pures et immutabilité

Au cœur de la PF se trouvent deux principes : les fonctions pures et l'immutabilité (données immuables).

Une fonction pure retourne toujours le même résultat pour les mêmes arguments et n'a pas d'effets secondaires (elle ne modifie pas les variables externes, n'affiche rien dans la console, n'effectue pas de requêtes API).

// Fonction pureconst add = (a, b) => a + b;

// Fonction impure (effet secondaire — modification d'une variable externe)let counter = 0;const increment = () => counter++;

L'immutabilité signifie que les données ne sont pas modifiées directement, mais que de nouvelles copies sont créées avec les modifications souhaitées. En JavaScript, on utilise pour cela des méthodes qui retournent de nouveaux objets/tableaux.

// Mise à jour immuable d'un objetconst user = { name: 'Alice', age: 30 };const updatedUser = { ...user, age: 31 }; // Création d'un nouvel objet

// Mise à jour immuable d'un tableauconst numbers = [1, 2, 3];const newNumbers = [...numbers, 4]; // [1, 2, 3, 4]

Fermetures et fonctions d'ordre supérieur

Une fermeture est une fonction qui "se souvient" de son environnement lexical même après que la fonction externe a terminé son exécution. C'est la base de nombreux motifs en PF.

const createMultiplier = (factor) => {  // Fonction interne — fermeture  return (number) => number * factor;};

const double = createMultiplier(2);console.log(double(5)); // 10

Les fonctions d'ordre supérieur sont des fonctions qui prennent d'autres fonctions comme arguments ou les retournent. Les exemples classiques sont map, filter, reduce.

const numbers = [1, 2, 3, 4, 5];

// map — transforme chaque élémentconst doubled = numbers.map(n => n * 2); // [2, 4, 6, 8, 10]

// filter — sélectionne les éléments selon une conditionconst even = numbers.filter(n => n % 2 === 0); // [2, 4]

// reduce — réduit le tableau à une seule valeurconst sum = numbers.reduce((acc, n) => acc + n, 0); // 15

Composition de fonctions et curryfication

La composition de fonctions consiste à combiner plusieurs fonctions en une seule, où le résultat d'une fonction est passé en entrée à la suivante. Cela permet de construire des opérations complexes à partir de blocs simples et réutilisables.

const compose = (...fns) => (x) => fns.reduceRight((acc, fn) => fn(acc), x);

const trim = (str) => str.trim();const toLowerCase = (str) => str.toLowerCase();const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);

const processName = compose(capitalize, toLowerCase, trim);console.log(processName('  JOHN DOE  ')); // 'John doe'

La curryfication est la transformation d'une fonction à plusieurs arguments en une séquence de fonctions, chacune prenant un seul argument. Cela simplifie l'application partielle et la composition.

// Fonction normaleconst multiply = (a, b, c) => a * b * c;

// Version curryfiéeconst curriedMultiply = (a) => (b) => (c) => a * b * c;

console.log(curriedMultiply(2)(3)(4)); // 24

// Application partielleconst multiplyBy2 = curriedMultiply(2);const multiplyBy2And3 = multiplyBy2(3);console.log(multiplyBy2And3(5)); // 30

Exemple pratique : traitement de données dans Node.js