JavaScript Academy · Aula

Variáveis privadas com closures

Oculte o estado dentro do escopo de uma função.

Variáveis privadas com closures é uma aula grátis de JavaScript Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de JavaScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de JavaScript Academy inclui 4 aulas no total.

Privacidade por meio de fechamentos

Durante muito tempo, JavaScript não teve uma forma integrada de tornar privados os campos de objetos. Os fechamentos oferecem uma: as variáveis dentro de uma função ficam invisíveis do lado de fora, mas acessíveis às funções definidas dentro dela.

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

Um counter com estado privado

O exemplo canônico: um counter cuja contagem não pode ser alterada diretamente. Somente os métodos retornados podem modificá-la.

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

O estado é intocável

Não há como alcançar count de fora. As tentativas de lê-lo retornam undefined; é necessário passar pelos métodos.

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

Impondo regras

Como o acesso passa pelos métodos, você pode impor invariantes, como nunca permitir que o valor de balance fique 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

Vários campos privados

Um fechamento pode proteger várias variáveis de uma só vez. Todas ficam ocultas e são compartilhadas apenas entre os métodos retornados.

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" }

Funções auxiliares privadas

Não apenas dados: você também pode ocultar funções internas. Somente os métodos que você expõe são públicos.

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

Instâncias independentes

Cada chamada à fábrica cria um estado privado separado, portanto as instâncias nunca interferem umas nas outras.

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

Exposição somente para leitura

Exponha um acessador sem um modificador para tornar um valor somente para leitura do lado de fora, embora ele continue modificável 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

Comparação: campos de classe

O JavaScript moderno também oferece campos de classe #private. Os fechamentos continuam úteis para funções fábrica e quando você deseja privacidade sem classes.

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

Por que funciona

Os métodos retornados são fechamentos sobre as variáveis externas. A função externa retornou, mas seu escopo continua existindo porque esses fechamentos ainda fazem referência a ele.

Um cache de memorização

O estado privado é excelente para caches. O objeto cache permanece oculto e persiste entre as chamadas.

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ção rápida

Variáveis privadas com fechamentos.

Recapitulação

Os fechamentos criam privacidade: as variáveis dentro de uma fábrica ficam inacessíveis do lado de fora, mas são compartilhadas entre os métodos retornados. Isso permite criar counters à prova de alterações indevidas, balances com invariantes, funções auxiliares ocultas e caches. Cada chamada à fábrica produz um estado independente. Os campos de classe modernos #private são uma alternativa, mas os fechamentos se destacam no código baseado em fábricas.

Perguntas Frequentes

A aula “Variáveis privadas com closures” é grátis?

Sim — o texto completo de “Variáveis privadas com closures” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de JavaScript Academy, atualize para CoddyKit PRO. O curso de JavaScript Academy inclui 4 aulas no total.

O que vou aprender em “Variáveis privadas com closures”?

Oculte o estado dentro do escopo de uma função. Você pratica JavaScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar JavaScript Academy?

Nenhuma experiência prévia é necessária. JavaScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Variáveis privadas com closures”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de JavaScript Academy?

Sim. Cada aula de JavaScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para JavaScript Academy