Arquetipo
Patrones de comportamientoUso: AltaComplejidad: Media

Command

Comando · Acción · Transacción

Convierte una petición en un objeto con toda la información necesaria, para poder encolarla, registrarla, programarla o deshacerla.

“Quiero encolar, registrar o deshacer acciones del usuario.”

workEl caso real

En el panel de administración de una tienda, el equipo comercial aplica cambios masivos: subir los precios de una categoría un 10 %, mover productos de categoría o desactivarlos. Necesitan deshacer el último cambio, dejar registro de quién hizo qué para auditoría y programar algunos cambios para la medianoche en que empieza una campaña.

warningEl problema sin el patrón

Cada botón del panel modifica la base de datos directamente. No queda registro de los valores anteriores, así que deshacer es imposible, y programar un cambio obliga a duplicar la lógica en una tarea aparte.

check_circleCómo lo resuelve el patrón

Cada acción se convierte en un objeto comando con ejecutar() y deshacer(), que guarda los datos que necesita y, al ejecutarse, los valores anteriores para poder revertir. Un invocador ejecuta los comandos, los apila en un historial y los registra; un planificador puede guardar el mismo comando para ejecutarlo más tarde.

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
botonSubirPrecios.onClick = async () => {
  await db.query('UPDATE productos SET precio = precio * 1.10 WHERE categoria = ?', [categoria]);
  // ¿cuáles eran los precios anteriores? ¿quién lo hizo? ¿cómo se programa?
};
check_circleCon el patrónDESPUÉS
interface Comando {
  ejecutar(): Promise<void>;
  deshacer(): Promise<void>;
}

class AjustarPrecios implements Comando {
  private anteriores = new Map<string, number>();
  constructor(private repo: RepoProductos, private categoria: string, private factor: number) {}

  async ejecutar() {
    for (const p of await this.repo.deCategoria(this.categoria)) {
      this.anteriores.set(p.id, p.precio);
      await this.repo.cambiarPrecio(p.id, p.precio * this.factor);
    }
  }

  async deshacer() {
    for (const [id, precio] of this.anteriores) await this.repo.cambiarPrecio(id, precio);
  }
}

class Invocador {
  private historial: Comando[] = [];

  async ejecutar(comando: Comando, usuario: string) {
    await comando.ejecutar();
    this.historial.push(comando);
    auditoria.registrar(usuario, comando);
  }

  async deshacerUltimo() { await this.historial.pop()?.deshacer(); }
}

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

lightbulb

Matiz importante

Como un comando es un objeto con todos sus datos, también se puede serializar: guardarlo en la base de datos para ejecutarlo más tarde, reintentarlo si falla o enviarlo a otro servicio para que lo ejecute allí.

thumb_upCuándo usarlo

  • ✓Necesitas deshacer y rehacer, auditar, encolar o programar acciones.
  • ✓La misma acción se dispara desde varios lugares (botón, atajo de teclado, API, tarea programada).
  • ✓Quieres tratar las operaciones como datos: guardarlas, reintentarlas o enviarlas a una cola.
  • ✓Quieres agrupar varios comandos simples en uno compuesto (una "macro") que se ejecuta y se deshace como una sola acción.

do_not_disturb_onCuándo no usarlo

  • ✕La acción es simple, se dispara desde un solo lugar y no necesita historial: una función basta.

memoryPrincipios en juego

  • •Responsabilidad única: quien dispara la acción (botón, tarea, API) no sabe cómo se ejecuta.
  • •Abierto/Cerrado: una acción nueva es una clase nueva.

hubPatrones relacionados

  • •Memento: un comando puede guardar un memento del estado previo para poder deshacer.
  • •Chain of Responsibility: los comandos pueden pasar por una cadena de manejadores.
  • •Strategy: ambos convierten comportamiento en objetos; el comando representa una operación concreta con sus datos, la estrategia una forma de hacer algo.
compare_arrowsSe suele confundir conCommand vs Strategy →

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_blocksCommand en tu lenguaje

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

LO IDIOMÁTICO EN TYPESCRIPT: Los comandos implementan una interfaz con métodos async y una descripción para la auditoría. El historial es un array usado como pila, y ?. evita comprobar si está vacío al deshacer.

command.ts · 85 líneas
interface Producto {
  id: string;
  categoria: string;
  precio: number;
  activo: boolean;
}

class RepoProductos {
  readonly #productos = new Map<string, Producto>([
    ['teclado', { id: 'teclado', categoria: 'perifericos', precio: 100, activo: true }],
    ['mouse', { id: 'mouse', categoria: 'perifericos', precio: 40, activo: true }],
    ['monitor', { id: 'monitor', categoria: 'pantallas', precio: 900, activo: true }],
  ]);

  async deCategoria(categoria: string): Promise<Producto[]> {
    return [...this.#productos.values()].filter((p) => p.categoria === categoria);
  }

  async actualizar(id: string, cambios: Partial<Producto>): Promise<void> {
    const producto = this.#productos.get(id);
    if (producto) Object.assign(producto, cambios);
  }

  listar(): string[] {
    return [...this.#productos.values()].map((p) => `${p.id} ${p.precio}${p.activo ? '' : ' (inactivo)'}`);
  }
}

export interface Comando {
  readonly descripcion: string;
  ejecutar(): Promise<void>;
  deshacer(): Promise<void>;
}

class AjustarPrecios implements Comando {
  readonly #anteriores = new Map<string, number>();
  constructor(private readonly repo: RepoProductos, private readonly categoria: string, private readonly factor: number) {}

  get descripcion() { return `Ajustar precios de ${this.categoria} ×${this.factor}`; }

  async ejecutar() {
    for (const p of await this.repo.deCategoria(this.categoria)) {
      this.#anteriores.set(p.id, p.precio);
      await this.repo.actualizar(p.id, { precio: Math.round(p.precio * this.factor * 100) / 100 });
    }
  }

  async deshacer() {
    for (const [id, precio] of this.#anteriores) await this.repo.actualizar(id, { precio });
  }
}

class DesactivarProducto implements Comando {
  constructor(private readonly repo: RepoProductos, private readonly id: string) {}

  get descripcion() { return `Desactivar ${this.id}`; }
  async ejecutar() { await this.repo.actualizar(this.id, { activo: false }); }
  async deshacer() { await this.repo.actualizar(this.id, { activo: true }); }
}

export class Invocador {
  readonly #historial: Comando[] = [];

  async ejecutar(comando: Comando, usuario: string): Promise<void> {
    await comando.ejecutar();
    this.#historial.push(comando);
    console.log(`[auditoría] ${usuario}: ${comando.descripcion}`);
  }

  async deshacerUltimo(): Promise<void> {
    await this.#historial.pop()?.deshacer();
  }
}

// ── Uso ──
const repo = new RepoProductos();
const panel = new Invocador();

await panel.ejecutar(new AjustarPrecios(repo, 'perifericos', 1.1), 'ana');
await panel.ejecutar(new DesactivarProducto(repo, 'monitor'), 'ana');
console.log(repo.listar()); // [ 'teclado 110', 'mouse 44', 'monitor 900 (inactivo)' ]

await panel.deshacerUltimo();
await panel.deshacerUltimo();
console.log(repo.listar()); // [ 'teclado 100', 'mouse 40', 'monitor 900' ]
Ver los 23 patrones en TypeScript →