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
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');
}
}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.
quizPon a prueba lo que leíste
Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.
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).
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 200LO IDIOMÁTICO EN C# / .NET: Una estrategia puede ser simplemente un delegado Func<Pedido, decimal>: las lambdas y las funciones que devuelven funciones sustituyen a una clase por algoritmo. Para dinero se usa decimal, que no tiene los errores de redondeo de double.
var tarifasPais = new Dictionary<string, decimal> { ["US"] = 45, ["ES"] = 60 };
(string Nombre, Func<Pedido, decimal> Calcular)[] modalidades =
[
("ciudad", TarifaPlana(10)),
("nacional", PorPeso(4.5m)),
("internacional", pedido => tarifasPais.GetValueOrDefault(pedido.Pais, 80)),
("campania", TarifaPlana(0)),
];
var pedidoEjemplo = new Pedido(Subtotal: 200, PesoKg: 3.2m, Pais: "ES");
// La modalidad la elige el cliente en tiempo de ejecución
foreach (var (nombre, calcular) in modalidades)
Console.WriteLine($"{nombre,-14} {TotalConEnvio(pedidoEjemplo, calcular):0.##}");
// ciudad 210 · nacional 214.4 · internacional 260 · campania 200
static Func<Pedido, decimal> TarifaPlana(decimal monto) => _ => monto;
static Func<Pedido, decimal> PorPeso(decimal precioPorKg) => pedido => Math.Round(pedido.PesoKg * precioPorKg, 2);
static decimal TotalConEnvio(Pedido pedido, Func<Pedido, decimal> calcularEnvio) => pedido.Subtotal + calcularEnvio(pedido);
public record Pedido(decimal Subtotal, decimal PesoKg, string Pais);LO IDIOMÁTICO EN JAVA: Desde Java 8, una estrategia con un solo método es una interfaz funcional y cada algoritmo se escribe como lambda o referencia a método, sin una clase por estrategia. El catálogo es una lista de record. (Para dinero real se usaría BigDecimal; aquí double simplifica el ejemplo.)
void main() {
var pedido = new Pedido(200, 3.2, "ES");
// La modalidad la elige el cliente en tiempo de ejecución
for (var modalidad : MODALIDADES) {
IO.println("%-14s %s".formatted(modalidad.nombre(), formatear(new Checkout(modalidad.calculo()).total(pedido))));
}
// ciudad 210 · nacional 214.4 · internacional 260 · campania 200
}
record Modalidad(String nombre, CalculoEnvio calculo) {}
final List<Modalidad> MODALIDADES = List.of(
new Modalidad("ciudad", CalculoEnvio.tarifaPlana(10)),
new Modalidad("nacional", CalculoEnvio.porPeso(4.5)),
new Modalidad("internacional", CalculoEnvio::internacional),
new Modalidad("campania", CalculoEnvio.tarifaPlana(0)));
String formatear(double valor) {
return BigDecimal.valueOf(valor).stripTrailingZeros().toPlainString();
}
record Pedido(double subtotal, double pesoKg, String pais) {}
@FunctionalInterface
interface CalculoEnvio {
double calcular(Pedido pedido);
static CalculoEnvio tarifaPlana(double monto) {
return pedido -> monto;
}
static CalculoEnvio porPeso(double precioPorKg) {
return pedido -> Math.round(pedido.pesoKg() * precioPorKg * 100) / 100.0;
}
static double internacional(Pedido pedido) {
return Map.of("US", 45.0, "ES", 60.0).getOrDefault(pedido.pais(), 80.0);
}
}
record Checkout(CalculoEnvio envio) {
double total(Pedido pedido) {
return pedido.subtotal() + envio.calcular(pedido);
}
}LO IDIOMÁTICO EN JAVASCRIPT: En JavaScript una estrategia es simplemente una función. Las estrategias configurables se crean con funciones que devuelven funciones (closures), y el catálogo es un objeto literal que mapea el nombre de la modalidad a su función.
const tarifaPlana = (monto) => () => monto;
const porPeso = (precioPorKg) => (pedido) => Math.round(pedido.pesoKg * precioPorKg * 100) / 100;
const tarifasPais = { US: 45, ES: 60 };
const internacional = (pedido) => tarifasPais[pedido.pais] ?? 80;
const modalidades = {
ciudad: tarifaPlana(10),
nacional: porPeso(4.5),
internacional,
campania: tarifaPlana(0),
};
export function totalConEnvio(pedido, calcularEnvio) {
return pedido.subtotal + calcularEnvio(pedido);
}
// ── Uso: la modalidad la elige el cliente en tiempo de ejecución ──
const pedido = { subtotal: 200, pesoKg: 3.2, pais: 'ES' };
for (const [nombre, calcular] of Object.entries(modalidades)) {
console.log(nombre.padEnd(14), totalConEnvio(pedido, calcular));
}
// ciudad 210 · nacional 214.4 · internacional 260 · campania 200LO IDIOMÁTICO EN PYTHON: En Python una estrategia es simplemente una función (o cualquier "llamable"). Las estrategias configurables se crean con functools.partial, que fija algunos argumentos de una función, y el catálogo es un diccionario de funciones.
from collections.abc import Callable
from dataclasses import dataclass
from functools import partial
@dataclass(frozen=True)
class Pedido:
subtotal: float
peso_kg: float
pais: str
CalculoEnvio = Callable[[Pedido], float]
def tarifa_plana(pedido: Pedido, monto: float) -> float:
return monto
def por_peso(pedido: Pedido, precio_por_kg: float) -> float:
return round(pedido.peso_kg * precio_por_kg, 2)
def internacional(pedido: Pedido) -> float:
return {"US": 45, "ES": 60}.get(pedido.pais, 80)
MODALIDADES: dict[str, CalculoEnvio] = {
"ciudad": partial(tarifa_plana, monto=10),
"nacional": partial(por_peso, precio_por_kg=4.5),
"internacional": internacional,
"campania": partial(tarifa_plana, monto=0),
}
def total_con_envio(pedido: Pedido, calcular_envio: CalculoEnvio) -> float:
return pedido.subtotal + calcular_envio(pedido)
if __name__ == "__main__":
pedido = Pedido(subtotal=200, peso_kg=3.2, pais="ES")
# La modalidad la elige el cliente en tiempo de ejecución
for nombre, calcular in MODALIDADES.items():
print(f"{nombre:<14} {total_con_envio(pedido, calcular):g}")
# ciudad 210 · nacional 214.4 · internacional 260 · campania 200LO IDIOMÁTICO EN GO: En Go una estrategia suele ser un tipo función (type CalculoEnvio func(Pedido) float64), y las estrategias configurables se crean con closures. El catálogo es un slice y no un mapa porque así se conserva el orden al recorrerlo.
package main
import (
"fmt"
"math"
)
type Pedido struct {
Subtotal float64
PesoKg float64
Pais string
}
type CalculoEnvio func(Pedido) float64
func TarifaPlana(monto float64) CalculoEnvio {
return func(Pedido) float64 { return monto }
}
func PorPeso(precioPorKg float64) CalculoEnvio {
return func(p Pedido) float64 { return math.Round(p.PesoKg*precioPorKg*100) / 100 }
}
var tarifasPais = map[string]float64{"US": 45, "ES": 60}
func Internacional(p Pedido) float64 {
if tarifa, existe := tarifasPais[p.Pais]; existe {
return tarifa
}
return 80
}
var modalidades = []struct {
Nombre string
Calcular CalculoEnvio
}{
{"ciudad", TarifaPlana(10)},
{"nacional", PorPeso(4.5)},
{"internacional", Internacional},
{"campania", TarifaPlana(0)},
}
func TotalConEnvio(p Pedido, calcular CalculoEnvio) float64 {
return p.Subtotal + calcular(p)
}
func main() {
pedido := Pedido{Subtotal: 200, PesoKg: 3.2, Pais: "ES"}
// La modalidad la elige el cliente en tiempo de ejecución
for _, m := range modalidades {
fmt.Printf("%-14s %g\n", m.Nombre, TotalConEnvio(pedido, m.Calcular))
}
// ciudad 210 · nacional 214.4 · internacional 260 · campania 200
}LO IDIOMÁTICO EN RUST: En Rust una estrategia puede ser cualquier cierre: aquí, Box<dyn Fn(&Pedido) -> f64>. Las estrategias configurables son funciones que devuelven cierres move, que se quedan con sus parámetros. Un Vec de pares conserva el orden del catálogo.
struct Pedido {
subtotal: f64,
peso_kg: f64,
pais: &'static str,
}
type CalculoEnvio = Box<dyn Fn(&Pedido) -> f64>;
fn tarifa_plana(monto: f64) -> CalculoEnvio {
Box::new(move |_| monto)
}
fn por_peso(precio_por_kg: f64) -> CalculoEnvio {
Box::new(move |pedido| (pedido.peso_kg * precio_por_kg * 100.0).round() / 100.0)
}
fn internacional(pedido: &Pedido) -> f64 {
match pedido.pais {
"US" => 45.0,
"ES" => 60.0,
_ => 80.0,
}
}
fn total_con_envio(pedido: &Pedido, calcular_envio: &dyn Fn(&Pedido) -> f64) -> f64 {
pedido.subtotal + calcular_envio(pedido)
}
fn main() {
let modalidades: Vec<(&str, CalculoEnvio)> = vec![
("ciudad", tarifa_plana(10.0)),
("nacional", por_peso(4.5)),
("internacional", Box::new(internacional)),
("campania", tarifa_plana(0.0)),
];
let pedido = Pedido {
subtotal: 200.0,
peso_kg: 3.2,
pais: "ES",
};
// La modalidad la elige el cliente en tiempo de ejecución
for (nombre, calcular) in &modalidades {
println!(
"{nombre:<14} {}",
total_con_envio(&pedido, calcular.as_ref())
);
}
// ciudad 210 · nacional 214.4 · internacional 260 · campania 200
}LO IDIOMÁTICO EN PHP: En PHP una estrategia puede ser cualquier callable: closures (fn), funciones normales tomadas con la sintaxis de "first-class callable" (internacional(...)) o funciones que devuelven closures para las estrategias configurables. El catálogo es un array asociativo, que conserva el orden.
<?php
declare(strict_types=1);
final readonly class Pedido
{
public function __construct(public float $subtotal, public float $pesoKg, public string $pais) {}
}
function tarifaPlana(float $monto): Closure
{
return fn (Pedido $pedido): float => $monto;
}
function porPeso(float $precioPorKg): Closure
{
return fn (Pedido $pedido): float => round($pedido->pesoKg * $precioPorKg, 2);
}
function internacional(Pedido $pedido): float
{
return match ($pedido->pais) {
'US' => 45.0,
'ES' => 60.0,
default => 80.0,
};
}
/** @param callable(Pedido): float $calcularEnvio */
function totalConEnvio(Pedido $pedido, callable $calcularEnvio): float
{
return $pedido->subtotal + $calcularEnvio($pedido);
}
$modalidades = [
'ciudad' => tarifaPlana(10),
'nacional' => porPeso(4.5),
'internacional' => internacional(...),
'campania' => tarifaPlana(0),
];
$pedido = new Pedido(subtotal: 200, pesoKg: 3.2, pais: 'ES');
// La modalidad la elige el cliente en tiempo de ejecución
foreach ($modalidades as $nombre => $calcular) {
printf("%-14s %s\n", $nombre, totalConEnvio($pedido, $calcular));
}
// ciudad 210 · nacional 214.4 · internacional 260 · campania 200