Programmation fonctionnelle en JavaScript : bases et pratique

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Introduction à la programmation fonctionnelle en JavaScript

La programmation fonctionnelle (PF) est un paradigme de programmation dans lequel les calculs sont considérés comme l'application de fonctions mathématiques. Contrairement à l'approche impérative, où nous écrivons une séquence d'instructions modifiant l'état du programme, le style fonctionnel se concentre sur ce qui doit être calculé, plutôt que comment le faire.

JavaScript, étant un langage multi-paradigme, est parfaitement adapté à la programmation fonctionnelle. Dans l'environnement Node.js, cette approche est particulièrement utile pour le traitement des données, le travail avec les flux et la construction d'applications serveur fiables. Dans cet article, nous allons examiner les concepts clés de la PF à l'aide d'exemples pratiques.

Principes fondamentaux de la programmation fonctionnelle

Fonctions pures (Pure Functions)

Une fonction pure est une fonction qui :

Retourne toujours le même résultat pour les mêmes arguments (déterminisme).
N'a pas d'effets secondaires (ne modifie pas les variables externes, n'affiche rien dans la console, n'écrit pas dans des fichiers).

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

// Fonction impure (effet secondaire — affichage dans la console)const impureAdd = (a, b) => {    console.log(`Addition de ${a} et ${b}`);    return a + b;};

// Fonction impure (dépend de l'état externe)let counter = 0;const increment = () => ++counter;

Avantages des fonctions pures : elles sont faciles à tester, à déboguer et à paralléliser. Elles sont prévisibles et ne dépendent pas du contexte d'exécution.

Immutabilité (Immutability)

L'immutabilité signifie que les données, une fois créées, ne sont pas modifiées. Au lieu de modifier un objet existant, nous créons une nouvelle copie de celui-ci avec les modifications souhaitées.

// Approche mutable (mauvaise)const user = { name: 'Ivan', age: 30 };user.age = 31; // Modification directe

// Approche immuable (bonne)const user2 = { name: 'Maria', age: 25 };const updatedUser = { ...user2, age: 26 };// L'objet original user2 reste inchangé

// Travail avec les tableauxconst numbers = [1, 2, 3];const newNumbers = [...numbers, 4]; // [1, 2, 3, 4]// numbers reste [1, 2, 3]

Dans Node.js, l'immutabilité est particulièrement importante lors du travail avec les requêtes et l'état de l'application, afin d'éviter des mutations inattendues dans le code asynchrone.

Fonctions d'ordre supérieur et fermetures

Fonctions d'ordre supérieur (Higher-Order Functions)

Ce sont des fonctions qui prennent d'autres fonctions comme arguments ou les retournent. Les méthodes intégrées des tableaux map, filter, reduce en sont des exemples classiques.

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

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

// filter — conserve les éléments selon une conditionconst evens = 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

Fermetures (Closures)

Une fermeture est une fonction qui « se souvient » des variables de la portée dans laquelle elle a été créée, même après que cette portée a terminé son exécution.

const createCounter = () => {    let count = 0; // Variable privée    return () => ++count;};

const counter1 = createCounter();console.log(counter1()); // 1console.log(counter1()); // 2

const counter2 = createCounter();console.log(counter2()); // 1 (compteur indépendant)

Les fermetures sont largement utilisées pour créer des fabriques de fonctions et encapsuler l'état dans un style fonctionnel.