TypeScript Academy · Leçon

Fonctions pures et immuabilité

Écrire des fonctions prévisibles sans effets secondaires.

Fonctions pures et immuabilité est une leçon TypeScript 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 TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.

Qu’est-ce qu’une fonction pure ?

Une fonction pure renvoie la même sortie pour une même entrée et n’a aucun effet de bord. Elle ne lit ni n’écrit dans un état externe, ne modifie pas ses arguments et n’effectue pas d’opérations d’entrées-sorties.

Un exemple pur

Cette fonction dépend uniquement de ses arguments et ne produit qu’une valeur de retour. Son appel ne modifie jamais rien à l’extérieur.

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

Un exemple impur

Celle-ci lit et modifie une variable située en dehors de sa portée ; son résultat dépend donc d’un état caché et elle laisse une trace. Elle est par conséquent impure.

let counter = 0;
function next(): number {
  counter += 1; // side effect
  return counter;
}
console.log(next(), next()); // 1 2, depends on history

Transparence référentielle

Un appel pur est référentiellement transparent : vous pouvez le remplacer par son résultat sans modifier le programme. add(2, 3) peut être remplacé par 5 n’importe où.

const x = add(2, 3) * 2;
const y = 5 * 2; // identical meaning
console.log(x === y); // true

Pourquoi la pureté est utile

Les fonctions pures sont faciles à vérifier (aucune préparation), faciles à mettre en cache, sûres à exécuter en parallèle et simples à comprendre, car elles n’ont aucune dépendance cachée.

Éviter de modifier les arguments

Modifier un tableau ou un objet d’entrée constitue un effet de bord auquel l’appelant ne s’attend pas forcément. Construisez et renvoyez plutôt une nouvelle valeur.

// Impure: mutates input
function pushImpure(xs: number[], v: number) { xs.push(v); return xs; }
// Pure: returns a new array
function pushPure(xs: number[], v: number): number[] { return [...xs, v]; }

Mises à jour immuables avec la décomposition

L’opérateur de décomposition copie un objet ou un tableau, ce qui vous permet de remplacer des champs sans toucher à l’original. C’est l’outil principal des mises à jour immuables en TS.

interface User { name: string; age: number }
function birthday(u: User): User {
  return { ...u, age: u.age + 1 };
}
const before = { name: "Ada", age: 30 };
const after = birthday(before);
console.log(before.age, after.age); // 30 31

Mettre à jour les tableaux de manière immuable

Utilisez map, filter et la décomposition pour produire de nouveaux tableaux au lieu de les modifier. Le tableau original reste intact et peut être utilisé par le reste du code.

const nums = [1, 2, 3];
const doubled = nums.map(n => n * 2);
console.log(nums, doubled); // [1,2,3] [2,4,6]

readonly pour plus de sécurité

Marquer les paramètres comme readonly indique au compilateur et aux lecteurs que la fonction ne les modifiera pas, ce qui renforce la pureté au niveau des types.

function sum(xs: readonly number[]): number {
  return xs.reduce((a, b) => a + b, 0);
}
console.log(sum([1, 2, 3])); // 6

Repousser les effets aux limites

Les programmes réels ont besoin d’effets (journalisation, réseau). Le style fonctionnel conserve le noyau pur et isole les effets aux frontières, afin que la majorité du code reste prévisible.

Une liste mentale de vérification

Pour chaque fonction, demandez-vous : dépend-elle uniquement de ses entrées ? Renvoie-t-elle uniquement une valeur ? Laisse-t-elle les entrées et le monde extérieur inchangés ? Trois réponses positives signifient qu’elle est pure.

Vérification rapide

Vérification rapide de cette leçon.

Récapitulatif

Les fonctions pures dépendent uniquement de leurs entrées et ne produisent aucun effet de bord, ce qui leur confère une transparence référentielle. Utilisez la décomposition, map/filter et readonly pour effectuer des mises à jour immuables, et repoussez les effets du monde réel aux limites du programme.

Questions Fréquemment Posées

La leçon « Fonctions pures et immuabilité » est-elle gratuite ?

Oui — le texte complet de « Fonctions pures et immuabilité » 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 TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Fonctions pures et immuabilité » ?

Écrire des fonctions prévisibles sans effets secondaires. Tu pratiques TypeScript 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 TypeScript Academy ?

Aucune expérience préalable n'est requise. TypeScript 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 immuabilité » ?

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 TypeScript Academy ?

Oui. Chaque leçon TypeScript 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 à TypeScript Academy