Arquetipo
Patrones de comportamientoUso: Muy altaComplejidad: Baja

Strategy

Estrategia · Política

Define una familia de algoritmos intercambiables, encapsula cada uno en su propia clase y permite elegir cuál usar en tiempo de ejecución.

“Tengo varias formas de hacer lo mismo y quiero elegir una en tiempo de ejecución.”

workEl caso real

Tu tienda calcula el costo de envío de forma distinta según la modalidad: tarifa plana dentro de la ciudad, por peso para el resto del país, con la tabla del operador para envíos internacionales y gratis durante las campañas. El cliente elige la modalidad en el checkout, y el negocio añade nuevas cada temporada.

warningEl problema sin el patrón

calcularEnvio() es un switch con todos los algoritmos mezclados, cada uno con sus llamadas a las APIs de los operadores. Probar uno implica preparar datos para todos, y cada modalidad nueva modifica la misma función.

check_circleCómo lo resuelve el patrón

Cada forma de calcular es una estrategia que implementa la interfaz CalculoEnvio. El checkout recibe la estrategia elegida y delega el cálculo en ella, sin saber cuál es.

schemaDiagrama de clases

Diagrama interactivo: puedes acercar, mover el lienzo y pasar el cursor sobre cada clase para ver su detalle.

codeEl código, antes y después

cancelSin el patrónANTES
function calcularEnvio(modalidad: string, pedido: Pedido): number {
  switch (modalidad) {
    case 'ciudad':        return 10;
    case 'nacional':      return pedido.pesoKg * 4.5;
    case 'internacional': return tablaOperador.consultar(pedido.pais, pedido.pesoKg);
    case 'campania':      return 0;
    default: throw new Error('Modalidad desconocida');
  }
}
check_circleCon el patrónDESPUÉS
interface CalculoEnvio {
  calcular(pedido: Pedido): number;
}

class TarifaPlana implements CalculoEnvio {
  constructor(private monto: number) {}
  calcular() { return this.monto; }
}

class PorPeso implements CalculoEnvio {
  constructor(private precioPorKg: number) {}
  calcular(p: Pedido) { return p.pesoKg * this.precioPorKg; }
}

class Checkout {
  constructor(private envio: CalculoEnvio) {}
  total(p: Pedido) { return p.subtotal + this.envio.calcular(p); }
}

const modalidades: Record<string, CalculoEnvio> = {
  ciudad: new TarifaPlana(10),
  nacional: new PorPeso(4.5),
  campania: new TarifaPlana(0),
};
new Checkout(modalidades[modalidadElegida]).total(pedido);

Ejemplos en TypeScript, simplificados para mostrar la idea: los tipos auxiliares (Pedido, Cliente…) se omiten.

thumb_upCuándo usarlo

  • ✓Hay varias formas de hacer lo mismo y se elige una en tiempo de ejecución.
  • ✓Quieres aislar algoritmos con detalles propios (APIs, tablas, reglas) del código que los usa y probarlos por separado.

do_not_disturb_onCuándo no usarlo

  • ✕Solo hay uno o dos algoritmos simples que casi nunca cambian.
  • ✕En lenguajes con funciones de primera clase, a menudo basta con pasar una función en lugar de crear una interfaz y varias clases.
  • ✕Quien elige no sabe distinguir las opciones: el cliente tiene que conocer las diferencias entre estrategias para escoger la adecuada.

memoryPrincipios en juego

  • •Abierto/Cerrado: una modalidad nueva es una estrategia nueva.
  • •Composición sobre herencia: el checkout tiene una estrategia, no hereda de ella.

hubPatrones relacionados

  • •State: misma estructura, pero los estados cambian solos; la estrategia la elige el cliente.
  • •Template Method: varía partes de un algoritmo mediante herencia; Strategy cambia el algoritmo completo mediante composición.
  • •Decorator: añade comportamiento alrededor del objeto; Strategy cambia cómo hace su trabajo por dentro.
compare_arrowsSe suele confundir conStrategy vs State →Strategy vs Command →Strategy vs Template Method →

quizPon a prueba lo que leíste

Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.

Más ejercicios →

code_blocksStrategy en tu lenguaje

El mismo caso, implementado completo y de forma idiomática. Se puede copiar y ejecutar.

LO IDIOMÁTICO EN TYPESCRIPT: Como las funciones son valores, una estrategia puede ser simplemente un tipo de función: no hace falta una interfaz con una clase por algoritmo. satisfies comprueba que cada entrada del catálogo es una estrategia válida sin perder los nombres de las claves (Modalidad).

strategy.ts · 39 líneas
export interface Pedido {
  subtotal: number;
  pesoKg: number;
  pais: string;
}

export type CalculoEnvio = (pedido: Pedido) => number;

const tarifaPlana = (monto: number): CalculoEnvio => () => monto;

const porPeso = (precioPorKg: number): CalculoEnvio =>
  (pedido) => Math.round(pedido.pesoKg * precioPorKg * 100) / 100;

const tarifasPais: Record<string, number> = { US: 45, ES: 60 };
const internacional: CalculoEnvio = (pedido) => tarifasPais[pedido.pais] ?? 80;

const modalidades = {
  ciudad: tarifaPlana(10),
  nacional: porPeso(4.5),
  internacional,
  campania: tarifaPlana(0),
} satisfies Record<string, CalculoEnvio>;

export type Modalidad = keyof typeof modalidades;

export class Checkout {
  constructor(private readonly envio: CalculoEnvio) {}
  total(pedido: Pedido): number {
    return pedido.subtotal + this.envio(pedido);
  }
}

// ── Uso: la modalidad la elige el cliente en tiempo de ejecución ──
const pedido: Pedido = { subtotal: 200, pesoKg: 3.2, pais: 'ES' };

for (const modalidad of Object.keys(modalidades) as Modalidad[]) {
  console.log(modalidad.padEnd(14), new Checkout(modalidades[modalidad]).total(pedido));
}
// ciudad 210 · nacional 214.4 · internacional 260 · campania 200
Ver los 23 patrones en TypeScript →