JavaScript Academy · Leçon

Style sans paramètres nommés

Composez des fonctions sans nommer leurs arguments.

Style sans paramètres nommés est une leçon JavaScript Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Qu’est-ce que le style sans arguments

Le style sans arguments (ou tacite) définit des fonctions en combinant d’autres fonctions, sans mentionner leurs arguments. Les arguments sont les points implicites transmis tout au long du traitement.

function double(n) { return n * 2; }
const nums = [1, 2, 3];
// pointed: argument named explicitly
console.log(nums.map((n) => double(n))); // [2, 4, 6]
// point-free: no named argument
console.log(nums.map(double));            // [2, 4, 6]

Passer directement des fonctions

Lorsqu’une fonction de rappel transmet simplement son argument à une autre fonction, vous pouvez passer cette fonction par son nom au lieu de l’envelopper.

const len = (s) => s.length;
const words = ["a", "bb", "ccc"];
console.log(words.map((w) => w.length)); // pointed: [1, 2, 3]
console.log(words.map(len));             // point-free: [1, 2, 3]

Composition de fonctions

Le code sans arguments s’appuie sur la composition : construire une nouvelle fonction en transmettant la sortie de l’une à la suivante.

const compose = (f, g) => (x) => f(g(x));
const inc = (n) => n + 1;
const double = (n) => n * 2;
const incThenDouble = compose(double, inc);
console.log(incThenDouble(3)); // (3+1)*2 = 8

Un utilitaire pipe

pipe se lit de gauche à droite, ce que beaucoup trouvent plus clair que compose. Il applique les fonctions dans l’ordre.

const pipe = (...fns) => (x) => fns.reduce((acc, f) => f(acc), x);
const inc = (n) => n + 1;
const double = (n) => n * 2;
const f = pipe(inc, double);
console.log(f(3)); // 8

Construire des chaînes de traitement

Avec pipe, vous pouvez exprimer une transformation en plusieurs étapes sous la forme d’une fonction nommée, sans jamais nommer les données.

const pipe = (...fns) => (x) => fns.reduce((a, f) => f(a), x);
const trim = (s) => s.trim();
const lower = (s) => s.toLowerCase();
const clean = pipe(trim, lower);
console.log(clean("  HELLO  ")); // "hello"

Le curryfage permet le style sans arguments

Le curryfage transforme une fonction à plusieurs arguments en une chaîne de fonctions à un seul argument. Il produit ainsi des fonctions unaires prêtes à être composées.

const multiply = (a) => (b) => a * b;
const triple = multiply(3);
console.log([1, 2, 3].map(triple)); // [3, 6, 9]

Application partielle

Fixer certains arguments à l’avance produit une fonction spécialisée que vous pouvez passer directement, ce qui constitue une autre voie vers le code sans arguments.

const add = (a, b) => a + b;
const add10 = add.bind(null, 10);
console.log([1, 2, 3].map(add10)); // [11, 12, 13]

Composer des prédicats

Vous pouvez construire des fonctions utilitaires booléennes à partir d’autres fonctions pour créer des filtres propres, sans syntaxe superflue de fonctions fléchées intégrées.

const isEven = (n) => n % 2 === 0;
const negate = (fn) => (x) => !fn(x);
const isOdd = negate(isEven);
console.log([1, 2, 3, 4].filter(isOdd)); // [1, 3]

Compromis de lisibilité

Le style sans arguments peut être élégant, mais poussé trop loin, il devient énigmatique. Utilisez-le lorsqu’il clarifie l’intention (map(double)) et restez explicite sur l’argument lorsque le nommer facilite la compréhension.

const names = ["ada", "bob"];
console.log(names.map((n) => n.toUpperCase())); // ["ADA","BOB"]

Piège des références de méthode

Passer une méthode par son nom peut lui faire perdre son this. Enveloppez-la ou liez-la lorsque la fonction dépend du contexte d’un objet.

const calc = {
  factor: 2,
  scale(n) { return n * this.factor; }
};
console.log([1, 2].map(calc.scale.bind(calc))); // [2, 4]

Composer de vraies transformations

En réunissant de petites fonctions nommées dans une chaîne de traitement, vous obtenez un flux de données déclaratif, facile à tester et sans arguments.

const pipe = (...fns) => (x) => fns.reduce((a, f) => f(a), x);
const toNums = (arr) => arr.map(Number);
const onlyPos = (arr) => arr.filter((n) => n > 0);
const sum = (arr) => arr.reduce((a, n) => a + n, 0);
const process = pipe(toNums, onlyPos, sum);
console.log(process(["3", "-1", "4"])); // 7

Vérification rapide

Style sans arguments.

Récapitulatif

Le style sans arguments construit des fonctions en en composant d’autres, sans nommer les arguments. Passez les fonctions par référence (map(double)), composez avec compose/pipe et utilisez le curryfage ou l’application partielle pour créer des fonctions unaires. Faites attention à la perte de this dans les références de méthode et restez explicite sur les arguments lorsque cela améliore la lisibilité.

Questions Fréquemment Posées

La leçon « Style sans paramètres nommés » est-elle gratuite ?

Oui — le texte complet de « Style sans paramètres nommés » 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 « Style sans paramètres nommés » ?

Composez des fonctions sans nommer leurs arguments. 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 4 sur 4.

Combien de temps prend la leçon « Style sans paramètres nommés » ?

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