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)
—
BotonesDoc"Hola""Holamundo""Ho"stateDocrun()invokerexecuteCommandinvokerstoreinvokerrun()insertcomandodeleteLastcomandohandlercomandoreducercomandoinsertCommandinterfaceCommandbotón y atajocambia y olvidaUna llamada directahello.onclick = () =>doc.insert("Hola");shortcut("Alt+H", () =>doc.insert("Hola"));Ctrl+Z¿qué fue lo último?Lo que no puedes hacerdeshacerno sabes qué pasórepetirno tienes los datoshacerlo más tardeya se ejecutóacción + datosdo · undoEl contrato de todosinterface Command {do(): void;undo(): void;label: string;}do() añade el textodoc.text += sinsertconst insert = (doc: Doc, s: string): Command => ({label: `insert "${s}"`,▸do: () => { doc.text += s; },undo: () => { doc.text =▸doc.text.slice(0, -s.length); },});do() y lo guardacrea el comandoEl invoker y su historialconst history: Command[] = [];const run = (c: Command) => {c.do();+history.push(c);};run(insert(doc, "Hola"));run(insert(doc, " mundo"));Ctrl+Zpop() y undo()Deshacer// Ctrl+Z▸const last = history.pop();▸last?.undo();// doc.text: "Hola"// history: [insert "Hola"]sin cambiosguarda lo borradodeleteLastconst deleteLast = (doc: Doc, n: number)▸: Command => { let removed = "";return { label: `delete ${n}`,do() {▸removed = doc.text.slice(-n);doc.text = doc.text.slice(0, -n); },undo() { doc.text += removed; } }; };undo sin removed¿qué devuelvo?Dos formas de deshacerguardacómo deshacercómo eracuestaun undo por comandomemoria por fotopatrónCommandMemento (módulo 5)sin conexiónesperan su turnoUna cola de comandosconst pending: Command[] = [];const later = (c: Command) =>pending.push(c);// cuando vuelve la conexión:▸pending.splice(0).forEach(run);"ext.hello"registrado con un IDVS Code: un comando por ID// en la extensión:vscode.commands.registerCommand("ext.hello", () => { /* … */ });// desde un menú, un atajo o código:vscode.commands.executeCommand("ext.hello");{ type, payload }aplica la acciónRedux: la acción es un datostore.dispatch({type: "todos/added",payload: "Comprar pan",});// el reducer recibe la acción// y devuelve el estado nuevoun objeto en tu códigono es un bus de CQRSTres ideas equivocadas«es el command de CQRS»mismo nombre, otra escala«deshacer sale gratis»cada undo se escribe«siempre es una clase»a veces basta una funciónllamada directano hace faltaLo que pagasun objetopor cada acciónun undocorrecto en cada comandoun salto másal seguir el códigoejecuta y recuerdaacción + datosCommand en una tablaproblemala acción se pierde al hacerlasoluciónun objeto con do y undoinvokerejecuta sin saber qué hacete dahistorial, deshacer, colano lo usessi nada de eso hace falta
  • 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.

Aprenderás

  • Ver por qué una llamada directa no deja deshacer, repetir ni esperar.
  • Convertir una acción en un objeto con `do()` y `undo()`.
  • Implementar deshacer con un historial de comandos.
  • Reconocer la idea en los comandos de VS Code y en las acciones de Redux.
  • Saber cuándo un comando sobra y qué cuesta.