JavaScript Academy · Leçon

Fonctions pures et effets secondaires

Écrivez des fonctions prévisibles et faciles à tester.

Fonctions pures et effets secondaires est une leçon JavaScript Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage JavaScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours JavaScript Academy comprend 4 leçons au total.

Ce qui rend une fonction pure

Une fonction pure possède deux propriétés : avec les mêmes entrées, elle renvoie toujours la même sortie et ne provoque aucun effet secondaire observable. Les fonctions pures sont prévisibles et faciles à tester.

function add(a, b) {
  return a + b;
}
console.log(add(2, 3));
console.log(add(2, 3)); // always 5

Sortie déterministe

La pureté implique le déterminisme. Les mêmes arguments doivent toujours produire le même résultat, sans dépendre d’un état caché, du temps ou du hasard.

function double(n) {
  return n * 2;
}
console.log(double(10)); // always 20

Qu’est-ce qu’un effet secondaire

Un effet secondaire est tout ce qu’une fonction fait en plus de renvoyer une valeur : journaliser, modifier un état externe, écrire dans le stockage, effectuer des appels réseau ou modifier ses arguments.

let total = 0;
function impureAdd(n) {
  total += n;     // side effect: mutates outer state
  return total;
}
console.log(impureAdd(5));
console.log(impureAdd(5)); // 5 then 10, not pure

Dépendre d’un état externe

Lire également un état externe modifiable rompt la pureté, car la sortie change alors que l’argument reste identique.

let rate = 1.5;
function priceImpure(x) {
  return x * rate; // depends on outside variable
}
console.log(priceImpure(10)); // 15
rate = 2;
console.log(priceImpure(10)); // 20 - different result

Rendre une fonction pure

Passez en arguments tout ce dont la fonction a besoin. Son résultat dépend alors uniquement de ses entrées.

function price(x, rate) {
  return x * rate;
}
console.log(price(10, 1.5)); // 15
console.log(price(10, 2));   // 20

Modifier des arguments n’est pas pur

Modifier un objet ou un tableau transmis à une fonction constitue un effet secondaire que l’appelant peut observer. Les fonctions pures laissent leurs entrées intactes.

function impurePush(arr, x) {
  arr.push(x);   // mutates caller array
  return arr;
}
const a = [1, 2];
impurePush(a, 3);
console.log(a); // [1, 2, 3] - caller changed

Renvoyer de nouvelles valeurs

Une version pure construit et renvoie une nouvelle valeur au lieu de modifier l’entrée.

function pureAppend(arr, x) {
  return [...arr, x];
}
const a = [1, 2];
const b = pureAppend(a, 3);
console.log(a); // [1, 2] unchanged
console.log(b); // [1, 2, 3]

Pourquoi la pureté est utile

Les fonctions pures sont triviales à tester (aucune préparation ni simulation), peuvent être mises en cache en toute sécurité (mémorisées) et peuvent être exécutées dans n’importe quel ordre ou en parallèle sans risque. Elles permettent de raisonner localement sur le code.

function square(n) { return n * n; }
console.log([1, 2, 3].map(square)); // [1, 4, 9]

Isoler l’impureté

Vous ne pouvez pas éviter tous les effets secondaires : les applications doivent journaliser, récupérer des données et afficher du contenu. L’objectif est de repousser les effets vers les limites de l’application et de conserver une logique centrale pure.

function computeTotal(items) {
  return items.reduce((s, i) => s + i.price, 0);
}
const total = computeTotal([{ price: 5 }, { price: 7 }]);
console.log(total); // 12 - pure core, log at the edge

Transparence référentielle

Un appel pur peut être remplacé par son résultat sans modifier le comportement. add(2, 3) est interchangeable avec 5 n’importe où. Cette propriété s’appelle la transparence référentielle.

function add(a, b) { return a + b; }
const x = add(2, 3) + add(2, 3);
const y = 5 + 5;
console.log(x === y); // true

Repérer l’impureté

Surveillez certains indices : console, Math.random, Date.now, les affectations à des variables externes ou la modification des arguments. Tous ces éléments rendent une fonction impure.

function pureRoll(seed) {
  return (seed * 1103515245 + 12345) % 100;
}
console.log(pureRoll(42)); // deterministic, testable

Vérification rapide

Identifier les fonctions pures.

Récapitulatif

Les fonctions pures sont déterministes et exemptes d’effets secondaires : aucune modification externe, aucune entrée-sortie, aucune modification des arguments. Passez les dépendances en arguments et renvoyez de nouvelles valeurs au lieu de modifier les existantes. La pureté facilite les tests, la mémorisation, la transparence référentielle et l’exécution sûre en parallèle. Gardez le cœur de la logique pur et repoussez les effets vers les limites de l’application.

Questions Fréquemment Posées

La leçon « Fonctions pures et effets secondaires » est-elle gratuite ?

Oui — le texte complet de « Fonctions pures et effets secondaires » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours JavaScript Academy, passe à CoddyKit PRO. Le cours JavaScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Fonctions pures et effets secondaires » ?

Écrivez des fonctions prévisibles et faciles à tester. Tu pratiques JavaScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer JavaScript Academy ?

Aucune expérience préalable n'est requise. JavaScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Fonctions pures et effets secondaires » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon JavaScript Academy ?

Oui. Chaque leçon JavaScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à JavaScript Academy