JavaScript Academy · Leçon

Fonctions fabrique

Créez des objets dotés d’un état privé grâce aux fermetures.

Fonctions fabrique 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 qu’une fonction de fabrique

Une fonction de fabrique est une fonction qui renvoie un nouvel objet. Contrairement à un constructeur, vous l’appelez normalement, sans new, et elle peut utiliser des fermetures pour gérer un état privé.

function createUser(name) {
  return {
    name,
    greet: () => "Hi, I am " + name
  };
}
const u = createUser("Ada");
console.log(u.greet()); // "Hi, I am Ada"

Sans le mot-clé new

Les fabriques évitent les pièges de new et de this. Il vous suffit d’appeler la fonction pour récupérer un objet.

function point(x, y) {
  return { x, y };
}
const p = point(3, 4);
console.log(p.x, p.y); // 3 4

État privé grâce à une fermeture

Les variables déclarées dans la fabrique sont privées. Les méthodes de l’objet renvoyé forment des fermetures sur ces variables, comme dans le modèle de module, mais en produisant plusieurs instances.

function createCounter() {
  let count = 0; // private
  return {
    inc: () => ++count,
    get: () => count
  };
}
const c = createCounter();
c.inc();
console.log(c.get()); // 1

De nombreuses instances indépendantes

Chaque appel de la fabrique produit un nouvel objet doté de son propre état privé. C’est la principale différence avec un module qui constitue une instance unique.

function createCounter() {
  let n = 0;
  return { inc: () => ++n };
}
const a = createCounter();
const b = createCounter();
console.log(a.inc(), a.inc()); // 1 2
console.log(b.inc());          // 1

Propriétés calculées

Les fabriques peuvent dériver des valeurs lors de la création et exposer des méthodes calculées, tout en gardant les entrées privées.

function rectangle(w, h) {
  return {
    area: () => w * h,
    perimeter: () => 2 * (w + h)
  };
}
const r = rectangle(3, 4);
console.log(r.area());      // 12
console.log(r.perimeter()); // 14

Config par défaut et facultative

Comme ce sont de simples fonctions, les fabriques gèrent proprement les valeurs par défaut et les options grâce à la déstructuration.

function createButton({ label = "OK", disabled = false } = {}) {
  return { label, disabled };
}
console.log(createButton());             // { label: "OK", disabled: false }
console.log(createButton({ label: "Go" })); // { label: "Go", disabled: false }

La composition plutôt que l’héritage

Les fabriques privilégient la composition : construisez un objet en combinant des behavior plutôt qu’en étendant une hiérarchie de classes.

const canFly = (s) => ({ fly: () => s.name + " flies" });
function createBird(name) {
  const self = { name };
  return Object.assign(self, canFly(self));
}
console.log(createBird("Robin").fly()); // "Robin flies"

Behavior partagé

Pour partager des méthodes entre les instances sans créer de copie par instance, définissez-les une seule fois et utilisez assign. Vous pouvez aussi accepter le faible coût associé à l’avantage de confidentialité offert par les fermetures.

const behavior = {
  describe() { return "id " + this.id; }
};
function createItem(id) {
  return Object.assign({ id }, behavior);
}
console.log(createItem(7).describe()); // "id 7"

Renvoyer aussi des fonctions

Une fabrique peut renvoyer une fonction plutôt qu’un objet lorsque cela constitue une interface plus claire, tout en capturant un état privé.

function multiplier(factor) {
  return (n) => n * factor;
}
const triple = multiplier(3);
console.log(triple(5)); // 15

Fabrique ou constructeur

Les constructeurs utilisent new, this et la chaîne des prototypes. Les fabriques sont plus simples, évitent les bogues liés à this et offrent une véritable confidentialité grâce aux fermetures, au prix de l’absence de partage des méthodes sur un prototype.

Validation à la création

Les fabriques peuvent valider les entrées, lever une exception ou les normaliser avant de renvoyer un résultat, ce qui garantit que chaque objet produit est valide.

function createAge(value) {
  if (value < 0) throw new Error("age must be >= 0");
  return { value };
}
console.log(createAge(30).value); // 30

Vérification rapide

Les fonctions de fabrique.

Récapitulatif

Les fonctions de fabrique renvoient des objets sans new ni this, en utilisant des fermetures pour gérer un état privé. Chaque appel produit une instance indépendante et prend en charge les propriétés calculées, la config par défaut, la composition et la validation. Elles renoncent au partage des méthodes par prototype au profit de la simplicité et d’une véritable confidentialité, ce qui en fait une alternative claire aux constructeurs, fondée sur les fermetures.

Questions Fréquemment Posées

La leçon « Fonctions fabrique » est-elle gratuite ?

Oui — le texte complet de « Fonctions fabrique » 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 fabrique » ?

Créez des objets dotés d’un état privé grâce aux fermetures. 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 « Fonctions fabrique » ?

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