Patrón Strategy explicado con ejemplos

Intención y el problema que resuelve

Intención: definir una familia de algoritmos, encapsular cada uno y hacerlos intercambiables. Strategy permite que el algoritmo varíe independientemente de los clientes que lo usan. Es uno de los patrones de comportamiento del libro de la Banda de los Cuatro (Gang of Four, GoF), donde también se llama Policy.

Supón que un proceso de pago calcula el coste de envío. El envío estándar es una tarifa fija, el exprés cuesta más por kilogramo y la recogida en tienda es gratis. Una primera versión pone las tres fórmulas en un método con una cadena if/else sobre el tipo de envío. Cada opción nueva, como un mensajero asociado, significa editar de nuevo ese método, y probar una fórmula implica pasar por todas las demás.

Con Strategy, cada fórmula se convierte en su propio objeto o función con la misma firma. El proceso de pago recibe la estrategia elegida y la llama. Añadir un mensajero significa añadir una estrategia nueva; el proceso de pago no cambia.

Estructura y participantes

Implementación en TypeScript

Como las funciones son valores en TypeScript, la interfaz de estrategia más simple es un tipo función. El contexto es la clase Checkout.

type Parcel = { weightKg: number; subtotal: number };
type ShippingStrategy = (parcel: Parcel) => number;

const standard: ShippingStrategy = (p) => (p.subtotal >= 50 ? 0 : 4.99);
const express: ShippingStrategy = (p) => 9.99 + 1.5 * p.weightKg;
const pickup: ShippingStrategy = () => 0;

class Checkout {
  constructor(private shipping: ShippingStrategy) {}

  setShipping(strategy: ShippingStrategy) {
    this.shipping = strategy;
  }

  total(parcel: Parcel): number {
    return Math.round((parcel.subtotal + this.shipping(parcel)) * 100) / 100;
  }
}

const parcel = { weightKg: 2, subtotal: 30 };
const checkout = new Checkout(standard);
console.log(checkout.total(parcel)); // 34.99
checkout.setShipping(express);
console.log(checkout.total(parcel)); // 42.99
checkout.setShipping(pickup);
console.log(checkout.total(parcel)); // 30

Si una estrategia necesita configuración o varios métodos, usa una interfaz y clases. Esta versión también da a cada estrategia un nombre que la interfaz puede mostrar:

interface Shipping {
  readonly label: string;
  cost(weightKg: number): number;
}

class Courier implements Shipping {
  readonly label: string;
  constructor(private ratePerKg: number, company: string) {
    this.label = company + " courier";
  }
  cost(weightKg: number) { return this.ratePerKg * weightKg; }
}

const options: Shipping[] = [new Courier(2, "North"), new Courier(3.5, "Fast")];
for (const o of options) console.log(o.label, o.cost(4));
// North courier 8
// Fast courier 14

Antes y después

Antes, la elección del algoritmo está fijada dentro del método:

function shippingCost(type: string, p: Parcel): number {
  if (type === "standard") return p.subtotal >= 50 ? 0 : 4.99;
  else if (type === "express") return 9.99 + 1.5 * p.weightKg;
  else if (type === "pickup") return 0;
  throw new Error("Unknown shipping type " + type);
}
// After: a lookup table of strategies replaces the chain
const strategies: Record<string, ShippingStrategy> = { standard, express, pickup };

Este fragmento reutiliza los tipos y las funciones del primer ejemplo. La tabla convierte el conjunto de opciones en datos en lugar de código, de modo que puede construirse desde la configuración o ampliarse mediante plugins.

Cuándo usarlo y cuándo no

• Úsalo cuando hay varias formas de hacer la misma tarea y la elección depende de la configuración, de la entrada del usuario o de los datos.
• Úsalo para eliminar grandes bloques condicionales que eligen entre algoritmos.
• Úsalo para probar cada algoritmo de forma aislada y permitir que otro código añada nuevos algoritmos sin editar el contexto.
• No lo uses cuando solo hay un algoritmo y no hay una necesidad real de cambiarlo. Una interfaz adicional añade indirección para nada.
• No crees clases cuando basta un parámetro de función. En TypeScript, pasar una función es la forma ligera de Strategy.

Usos en el mundo real

• Array.prototype.sort(compareFn) recibe la estrategia de comparación como una función, así que la misma ordenación puede ordenar números, fechas o nombres.
• La interfaz Comparator de Java es una estrategia para Collections.sort y List.sort.
• Passport.js, el middleware de autenticación para Node.js, llama estrategia a cada método de inicio de sesión (contraseña local, proveedores OAuth) y permite que las aplicaciones los conecten.
• Las bibliotecas de compresión y de hash dejan que quien llama elija un algoritmo mediante una interfaz común.

Patrones relacionados