Command: acciones como objetos
- Lección 20 de 32
- 11 min
- Intermedio
- 14 pasos
Un botón que llama directo a un método no deja rastro, así que no hay forma de deshacer. Vas a convertir cada acción en un objeto con `do` y `undo`, ejecutarla desde un historial y ver dónde ya usas esta idea.
- Comandos en el historial
- —
- Comandos en cola (ejemplo)
- —
- petición
- esperando en cola
- petición fallida
Paso 1 de 14
Problema
El botón hace el trabajo
Tienes un editor de texto. El botón «Hola» llama directo a doc.insert("Hola"), y un atajo de teclado llama a lo mismo por su lado. Funciona: el texto cambia.
Pero la llamada ocurre y desaparece. Nada en el programa recuerda qué se hizo ni con qué datos.
Qué cambió
- doc.insert desde el botón y desde el atajo
Paso 2 de 14
Problema
¿Qué deshago?
Ahora te piden Ctrl+Z. El atajo llega a Doc, pero Doc solo tiene su texto actual: no sabe cuál fue el último cambio ni cómo revertirlo.
Pasa lo mismo si quieres repetir la última acción, mostrar un historial o guardar acciones para hacerlas más tarde. Todo eso necesita algo que hoy no existe: la acción guardada como un dato.
Qué cambió
- Ctrl+Z
- Doc no sabe qué revertir
Paso 3 de 14
Concepto
La acción se vuelve un objeto
La idea de Command: en vez de ejecutar la acción en el momento, la guardas en un objeto. Ese objeto sabe a quién afecta (Doc), con qué datos ("Hola") y cómo hacerse y deshacerse.
Todos los comandos cumplen la misma interfaz, Command, con do() y undo(). Así, quien los ejecuta no necesita saber qué hace cada uno.
Qué cambió
- interface Command
- insert, el primer comando
Paso 4 de 14
Técnica
Un comando en pocas líneas
insert recibe el documento y el texto, y devuelve un objeto con tres cosas: una etiqueta para el historial, do, que añade el texto, y undo, que lo quita.
Aquí es una función que devuelve un objeto; una clase InsertCommand sirve igual. Lo importante es que `undo` deshace exactamente lo que hizo `do`: quita tantos caracteres como añadió.
Qué cambió
- do: añade s
- undo: quita s.length caracteres
Paso 5 de 14
Solución
Quien ejecuta, recuerda
Falta quien ejecute. run recibe cualquier Command, llama a do() y lo guarda en history. En el patrón se le llama invoker: no sabe si el comando inserta, borra o cambia el color.
El botón ya no llama a Doc: crea un comando y se lo pasa a run. Tras dos acciones, el documento dice «Hola mundo» y el historial tiene 2 comandos.
Qué cambió
- run(c), el invoker
- history
- doc.insert desde el botón
Paso 6 de 14
Solución
Ctrl+Z, por fin
Deshacer ahora es sacar el último comando del historial y llamar a su undo(). run no necesita saber qué era: el comando lo sabe.
insert " mundo" quita sus 6 caracteres y el documento vuelve a «Hola». El historial queda con 1 comando. Si guardas los comandos deshechos en otra lista, rehacer es volver a llamar a su do().
Qué cambió
- insert " mundo" del historial
- Doc vuelve a "Hola"
Paso 7 de 14
Técnica
Otro comando, el mismo invoker
Agrega un comando que borra los últimos n caracteres. Su undo necesita algo que insert no necesitaba: recordar lo que borró. Por eso lo guarda en removed antes de borrar.
run y el historial no cambian ni una línea. Ejecutas deleteLast(doc, 2): «Hola» queda en «Ho» y el historial vuelve a tener 2 comandos.
Qué cambió
- deleteLast, con removed
- run, sin cambios
Paso 8 de 14
Compromiso
Un deshacer que no sabe deshacer
Si deleteLast no guardara removed, su undo no tendría qué devolver y «Ho» se quedaría así. Cada comando necesita un inverso exacto, y cada inverso es código que puede fallar. Pruébalo con un test: do y luego undo dejan el documento igual que antes.
Hay otra forma de deshacer: antes de cada comando, guardar una foto del estado (el doc.text completo) y, al deshacer, restaurarla. No escribes inversos, pero cada foto ocupa memoria. Esa idea tiene nombre propio, Memento, y la verás en el módulo 5.
Qué cambió
- undo sin removed: no puede restaurar
- alternativa: una foto del estado
Paso 9 de 14
Técnica
Guardarlos para después
Como un comando es un dato, no tienes que ejecutarlo en el momento. Imagina que el editor guarda en un servidor y se queda sin conexión: los comandos esperan en una lista y, cuando vuelve la red, se ejecutan en el mismo orden.
Si guardas su nombre y sus datos (no las funciones), también puedes escribirlo en un log o enviarlo a otro proceso para que lo ejecute allí.
Qué cambió
- pending, una cola de comandos
Paso 10 de 14
Concepto
Ya lo usas: los comandos de VS Code
En VS Code, una extensión registra una función bajo un ID de comando con registerCommand. Los menús, los atajos de teclado y el propio código ejecutan ese comando con executeCommand y el ID.
Quien pulsa el atajo no conoce la función, solo el ID. executeCommand hace de invoker: busca la función registrada y la llama. Por eso un mismo comando puede estar en un menú y en un atajo a la vez.
Qué cambió
- run → executeCommand
- el comando → un ID y su handler
Paso 11 de 14
Concepto
Un primo en Redux: acciones como datos
En Redux, la única forma de cambiar el estado es despachar una acción: un objeto plano que describe qué pasó, como { type: "todos/added", payload: "Comprar pan" }. El reducer es quien hace el cambio.
La diferencia con el Command clásico: la acción es solo datos, sin do() ni undo(). El código que la aplica vive en el reducer, no en la acción.
Qué cambió
- run → store.dispatch
- do() → el reducer
Paso 12 de 14
Concepto
Tres ideas equivocadas
«Es el command de CQRS»: comparten nombre, no escala. En CQRS (por ejemplo, con NestJS) un command es un mensaje que un bus lleva al handler registrado para su tipo, a nivel de arquitectura. El Command de esta lección es un objeto dentro de tu código.
«Deshacer sale gratis»: cada undo hay que escribirlo y probarlo, o guardar fotos del estado.
«Siempre hace falta una clase»: con funciones como valores, un comando sin undo puede ser solo () => doc.insert("Hola"). Peter Norvig ya mostró en 1996 que muchos patrones se simplifican así. Necesitas el objeto cuando sumas undo, una etiqueta o datos que guardar.
Paso 13 de 14
Compromiso
Cuándo no usarlo y qué cuesta
Si la acción se ejecuta una vez, en el momento, y nadie necesita deshacerla, repetirla ni guardarla, llama al método directo. Un comando ahí es una capa más que leer.
Lo que pagas cuando sí lo usas: un objeto por cada acción, un undo por comando que hay que mantener correcto y un salto más al seguir el código (run → do → Doc).
Paso 14 de 14
Resumen
Acciones que se pueden guardar
Cuando una acción tiene que poder deshacerse, repetirse, esperar o registrarse, conviértela en un objeto con do() y undo(). Un invoker la ejecuta sin saber qué hace y la guarda en un historial.
El precio es un objeto por acción y un inverso correcto en cada uno (o fotos del estado, con Memento). Si nada de eso hace falta, la llamada directa es mejor.
← → paso · R repetir · Espacio pausa
Aprenderás
- Ver por qué una llamada directa no deja deshacer, repetir ni esperar. (visto)
- Convertir una acción en un objeto con `do()` y `undo()`. (visto)
- Implementar deshacer con un historial de comandos. (visto)
- Reconocer la idea en los comandos de VS Code y en las acciones de Redux. (visto)
- Saber cuándo un comando sobra y qué cuesta. (visto)