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
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?
};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.
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.
quizPon a prueba lo que leíste
Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.
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.
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' ]LO IDIOMÁTICO EN C# / .NET: Los comandos implementan IComando y el historial es una Stack<T>, la pila de la biblioteca estándar; TryPop evita comprobar antes si está vacía. Cada comando guarda en un diccionario lo que necesita para deshacerse.
var repo = new RepoProductos();
var panel = new Invocador();
panel.Ejecutar(new AjustarPrecios(repo, "perifericos", 1.1m), "ana");
panel.Ejecutar(new DesactivarProducto(repo, "monitor"), "ana");
Console.WriteLine(repo.Listar()); // teclado 110, mouse 44, monitor 900 (inactivo)
panel.DeshacerUltimo();
panel.DeshacerUltimo();
Console.WriteLine(repo.Listar()); // teclado 100, mouse 40, monitor 900
public record Producto(string Id, string Categoria)
{
public decimal Precio { get; set; }
public bool Activo { get; set; } = true;
}
public class RepoProductos
{
private readonly List<Producto> _productos =
[
new("teclado", "perifericos") { Precio = 100 },
new("mouse", "perifericos") { Precio = 40 },
new("monitor", "pantallas") { Precio = 900 },
];
public IEnumerable<Producto> DeCategoria(string categoria) => _productos.Where(p => p.Categoria == categoria);
public Producto Buscar(string id) =>
_productos.FirstOrDefault(p => p.Id == id) ?? throw new KeyNotFoundException($"No existe el producto {id}");
public string Listar() =>
string.Join(", ", _productos.Select(p => $"{p.Id} {p.Precio:0.##}{(p.Activo ? "" : " (inactivo)")}"));
}
public interface IComando
{
string Descripcion { get; }
void Ejecutar();
void Deshacer();
}
public class AjustarPrecios(RepoProductos repo, string categoria, decimal factor) : IComando
{
private readonly Dictionary<string, decimal> _anteriores = [];
public string Descripcion => $"Ajustar precios de {categoria} ×{factor}";
public void Ejecutar()
{
foreach (var producto in repo.DeCategoria(categoria))
{
_anteriores[producto.Id] = producto.Precio;
producto.Precio = Math.Round(producto.Precio * factor, 2);
}
}
public void Deshacer()
{
foreach (var (id, precio) in _anteriores) repo.Buscar(id).Precio = precio;
}
}
public class DesactivarProducto(RepoProductos repo, string id) : IComando
{
public string Descripcion => $"Desactivar {id}";
public void Ejecutar() => repo.Buscar(id).Activo = false;
public void Deshacer() => repo.Buscar(id).Activo = true;
}
public class Invocador
{
private readonly Stack<IComando> _historial = new();
public void Ejecutar(IComando comando, string usuario)
{
comando.Ejecutar();
_historial.Push(comando);
Console.WriteLine($"[auditoría] {usuario}: {comando.Descripcion}");
}
public void DeshacerUltimo()
{
if (_historial.TryPop(out var comando)) comando.Deshacer();
}
}LO IDIOMÁTICO EN JAVA: Los comandos implementan una interfaz y el historial es un ArrayDeque usado como pila: es lo que recomienda la documentación de Java en lugar de la antigua clase Stack. Cada comando guarda en un Map lo que necesita para deshacerse.
void main() {
var repo = new RepoProductos();
var panel = new Invocador();
panel.ejecutar(new AjustarPrecios(repo, "perifericos", 1.1), "ana");
panel.ejecutar(new DesactivarProducto(repo, "monitor"), "ana");
IO.println(repo.listar()); // [teclado 110, mouse 44, monitor 900 (inactivo)]
panel.deshacerUltimo();
panel.deshacerUltimo();
IO.println(repo.listar()); // [teclado 100, mouse 40, monitor 900]
}
final class Producto {
final String id;
final String categoria;
double precio;
boolean activo = true;
Producto(String id, String categoria, double precio) {
this.id = id;
this.categoria = categoria;
this.precio = precio;
}
}
final class RepoProductos {
private final List<Producto> productos = List.of(
new Producto("teclado", "perifericos", 100),
new Producto("mouse", "perifericos", 40),
new Producto("monitor", "pantallas", 900));
List<Producto> deCategoria(String categoria) {
return productos.stream().filter(p -> p.categoria.equals(categoria)).toList();
}
Producto buscar(String id) {
return productos.stream().filter(p -> p.id.equals(id)).findFirst()
.orElseThrow(() -> new NoSuchElementException("No existe el producto " + id));
}
List<String> listar() {
return productos.stream()
.map(p -> "%s %s%s".formatted(p.id, Math.round(p.precio), p.activo ? "" : " (inactivo)"))
.toList();
}
}
interface Comando {
String descripcion();
void ejecutar();
void deshacer();
}
final class AjustarPrecios implements Comando {
private final RepoProductos repo;
private final String categoria;
private final double factor;
private final Map<String, Double> anteriores = new HashMap<>();
AjustarPrecios(RepoProductos repo, String categoria, double factor) {
this.repo = repo;
this.categoria = categoria;
this.factor = factor;
}
@Override public String descripcion() { return "Ajustar precios de " + categoria + " ×" + factor; }
@Override public void ejecutar() {
for (var producto : repo.deCategoria(categoria)) {
anteriores.put(producto.id, producto.precio);
producto.precio = Math.round(producto.precio * factor * 100) / 100.0;
}
}
@Override public void deshacer() {
anteriores.forEach((id, precio) -> repo.buscar(id).precio = precio);
}
}
final class DesactivarProducto implements Comando {
private final RepoProductos repo;
private final String id;
DesactivarProducto(RepoProductos repo, String id) {
this.repo = repo;
this.id = id;
}
@Override public String descripcion() { return "Desactivar " + id; }
@Override public void ejecutar() { repo.buscar(id).activo = false; }
@Override public void deshacer() { repo.buscar(id).activo = true; }
}
final class Invocador {
private final Deque<Comando> historial = new ArrayDeque<>();
void ejecutar(Comando comando, String usuario) {
comando.ejecutar();
historial.push(comando);
IO.println("[auditoría] " + usuario + ": " + comando.descripcion());
}
void deshacerUltimo() {
var comando = historial.poll(); // null si está vacía
if (comando != null) comando.deshacer();
}
}LO IDIOMÁTICO EN JAVASCRIPT: Cada comando es un objeto creado por una función fábrica: la closure guarda los datos que necesita y los valores anteriores para poder deshacer. El invocador solo exige que el objeto tenga ejecutar, deshacer y descripcion.
function crearRepoProductos() {
const productos = new Map([
['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 }],
]);
return {
deCategoria: async (categoria) => [...productos.values()].filter((p) => p.categoria === categoria),
actualizar: async (id, cambios) => Object.assign(productos.get(id), cambios),
listar: () => [...productos.values()].map((p) => `${p.id} ${p.precio}${p.activo ? '' : ' (inactivo)'}`),
};
}
const ajustarPrecios = (repo, categoria, factor) => {
const anteriores = new Map();
return {
descripcion: `Ajustar precios de ${categoria} ×${factor}`,
async ejecutar() {
for (const p of await repo.deCategoria(categoria)) {
anteriores.set(p.id, p.precio);
await repo.actualizar(p.id, { precio: Math.round(p.precio * factor * 100) / 100 });
}
},
async deshacer() {
for (const [id, precio] of anteriores) await repo.actualizar(id, { precio });
},
};
};
const desactivarProducto = (repo, id) => ({
descripcion: `Desactivar ${id}`,
ejecutar: () => repo.actualizar(id, { activo: false }),
deshacer: () => repo.actualizar(id, { activo: true }),
});
export function crearInvocador() {
const historial = [];
return {
async ejecutar(comando, usuario) {
await comando.ejecutar();
historial.push(comando);
console.log(`[auditoría] ${usuario}: ${comando.descripcion}`);
},
async deshacerUltimo() {
await historial.pop()?.deshacer();
},
};
}
// ── Uso ──
const repo = crearRepoProductos();
const panel = crearInvocador();
await panel.ejecutar(ajustarPrecios(repo, 'perifericos', 1.1), 'ana');
await panel.ejecutar(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' ]LO IDIOMÁTICO EN PYTHON: Los comandos son dataclass que cumplen un Protocol con ejecutar y deshacer. Los datos internos (los precios anteriores) se declaran con field(init=False) para que no formen parte del constructor. El historial es una lista usada como pila.
from dataclasses import dataclass, field
from typing import Protocol
@dataclass
class Producto:
id: str
categoria: str
precio: float
activo: bool = True
class RepoProductos:
def __init__(self) -> None:
self._productos = {p.id: p for p in [
Producto("teclado", "perifericos", 100),
Producto("mouse", "perifericos", 40),
Producto("monitor", "pantallas", 900),
]}
def de_categoria(self, categoria: str) -> list[Producto]:
return [p for p in self._productos.values() if p.categoria == categoria]
def obtener(self, id: str) -> Producto:
return self._productos[id]
def listar(self) -> list[str]:
return [f"{p.id} {p.precio:g}{'' if p.activo else ' (inactivo)'}" for p in self._productos.values()]
class Comando(Protocol):
@property
def descripcion(self) -> str: ...
def ejecutar(self) -> None: ...
def deshacer(self) -> None: ...
@dataclass
class AjustarPrecios:
repo: RepoProductos
categoria: str
factor: float
_anteriores: dict[str, float] = field(default_factory=dict, init=False)
@property
def descripcion(self) -> str:
return f"Ajustar precios de {self.categoria} ×{self.factor}"
def ejecutar(self) -> None:
for producto in self.repo.de_categoria(self.categoria):
self._anteriores[producto.id] = producto.precio
producto.precio = round(producto.precio * self.factor, 2)
def deshacer(self) -> None:
for id, precio in self._anteriores.items():
self.repo.obtener(id).precio = precio
@dataclass
class DesactivarProducto:
repo: RepoProductos
id: str
@property
def descripcion(self) -> str:
return f"Desactivar {self.id}"
def ejecutar(self) -> None:
self.repo.obtener(self.id).activo = False
def deshacer(self) -> None:
self.repo.obtener(self.id).activo = True
class Invocador:
def __init__(self) -> None:
self._historial: list[Comando] = []
def ejecutar(self, comando: Comando, usuario: str) -> None:
comando.ejecutar()
self._historial.append(comando)
print(f"[auditoría] {usuario}: {comando.descripcion}")
def deshacer_ultimo(self) -> None:
if self._historial:
self._historial.pop().deshacer()
if __name__ == "__main__":
repo = RepoProductos()
panel = Invocador()
panel.ejecutar(AjustarPrecios(repo, "perifericos", 1.1), "ana")
panel.ejecutar(DesactivarProducto(repo, "monitor"), "ana")
print(repo.listar()) # ['teclado 110', 'mouse 44', 'monitor 900 (inactivo)']
panel.deshacer_ultimo()
panel.deshacer_ultimo()
print(repo.listar()) # ['teclado 100', 'mouse 40', 'monitor 900']LO IDIOMÁTICO EN GO: Los comandos implementan una interfaz pequeña de tres métodos. Como Ejecutar y Deshacer devuelven error, el invocador solo guarda en el historial lo que se ejecutó bien, y el error llega a quien lo pidió con el contexto añadido por %w.
package main
import (
"fmt"
"math"
)
type Producto struct {
ID string
Categoria string
Precio float64
Activo bool
}
type RepoProductos struct{ productos []*Producto }
func NuevoRepo() *RepoProductos {
return &RepoProductos{[]*Producto{
{"teclado", "perifericos", 100, true},
{"mouse", "perifericos", 40, true},
{"monitor", "pantallas", 900, true},
}}
}
func (r *RepoProductos) Buscar(id string) (*Producto, error) {
for _, p := range r.productos {
if p.ID == id {
return p, nil
}
}
return nil, fmt.Errorf("no existe el producto %s", id)
}
func (r *RepoProductos) DeCategoria(categoria string) []*Producto {
var resultado []*Producto
for _, p := range r.productos {
if p.Categoria == categoria {
resultado = append(resultado, p)
}
}
return resultado
}
func (r *RepoProductos) Listar() []string {
lista := make([]string, len(r.productos))
for i, p := range r.productos {
lista[i] = fmt.Sprintf("%s %g", p.ID, p.Precio)
if !p.Activo {
lista[i] += " (inactivo)"
}
}
return lista
}
type Comando interface {
Ejecutar() error
Deshacer() error
Descripcion() string
}
type AjustarPrecios struct {
repo *RepoProductos
categoria string
factor float64
anteriores map[string]float64
}
func (c *AjustarPrecios) Descripcion() string {
return fmt.Sprintf("Ajustar precios de %s ×%g", c.categoria, c.factor)
}
func (c *AjustarPrecios) Ejecutar() error {
c.anteriores = map[string]float64{}
for _, p := range c.repo.DeCategoria(c.categoria) {
c.anteriores[p.ID] = p.Precio
p.Precio = math.Round(p.Precio*c.factor*100) / 100
}
return nil
}
func (c *AjustarPrecios) Deshacer() error {
for id, precio := range c.anteriores {
p, err := c.repo.Buscar(id)
if err != nil {
return err
}
p.Precio = precio
}
return nil
}
type DesactivarProducto struct {
repo *RepoProductos
id string
}
func (c DesactivarProducto) Descripcion() string { return "Desactivar " + c.id }
func (c DesactivarProducto) Ejecutar() error { return c.cambiar(false) }
func (c DesactivarProducto) Deshacer() error { return c.cambiar(true) }
func (c DesactivarProducto) cambiar(activo bool) error {
p, err := c.repo.Buscar(c.id)
if err != nil {
return err
}
p.Activo = activo
return nil
}
type Invocador struct{ historial []Comando }
func (i *Invocador) Ejecutar(c Comando, usuario string) error {
if err := c.Ejecutar(); err != nil {
return fmt.Errorf("%s: %w", c.Descripcion(), err)
}
i.historial = append(i.historial, c)
fmt.Printf("[auditoría] %s: %s\n", usuario, c.Descripcion())
return nil
}
func (i *Invocador) DeshacerUltimo() error {
if len(i.historial) == 0 {
return nil
}
ultimo := i.historial[len(i.historial)-1]
i.historial = i.historial[:len(i.historial)-1]
return ultimo.Deshacer()
}
func main() {
repo := NuevoRepo()
panel := &Invocador{}
_ = panel.Ejecutar(&AjustarPrecios{repo: repo, categoria: "perifericos", factor: 1.1}, "ana")
_ = panel.Ejecutar(DesactivarProducto{repo, "monitor"}, "ana")
fmt.Println(repo.Listar()) // [teclado 110 mouse 44 monitor 900 (inactivo)]
_ = panel.DeshacerUltimo()
_ = panel.DeshacerUltimo()
fmt.Println(repo.Listar()) // [teclado 100 mouse 40 monitor 900]
err := panel.Ejecutar(DesactivarProducto{repo, "silla"}, "ana")
fmt.Println("error:", err) // error: Desactivar silla: no existe el producto silla
}LO IDIOMÁTICO EN RUST: El borrow checker no deja que cada comando guarde una referencia mutable al repositorio mientras está en el historial, así que el diseño idiomático es pasar el repositorio (&mut) al ejecutar y al deshacer. Los comandos son Box<dyn Comando> dentro de un Vec usado como pila.
struct Producto {
id: &'static str,
categoria: &'static str,
precio: f64,
activo: bool,
}
struct Repo {
productos: Vec<Producto>,
}
impl Repo {
fn buscar(&mut self, id: &str) -> Result<&mut Producto, String> {
self.productos
.iter_mut()
.find(|p| p.id == id)
.ok_or(format!("no existe el producto {id}"))
}
fn listar(&self) -> Vec<String> {
self.productos
.iter()
.map(|p| {
format!(
"{} {}{}",
p.id,
p.precio,
if p.activo { "" } else { " (inactivo)" }
)
})
.collect()
}
}
trait Comando {
fn descripcion(&self) -> String;
fn ejecutar(&mut self, repo: &mut Repo) -> Result<(), String>;
fn deshacer(&mut self, repo: &mut Repo) -> Result<(), String>;
}
struct AjustarPrecios {
categoria: &'static str,
factor: f64,
anteriores: Vec<(&'static str, f64)>,
}
impl Comando for AjustarPrecios {
fn descripcion(&self) -> String {
format!("Ajustar precios de {} ×{}", self.categoria, self.factor)
}
fn ejecutar(&mut self, repo: &mut Repo) -> Result<(), String> {
for producto in repo
.productos
.iter_mut()
.filter(|p| p.categoria == self.categoria)
{
self.anteriores.push((producto.id, producto.precio));
producto.precio = (producto.precio * self.factor * 100.0).round() / 100.0;
}
Ok(())
}
fn deshacer(&mut self, repo: &mut Repo) -> Result<(), String> {
for (id, precio) in self.anteriores.drain(..) {
repo.buscar(id)?.precio = precio;
}
Ok(())
}
}
struct DesactivarProducto {
id: &'static str,
}
impl Comando for DesactivarProducto {
fn descripcion(&self) -> String {
format!("Desactivar {}", self.id)
}
fn ejecutar(&mut self, repo: &mut Repo) -> Result<(), String> {
repo.buscar(self.id)?.activo = false;
Ok(())
}
fn deshacer(&mut self, repo: &mut Repo) -> Result<(), String> {
repo.buscar(self.id)?.activo = true;
Ok(())
}
}
#[derive(Default)]
struct Invocador {
historial: Vec<Box<dyn Comando>>,
}
impl Invocador {
fn ejecutar(
&mut self,
mut comando: Box<dyn Comando>,
repo: &mut Repo,
usuario: &str,
) -> Result<(), String> {
comando.ejecutar(repo)?;
println!("[auditoría] {usuario}: {}", comando.descripcion());
self.historial.push(comando);
Ok(())
}
fn deshacer_ultimo(&mut self, repo: &mut Repo) -> Result<(), String> {
match self.historial.pop() {
Some(mut comando) => comando.deshacer(repo),
None => Ok(()),
}
}
}
fn main() -> Result<(), String> {
let mut repo = Repo {
productos: vec![
Producto {
id: "teclado",
categoria: "perifericos",
precio: 100.0,
activo: true,
},
Producto {
id: "mouse",
categoria: "perifericos",
precio: 40.0,
activo: true,
},
Producto {
id: "monitor",
categoria: "pantallas",
precio: 900.0,
activo: true,
},
],
};
let mut panel = Invocador::default();
let ajuste = AjustarPrecios {
categoria: "perifericos",
factor: 1.1,
anteriores: Vec::new(),
};
panel.ejecutar(Box::new(ajuste), &mut repo, "ana")?;
panel.ejecutar(
Box::new(DesactivarProducto { id: "monitor" }),
&mut repo,
"ana",
)?;
println!("{:?}", repo.listar()); // ["teclado 110", "mouse 44", "monitor 900 (inactivo)"]
panel.deshacer_ultimo(&mut repo)?;
panel.deshacer_ultimo(&mut repo)?;
println!("{:?}", repo.listar()); // ["teclado 100", "mouse 40", "monitor 900"]
let error = panel.ejecutar(
Box::new(DesactivarProducto { id: "silla" }),
&mut repo,
"ana",
);
println!("{error:?}"); // Err("no existe el producto silla")
Ok(())
}LO IDIOMÁTICO EN PHP: Los comandos implementan una interfaz y el historial es un SplStack, la pila de la biblioteca estándar de PHP. Cada comando recibe sus dependencias con promoción de propiedades y guarda lo que necesita para deshacerse.
<?php
declare(strict_types=1);
final class Producto
{
public function __construct(
public readonly string $id,
public readonly string $categoria,
public float $precio,
public bool $activo = true,
) {}
}
final class RepoProductos
{
/** @var array<string, Producto> */
private array $productos = [];
public function __construct(Producto ...$productos)
{
foreach ($productos as $p) $this->productos[$p->id] = $p;
}
/** @return list<Producto> */
public function deCategoria(string $categoria): array
{
return array_values(array_filter($this->productos, fn (Producto $p) => $p->categoria === $categoria));
}
public function buscar(string $id): Producto
{
return $this->productos[$id] ?? throw new OutOfBoundsException("No existe el producto {$id}");
}
public function listar(): string
{
return implode(', ', array_map(fn (Producto $p) => "{$p->id} {$p->precio}" . ($p->activo ? '' : ' (inactivo)'), $this->productos));
}
}
interface Comando
{
public function descripcion(): string;
public function ejecutar(): void;
public function deshacer(): void;
}
final class AjustarPrecios implements Comando
{
/** @var array<string, float> */
private array $anteriores = [];
public function __construct(private readonly RepoProductos $repo, private readonly string $categoria, private readonly float $factor) {}
public function descripcion(): string { return "Ajustar precios de {$this->categoria} ×{$this->factor}"; }
public function ejecutar(): void
{
foreach ($this->repo->deCategoria($this->categoria) as $producto) {
$this->anteriores[$producto->id] = $producto->precio;
$producto->precio = round($producto->precio * $this->factor, 2);
}
}
public function deshacer(): void
{
foreach ($this->anteriores as $id => $precio) $this->repo->buscar($id)->precio = $precio;
}
}
final readonly class DesactivarProducto implements Comando
{
public function __construct(private RepoProductos $repo, private string $id) {}
public function descripcion(): string { return "Desactivar {$this->id}"; }
public function ejecutar(): void { $this->repo->buscar($this->id)->activo = false; }
public function deshacer(): void { $this->repo->buscar($this->id)->activo = true; }
}
final class Invocador
{
/** @var SplStack<Comando> */
private SplStack $historial;
public function __construct() { $this->historial = new SplStack(); }
public function ejecutar(Comando $comando, string $usuario): void
{
$comando->ejecutar();
$this->historial->push($comando);
echo "[auditoría] {$usuario}: {$comando->descripcion()}\n";
}
public function deshacerUltimo(): void
{
if (!$this->historial->isEmpty()) $this->historial->pop()->deshacer();
}
}
$repo = new RepoProductos(
new Producto('teclado', 'perifericos', 100),
new Producto('mouse', 'perifericos', 40),
new Producto('monitor', 'pantallas', 900),
);
$panel = new Invocador();
$panel->ejecutar(new AjustarPrecios($repo, 'perifericos', 1.1), 'ana');
$panel->ejecutar(new DesactivarProducto($repo, 'monitor'), 'ana');
echo $repo->listar(), "\n"; // teclado 110, mouse 44, monitor 900 (inactivo)
$panel->deshacerUltimo();
$panel->deshacerUltimo();
echo $repo->listar(), "\n"; // teclado 100, mouse 40, monitor 900