¿Cuáles son los patrones de diseño comunes en Node.js?

Question

IT Interview Practice · Accepted Answer

Node.js se apoya en un puñado de patrones de diseño que encajan con su sistema de módulos, su modelo asíncrono y su I/O por streaming. Los más comunes que todo desarrollador backend debería reconocer:

## Creacionales (Creational)

- **Module pattern** — cada archivo es su propio scope; expones un API pública mediante `module.exports` / `export`, manteniendo lo interno privado. La base de la organización del código en Node.
- **Singleton** — los exports de un módulo se **cachean**, así que exportar una instancia da a cada importador el mismo objeto. Perfecto para un DB pool o una config.

```js
// db.js — cada `require("./db")` obtiene este mismo pool (singleton vía caché de módulos).
const pool = createPool(process.env.DATABASE_URL);
module.exports = pool;
```

- **Factory** — una función que crea y devuelve objetos, ocultando la lógica de construcción y permitiéndote intercambiar implementaciones.

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

## De comportamiento (Behavioral)

- **Observer / EventEmitter** — el patrón asíncrono central de Node: emites eventos con nombre, adjuntas listeners. `EventEmitter`, los streams y la mayoría de los módulos core lo usan.

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

- **Middleware** — una pipeline de funciones que reciben cada una `(ctx, next)`, popularizada por Express/Koa. Ideal para preocupaciones transversales (auth, logging, validación).

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

- **Strategy** — seleccionar un algoritmo en runtime (p. ej. elegir un proveedor de pagos o una estrategia de hashing tras una única interfaz).

## Estructurales (Structural)

- **Adapter** — envuelve un API de terceros en tu propia interfaz para poder cambiar de proveedor sin tocar los puntos de llamada.
- **Streams (pipeline)** — compón etapas readable → transform → writable para procesar datos de forma incremental con backpressure, en lugar de bufferizar todo en memoria.

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

- **Dependency Injection** — pasa los colaboradores (db, logger, clientes) a un módulo en lugar de importarlos directamente; hace el código testeable y desacoplado. Frameworks como **NestJS** integran DI; también puedes hacerlo a mano mediante argumentos de constructor/función.

## Regla general

| Necesidad | Patrón |
|---|---|
| Un recurso compartido | Singleton (caché de módulos) |
| Construir objetos, ocultar `new` | Factory |
| Reaccionar a eventos asíncronos | Observer / EventEmitter |
| Lógica transversal de request | Middleware |
| Procesar datos grandes con seguridad | Streams / pipeline |
| Dependencias testeables y desacopladas | Dependency Injection |

## Por qué es importante

Los patrones son un vocabulario compartido: decir "la config es un singleton cacheado por módulo" o "auth es middleware" comunica un diseño en pocas palabras. El propio core de Node (EventEmitter, streams, el sistema de módulos) está construido con ellos, así que reconocerlos te ayuda a leer frameworks y estructurar tus propios servicios. Los entrevistadores usan esta pregunta para comprobar que no solo cableas callbacks ad hoc, sino que recurres al patrón que encaja — y conoces sus concesiones, como que un singleton hace más difícil testear el estado global.

Necesidad	Patrón
Un recurso compartido	Singleton (caché de módulos)
Construir objetos, ocultar `new`	Factory
Reaccionar a eventos asíncronos	Observer / EventEmitter
Lógica transversal de request	Middleware
Procesar datos grandes con seguridad	Streams / pipeline
Dependencias testeables y desacopladas	Dependency Injection

Creacionales (Creational)

De comportamiento (Behavioral)

Estructurales (Structural)

Regla general

Por qué es importante

Preguntas relacionadas