Factory

Los patrones creacionales responden una pregunta que parece trivial hasta que el proyecto crece: ¿quién ejecuta el new? Factory es la respuesta más usada: un único lugar que sabe qué clase concreta construir, para que el resto del código trabaje solo con la interfaz.

El problema: new es acoplamiento

Cada new ParserCSV() esparcido por el código ata ese punto a una clase concreta. Y cuando la elección depende de un dato, el acoplamiento viene con su amigo el switch duplicado:

// Este switch aparece en importar(), en previsualizar(), en validar()…
let parser;
if (fichero.endsWith('.csv')) parser = new ParserCSV();
else if (fichero.endsWith('.json')) parser = new ParserJSON();
else if (fichero.endsWith('.xml')) parser = new ParserXML();

Soportar .yaml mañana significa cazar todos esos switch. Alguno se te escapará — y ese es el bug.

La solución: un único lugar que decide

interface Parser {
  parsear(contenido: string): Registro[];
}

const constructores: Record<string, () => Parser> = {
  csv: () => new ParserCSV(),
  json: () => new ParserJSON(),
  xml: () => new ParserXML(),
};

function crearParser(fichero: string): Parser {
  const ext = fichero.split('.').pop() ?? '';
  const constructor = constructores[ext];
  if (!constructor) throw new Error(`formato no soportado: .${ext}`);
  return constructor();
}

// El código cliente ya no conoce ninguna clase concreta:
const registros = crearParser(fichero).parsear(contenido);

Fíjate en la simetría con Strategy: el mapa de constructores es un mapa de estrategias de creación. La diferencia está en la intención — Factory decide qué objeto nace; Strategy decide cómo se comporta uno que ya existe. En la práctica van juntos: la fábrica elige la estrategia según la configuración.

Las variantes, sin ceremonias

• Función fábrica (simple factory): lo de arriba. Cubre el 90 % de los casos en JavaScript/TypeScript.
• Factory Method (el patrón GoF formal): la fábrica es un método que las subclases sobreescriben — el framework define cuándo se crea y cada extensión define qué. Lo has usado si has sobreescrito un createConnection() o un render() que devuelve el componente concreto.
• Abstract Factory: una fábrica de familias completas de objetos que deben ser coherentes entre sí (todos los widgets del tema oscuro, todos los drivers del mismo proveedor). Menos frecuente; reconócela, no la busques.

Ya lo usas todos los días

• document.createElement('canvas') — le pides por nombre, el navegador decide la clase concreta.
• Los drivers de base de datos: createConnection(url) devuelve el conector de Postgres o MySQL según el esquema de la URL.
• Los transportes de un logger (consola, fichero, servicio externo) elegidos por configuración.
• Cualquier sistema de plugins: registrar un formato nuevo = añadir una entrada al mapa de la fábrica, sin tocar el núcleo. El registro de widgets de este mismo sitio funciona así.

Cuándo NO usarlo

Con Factory cierras el ciclo creacional que abrió Singleton — uno controla cuántas instancias hay; el otro, cuáles. Y si la fábrica decide con datos del negocio qué estrategia devolver, acabas de conectar los tres patrones que más usarás.