Quais são os padrões de projeto comuns em Node.js?

Question

IT Interview Practice · Accepted Answer

O Node.js se apoia em um punhado de padrões de projeto que se encaixam em seu sistema de módulos, modelo assíncrono e I/O de streaming. Os mais comuns que todo desenvolvedor backend deve reconhecer:

## Criacionais

- **Padrão de módulo** — cada arquivo tem seu próprio escopo; você expõe uma API pública via `module.exports` / `export`, mantendo o interno privado. A base da organização de código no Node.
- **Singleton** — os exports de um módulo são **cacheados**, então exportar uma instância dá a todo importador o mesmo objeto. Perfeito para um pool de DB ou configuração.

```js
// db.js — todo `require("./db")` recebe esse mesmo pool (singleton via cache de módulo).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — uma função que cria e retorna objetos, ocultando a lógica de construção e permitindo trocar implementações.

```js
function createLogger(kind) {
  return kind === "json" ? new JsonLogger() : new TextLogger();
}
```

## Comportamentais

- **Observer / EventEmitter** — o padrão async central do Node: emita eventos nomeados, anexe ouvintes. `EventEmitter`, streams e a maioria dos módulos centrais o usam.

```js
const { EventEmitter } = require("node:events");
const bus = new EventEmitter();
bus.on("order:paid", (o) => sendReceipt(o));
bus.emit("order:paid", order);
```

- **Middleware** — um pipeline de funções, cada uma recebendo `(ctx, next)`, popularizado por Express/Koa. Ótimo para preocupações transversais (auth, logging, validação).

```js
app.use((req, res, next) => { req.startedAt = Date.now(); next(); });
```

- **Strategy** — selecione um algoritmo em tempo de execução (ex.: escolher um provedor de pagamento ou uma estratégia de hashing por trás de uma interface).

## Estruturais

- **Adapter** — envolva uma API de terceiros na sua própria interface para poder trocar de fornecedor sem tocar nos pontos de chamada.
- **Streams (pipeline)** — componha estágios readable → transform → writable para processar dados incrementalmente com backpressure, em vez de bufferizar tudo na memória.

```js
const { pipeline } = require("node:stream/promises");
await pipeline(fs.createReadStream("in"), gzip(), fs.createWriteStream("out.gz"));
```

- **Injeção de dependência** — passe colaboradores (db, logger, clientes) para um módulo em vez de importá-los diretamente; torna o código testável e desacoplado. Frameworks como **NestJS** têm DI embutida; você também pode fazê-la manualmente via argumentos de construtor/função.

## Regra prática

| Necessidade | Padrão |
|---|---|
| Um recurso compartilhado | Singleton (cache de módulo) |
| Construir objetos, ocultar `new` | Factory |
| Reagir a eventos async | Observer / EventEmitter |
| Lógica de requisição transversal | Middleware |
| Processar grandes dados com segurança | Streams / pipeline |
| Dependências testáveis e desacopladas | Injeção de dependência |

## Por que isso importa

Padrões são um vocabulário compartilhado: dizer "a config é um singleton cacheado por módulo" ou "auth é middleware" comunica um design em poucas palavras. O próprio núcleo do Node (EventEmitter, streams, o sistema de módulos) é construído a partir deles, então reconhecê-los ajuda a ler frameworks e estruturar seus próprios serviços. Os entrevistadores usam esta pergunta para verificar se você não apenas liga callbacks ad hoc, mas busca o padrão que se encaixa — e conhece suas contrapartidas, como um singleton tornando o estado global mais difícil de testar.

Necessidade	Padrão
Um recurso compartilhado	Singleton (cache de módulo)
Construir objetos, ocultar `new`	Factory
Reagir a eventos async	Observer / EventEmitter
Lógica de requisição transversal	Middleware
Processar grandes dados com segurança	Streams / pipeline
Dependências testáveis e desacopladas	Injeção de dependência

Criacionais

Comportamentais

Estruturais

Regra prática

Por que isso importa

Perguntas relacionadas