JavaScript Academy · Aula

Funções fábrica

Crie objetos com estado privado usando closures.

Funções fábrica é uma aula grátis de JavaScript Academy no CoddyKit. Esta é a aula 4 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.

O que é uma função fábrica

Uma função fábrica é qualquer função que retorna um novo objeto. Diferentemente de um construtor, você a chama normalmente, sem new, e ela pode usar fechamentos para manter um estado privado.

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

Sem a palavra-chave de instanciação

As fábricas evitam as armadilhas de new e this. Basta chamar a função para receber um objeto como resultado.

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

Estado privado por meio de um fechamento

As variáveis declaradas na fábrica são privadas. Os métodos do objeto retornado formam fechamentos sobre elas, assim como no padrão de módulo, mas produzindo várias instâncias.

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

Muitas instâncias independentes

Cada chamada à fábrica produz um objeto novo com seu próprio estado privado. Essa é a principal diferença em relação a um módulo de instância única.

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

Propriedades calculadas

As fábricas podem derivar valores no momento da criação e expor métodos calculados, mantendo as entradas privadas.

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

Configuração padrão e config opcional

Como são funções comuns, as fábricas lidam de forma simples com valores padrão e opções usando a desestruturação.

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 }

Composição em vez de herança

As fábricas favorecem a composição: crie um objeto combinando behaviors em vez de estender uma cadeia 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"

Comportamento compartilhado

Para compartilhar métodos entre instâncias sem criar cópias por instância, defina-os uma vez e use assign. Ou aceite o pequeno custo em troca do benefício de privacidade oferecido pelos fechamentos.

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

Retornando funções também

Uma fábrica pode retornar uma função em vez de um objeto quando essa for a interface mais simples, continuando a capturar o estado privado.

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

Fábrica versus construtor

Os construtores usam new, this e a cadeia de protótipos. As fábricas são mais simples, evitam erros relacionados a this e oferecem privacidade real por meio de fechamentos, mas não compartilham métodos em um protótipo.

Validação na criação

As fábricas podem validar as entradas e lançar um erro ou normalizá-las antes de retornar, garantindo que todo objeto produzido seja válido.

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

Verificação rápida

Funções fábrica.

Recapitulação

As funções fábrica retornam objetos sem new ou this, usando fechamentos para manter um estado privado. Cada chamada produz uma instância independente, com suporte a propriedades calculadas, config padrão, composição e validação. Elas trocam o compartilhamento de métodos por protótipo pela simplicidade e pela privacidade genuína, tornando-se uma alternativa simples aos construtores baseada em fechamentos.

Perguntas Frequentes

A aula “Funções fábrica” é grátis?

Sim — o texto completo de “Funções fábrica” é 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 “Funções fábrica”?

Crie objetos com estado privado usando closures. 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 4 de 4.

Quanto tempo leva a aula “Funções fábrica”?

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