JavaScript Academy · Lezione

Funzioni factory

Crei oggetti con stato privato tramite closure.

Funzioni factory è una lezione JavaScript Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento JavaScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso JavaScript Academy include 4 lezioni in totale.

Cos'è una funzione factory

Una factory function è una funzione qualsiasi che restituisce un nuovo oggetto. A differenza di un costruttore, viene chiamata normalmente (senza new) e può usare le closure per lo stato privato.

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

Nessuna parola chiave new

Le factory evitano le insidie di new e this. È sufficiente chiamare la funzione per ottenere in risposta un oggetto.

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

Stato privato tramite closure

Le variabili dichiarate nella factory sono private. I metodi dell'oggetto restituito vi fanno riferimento tramite closure, proprio come nel module pattern, ma producendo più istanze.

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

Molte istanze indipendenti

Ogni chiamata alla factory produce un oggetto nuovo con il proprio stato privato. Questa è la differenza fondamentale rispetto a un modulo singleton.

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

Proprietà calcolate

Le factory possono derivare valori al momento della creazione ed esporre metodi calcolati, mantenendo privati gli input.

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

Configurazione predefinita e opzionale

Essendo funzioni normali, le factory gestiscono in modo chiaro i valori predefiniti e le opzioni tramite il destructuring.

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 }

Composizione invece dell'ereditarietà

Le factory privilegiano la composizione: si costruisce un oggetto combinando comportamenti invece di estendere una catena di classi.

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"

Comportamento condiviso

Per condividere i metodi tra le istanze senza crearne una copia per ogni istanza, li si può definire una sola volta e assegnare. In alternativa, si può accettare il piccolo costo in cambio del vantaggio in termini di privacy offerto dalle closure.

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

Restituire anche funzioni

Una factory può restituire una funzione invece di un oggetto quando questa rappresenta un'interfaccia più chiara, mantenendo comunque lo stato privato tramite closure.

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

Factory e costruttori

I costruttori usano new, this e la catena dei prototipi. Le factory sono più semplici, evitano i bug legati a this e offrono una privacy reale tramite le closure, al costo di non condividere i metodi attraverso un prototipo.

Convalida alla creazione

Le factory possono convalidare gli input e generare un errore o normalizzarli prima di restituire il risultato, garantendo che ogni oggetto prodotto sia valido.

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

Verifica rapida

Le funzioni factory.

Riepilogo

Le funzioni factory restituiscono oggetti senza new o this, usando le closure per lo stato privato. Ogni chiamata produce un'istanza indipendente e supporta proprietà calcolate, configurazione predefinita, composizione e convalida. In cambio della condivisione dei metodi tramite prototipo, offrono semplicità e privacy autentica, diventando un'alternativa chiara ai costruttori basata sulle closure.

Domande Frequenti

La lezione «Funzioni factory» è gratuita?

Sì — il testo completo di «Funzioni factory» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso JavaScript Academy, passa a CoddyKit PRO. Il corso JavaScript Academy include 4 lezioni in totale.

Cosa imparerò in «Funzioni factory»?

Crei oggetti con stato privato tramite closure. Eserciti JavaScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare JavaScript Academy?

Non è richiesta alcuna esperienza precedente. JavaScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Funzioni factory»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione JavaScript Academy?

Sì. Ogni lezione JavaScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a JavaScript Academy