JavaScript Academy · Aula

O padrão de módulo (IIFE)

Encapsule o código com funções imediatamente invocadas.

O padrão de módulo (IIFE) é uma aula grátis de JavaScript Academy no CoddyKit. Esta é a aula 3 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 o padrão de módulo resolve

Antes dos módulos ES, o padrão de módulo permitia agrupar estado e behavior relacionados, mantendo os componentes internos privados e expondo uma API pública limpa. Ele é baseado em fechamentos.

O IIFE

Um IIFE (expressão de função invocada imediatamente) é uma função que é executada no momento em que é definida. Envolvê-la entre parênteses e chamá-la cria instantaneamente um escopo privado.

const result = (function () {
  return 42;
})();
console.log(result); // 42

Por que executá-lo imediatamente

O IIFE oferece um escopo privado de uso único sem deixar uma função nomeada desnecessária. Tudo dentro dele fica isolado do espaço de nomes global.

(function () {
  const temp = "not global";
  console.log(temp);
})();
// temp is unreachable out here

Retornando uma API pública

O padrão de módulo é um IIFE que retorna um objeto. Os métodos do objeto são fechamentos sobre as variáveis privadas, formando a interface pública.

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

Privado versus público

Tudo o que for declarado internamente, mas não for retornado, permanece privado. Somente aquilo que você colocar no objeto retornado ficará acessível.

const calc = (function () {
  const pi = 3.14159; // private constant
  return {
    area: (r) => pi * r * r
  };
})();
console.log(calc.area(2)); // 12.56636
console.log(calc.pi);      // undefined

Funções auxiliares privadas

As funções auxiliares podem ficar dentro do módulo, sendo usadas pelos métodos públicos sem nunca serem expostas.

const validator = (function () {
  const clean = (s) => s.trim().toLowerCase(); // private
  return {
    isEmail: (s) => clean(s).includes("@")
  };
})();
console.log(validator.isEmail(" A@B.com ")); // true

O padrão de módulo revelador

Uma variante popular define todas as funções como privadas e depois retorna um objeto que "revela" referências às funções públicas. Ela mantém clara a lista da API pública no final.

const store = (function () {
  let items = [];
  function add(x) { items.push(x); }
  function count() { return items.length; }
  return { add, count }; // reveal
})();
store.add("a");
console.log(store.count()); // 1

Instâncias únicas

Como o IIFE é executado uma vez, um módulo funciona efetivamente como uma instância única: há exatamente uma instância com um único conjunto de estado privado.

const config = (function () {
  let settings = { theme: "dark" };
  return {
    get: (k) => settings[k],
    set: (k, v) => { settings[k] = v; }
  };
})();
config.set("theme", "light");
console.log(config.get("theme")); // "light"

Passando dependências

Você pode passar elementos globais ou outros módulos como argumentos do IIFE, tornando as dependências explícitas e permitindo uma minificação segura.

const mathUtils = (function (M) {
  return { roundUp: (n) => M.ceil(n) };
})(Math);
console.log(mathUtils.roundUp(4.1)); // 5

Evitando a poluição global

A ideia principal é ter um único nome global, o módulo, em vez de dezenas de variáveis soltas. Isso evita colisões de nomes entre os scripts.

Relação com os módulos ES

Hoje, import/export oferecem um escopo de módulo verdadeiro no nível da linguagem, substituindo em grande parte esse padrão. Mas entender os módulos IIFE esclarece como funcionam a privacidade e o encapsulamento, e você ainda os encontrará em código legado.

Verificação rápida

O padrão de módulo e os IIFEs.

Recapitulação

O padrão de módulo usa um IIFE para criar um escopo privado e retorna um objeto cujos métodos são fechamentos sobre o estado oculto. Os componentes internos permanecem privados; somente os membros retornados são públicos. Variantes como o padrão de módulo revelador deixam a API mais clara, e os módulos funcionam como instâncias únicas. import/export de ES agora substituem o padrão, mas se baseiam nas mesmas ideias.

Perguntas Frequentes

A aula “O padrão de módulo (IIFE)” é grátis?

Sim — o texto completo de “O padrão de módulo (IIFE)” é 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 “O padrão de módulo (IIFE)”?

Encapsule o código com funções imediatamente invocadas. 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 3 de 4.

Quanto tempo leva a aula “O padrão de módulo (IIFE)”?

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