JavaScript Academy · Lezione

Variabili private con le closure

Nasconda lo stato all'interno dello scope di una funzione.

Variabili private con le closure è una lezione JavaScript Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Privacy con le closure

Per molto tempo JavaScript non ha avuto un modo integrato per rendere privati i campi degli oggetti. Le closure ne offrono uno: le variabili all'interno di una funzione sono invisibili dall'esterno, ma accessibili alle funzioni definite al loro interno.

function secretBox() {
  let secret = "hidden";
  return {
    reveal: () => secret
  };
}
const box = secretBox();
console.log(box.reveal()); // "hidden"
console.log(box.secret);   // undefined

Un contatore con stato privato

L'esempio classico: un contatore il cui conteggio non può essere modificato direttamente. Solo i metodi restituiti possono cambiarlo.

function makeCounter() {
  let count = 0;
  return {
    increment: () => ++count,
    value: () => count
  };
}
const c = makeCounter();
c.increment();
c.increment();
console.log(c.value()); // 2

Lo stato è inaccessibile

Non è possibile raggiungere count dall'esterno. I tentativi di leggerlo restituiscono undefined; è necessario passare attraverso i metodi.

function makeCounter() {
  let count = 0;
  return { inc: () => ++count, get: () => count };
}
const c = makeCounter();
c.count = 100;        // creates an unrelated property
console.log(c.get()); // 0 - real count untouched

Applicare le regole

Poiché l'accesso passa attraverso i metodi, è possibile imporre degli invarianti, ad esempio impedire che un saldo diventi negativo.

function account(start) {
  let balance = start;
  return {
    withdraw: (n) => {
      if (n > balance) return "insufficient";
      balance -= n;
      return balance;
    },
    balance: () => balance
  };
}
const a = account(100);
console.log(a.withdraw(150)); // "insufficient"
console.log(a.withdraw(40));  // 60

Più campi privati

Una closure può proteggere più variabili contemporaneamente. Sono tutte nascoste e condivise solo tra i metodi restituiti.

function user(name) {
  let logins = 0;
  let lastSeen = null;
  return {
    login: () => { logins++; lastSeen = "now"; },
    stats: () => ({ name, logins, lastSeen })
  };
}
const u = user("Ada");
u.login();
console.log(u.stats()); // { name: "Ada", logins: 1, lastSeen: "now" }

Funzioni helper private

Non solo dati: è possibile nascondere anche le funzioni interne. Solo i metodi esposti sono pubblici.

function temperature() {
  let celsius = 0;
  const toF = (c) => c * 9 / 5 + 32; // private
  return {
    set: (c) => { celsius = c; },
    fahrenheit: () => toF(celsius)
  };
}
const t = temperature();
t.set(100);
console.log(t.fahrenheit()); // 212

Istanze indipendenti

Ogni chiamata alla factory crea uno stato privato separato, quindi le istanze non interferiscono mai tra loro.

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

Esposizione in sola lettura

Si può esporre un getter senza setter per rendere un valore di sola lettura dall'esterno, lasciandolo comunque modificabile internamente.

function timer() {
  let ticks = 0;
  setupInternally();
  function setupInternally() { ticks = 3; }
  return { ticks: () => ticks };
}
const t = timer();
console.log(t.ticks()); // 3 - no way to set it outside

Confronto: campi delle classi

JavaScript moderno supporta anche i campi di classe #private. Le closure restano utili per le funzioni factory e quando si desidera la privacy senza usare le classi.

class Counter {
  #count = 0;
  inc() { return ++this.#count; }
}
const c = new Counter();
console.log(c.inc()); // 1

Perché funziona

I metodi restituiti sono closure sulle variabili esterne. La funzione esterna ha restituito il risultato, ma il suo scope continua a vivere perché quelle closure vi fanno ancora riferimento.

Una cache di memoizzazione

Lo stato privato è ideale per le cache. L'oggetto cache rimane nascosto e persiste tra una chiamata e l'altra.

function memoSquare() {
  const cache = {};
  return (n) => {
    if (cache[n] === undefined) cache[n] = n * n;
    return cache[n];
  };
}
const sq = memoSquare();
console.log(sq(4)); // 16
console.log(sq(4)); // 16 (cached)

Verifica rapida

Variabili private con le closure.

Riepilogo

Le closure creano privacy: le variabili all'interno di una factory non sono raggiungibili dall'esterno, ma vengono condivise tra i metodi restituiti. Questo permette di creare contatori a prova di manomissione, saldi con invarianti, helper nascosti e cache. Ogni chiamata alla factory produce uno stato indipendente. I moderni campi di classe #private sono un'alternativa, ma le closure sono particolarmente adatte al codice basato su factory.

Domande Frequenti

La lezione «Variabili private con le closure» è gratuita?

Sì — il testo completo di «Variabili private con le closure» è 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 «Variabili private con le closure»?

Nasconda lo stato all'interno dello scope di una funzione. 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 2 di 4.

Quanto tempo richiede la lezione «Variabili private con le closure»?

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