State: comportamiento según el estado

  • Lección 21 de 32
  • 10 min
  • Intermedio
  • 13 pasos

Un pedido que puede quedar enviado y cancelado a la vez porque lo guardan tres booleanos. Vas a convertirlo en una máquina de estados y ver cuándo vale la pena hacerlo.

Combinaciones posibles
4
Combinaciones sin sentido
0
Estado del pedido
—
checkoutOrderOrder ·shippedOrder ·isGiftOrderdraftdraftpaidpaidshippedshippedcancelledcancelledOrderOrderOrderStateinterfazOrderStateDraftDraftPaidPaidShippedShipped3 booleanosOrder con booleanoslet isPaid = false;let isShipped = false;let isCancelled = false;function ship() {▸if (isPaid && !isCancelled)isShipped = true;}cancel()enviado y canceladoLo que nadie revisófunction cancel() {▸isCancelled = true;}ship(); // isShipped = truecancel(); // isCancelled = true// enviado y cancelado a la vezuno activo a la vezUn campo, cuatro valores+type Status =+| "draft"+| "paid"+| "shipped"+| "cancelled";+let status: Status = "draft";payshipcancelcancelfinalfinalTabla de transicionesconst transitions = {draft: {pay: "paid", cancel: "cancelled" },paid: {ship: "shipped", cancel: "cancelled" },▸shipped: {},▸cancelled: {},};payestado: paidnext() (extracto)function next(s: Status, e: Ev) {const to = transitions[s][e];if (!to)throw new Error(`cannot ${e} when ${s}`);return to;}let order: Status = "draft";▸order = next(order, "pay"); // "paid"cancel()cannot cancel when shippedUn evento inválidoorder = next(order, "ship");// order === "shipped"▸next(order, "cancel");// Error: cannot cancel when shippedun solo estado activoMáquina de estados finitaestadosun número finitoactivosuno a la vezeventosdisparan transicionesestado + eventosiempre el mismo destinosegún la documentación de StatelydelegaimplementaInterfaz y contextointerface OrderState {pay(o: Order): void;ship(o: Order): void;}class Order {state: OrderState = new Draft();▸ship() { this.state.ship(this); }}state.ship(this)ship() → ShippedUn estado concretoclass Paid implements OrderState {pay() {throw new Error("already paid");}ship(o: Order) {▸o.state = new Shipped();}}¿tabla o clases?Tabla o clasesformatablaclasestamaño1 objeto1 clase por estadológica por estadopocamuchaleer el flujode un vistazorepartidoun boolean bastaCuándo no usarlo2 estados sin reglasun boolean bastareglas que cambian seguidomotor de workflows«State es una librería»es un patróninicioState en una tablaproblemabooleanos que se cruzansoluciónestados + transicionesevento inválidoerror claropoca lógicauna tablamucha lógicauna clase por estadono lo usescon 2 estados sin reglas
  • petición
  • respuesta
  • evento
  • petición fallida

Paso 1 de 13

Problema

Un pedido guardado con tres booleanos

Una tienda guarda cada pedido con tres campos: isPaid, isShipped e isCancelled. Para enviar, ship() revisa que esté pagado y no cancelado.

Tres booleanos dan 2 × 2 × 2 = 8 combinaciones. Solo 5 describen un pedido real; las otras 3 (enviado sin pagar, o enviado y cancelado) no deberían existir, pero nada en el código las impide.

Paso 2 de 13

Problema

Cancelar un pedido que ya salió

Alguien escribe cancel() y solo pone isCancelled = true. Se olvidó de revisar isShipped.

Ahora un pedido que ya salió del almacén puede quedar enviado y cancelado a la vez. No hay ningún error: el estado imposible se guarda en silencio y aparece semanas después en un reporte.

Paso 3 de 13

Concepto

Un solo campo con estados con nombre

Cambia la pregunta: en vez de tres sí/no, ¿en qué estado está el pedido? Aquí hay cuatro: draft, paid, shipped y cancelled.

Un solo campo status guarda uno de esos valores, y solo uno a la vez. «Enviado y cancelado» ya no se puede escribir: las combinaciones bajan de 8 a 4 y las imposibles, de 3 a 0.

Qué cambió

  • type Status
  • isPaid, isShipped, isCancelled

Paso 4 de 13

Concepto

Qué eventos mueven el pedido

Un estado no basta: también importa cómo se llega. Las flechas son transiciones y cada una tiene un evento: pay lleva de draft a paid, ship de paid a shipped, y cancel funciona desde draft o desde paid.

Esto es una máquina de estados. Ojo: un enum solo no lo es. Lo es cuando algo impide las transiciones que no están en el diagrama.

Paso 5 de 13

Técnica

Las transiciones, escritas como datos

La forma más directa en TypeScript: un objeto donde cada estado lista los eventos que acepta y a dónde lleva cada uno.

shipped y cancelled tienen {}: son estados finales y no aceptan ningún evento. Lo que no está en la tabla, no se puede hacer.

Paso 6 de 13

Técnica

`next()` aplica un evento

next(estado, evento) busca en la tabla (Ev es "pay" | "ship" | "cancel"). Si encuentra destino, lo devuelve; si no, lanza un error con un mensaje claro.

El pedido empieza en draft. Con next(order, "pay") pasa a paid. Nadie cambia el estado a mano: todo cambio pasa por la tabla.

Qué cambió

  • function next()

Paso 7 de 13

Solución

Un evento que no vale se rechaza en voz alta

El pedido ya está en shipped y llega un cancel. La tabla no tiene cancel para shipped, así que next lanza cannot cancel when shipped.

Es el mismo bug del paso 2, pero ahora falla en el momento y con un mensaje que dice qué pasó, en vez de guardar un pedido imposible.

Paso 8 de 13

Técnica

Así lo define una librería de máquinas de estados

La documentación de Stately (el equipo de XState) describe una máquina de estados finita así: un número finito de estados, solo uno activo a la vez, eventos que disparan transiciones, y cada par estado-evento lleva siempre al mismo destino.

Tu tabla cumple las cuatro reglas sin instalar nada. State es un patrón, no una librería: XState añade herramientas encima, pero la idea es esta.

Paso 9 de 13

Solución

La forma del libro: una clase por estado

El patrón State del libro de GoF lo resuelve con objetos: una interfaz OrderState con un método por evento (cancel va igual) y una clase por estado que la implementa: Draft, Paid, Shipped (y Cancelled, que no dibujamos).

Order guarda su estado actual en un campo y le delega cada llamada: ship() hace this.state.ship(this). Order no tiene ningún if sobre su estado.

Qué cambió

  • interface OrderState

Paso 10 de 13

Técnica

Cada estado sabe qué hacer y a dónde ir

Con el pedido pagado, state es un Paid. Su ship() cambia o.state a un Shipped; su pay() lanza un error, porque ya está pagado.

Las reglas de cada estado viven juntas en su clase. Si Paid tiene mucha lógica propia (reembolsos, avisos, plazos), esta forma la ordena mejor que una tabla.

Paso 11 de 13

Compromiso

Tabla o clases: depende de cuánto hace cada estado

La tabla es corta y se lee de un vistazo: ideal cuando un estado solo decide a dónde ir. Las clases pesan más (un tipo por estado), pero ganan cuando cada estado tiene su propio comportamiento.

Las dos te dan lo que importa: estados imposibles que ya no se pueden escribir y un diagrama que puedes revisar. El precio, en ambos casos, es modelar antes y tener más tipos.

Paso 12 de 13

Compromiso

Cuándo una máquina de estados sobra

Si hay 2 estados sin reglas entre ellos, un boolean basta: isGift puede pasar de true a false cuando quieras y no hay transiciones que vigilar.

Y si las transiciones las define el negocio y cambian seguido (aprobaciones configurables, pasos que se agregan), son datos de un flujo de trabajo: una tabla en la base de datos o un motor de workflows encaja mejor que clases en el código.

Paso 13 de 13

Resumen

Estados con nombre y transiciones explícitas

Cuando el comportamiento depende de un estado y los booleanos se cruzan, nombra los estados y escribe qué eventos llevan de uno a otro. Lo que no está permitido falla con un error claro.

Usa una tabla si cada estado solo decide a dónde ir, y una clase por estado si cada uno tiene mucha lógica. Con dos estados sin reglas, sigue con un boolean.

Aprenderás

  • Reconocer el problema: varios booleanos que permiten combinaciones imposibles.
  • Modelar un proceso como estados con nombre y transiciones con eventos.
  • Escribir una tabla de transiciones que rechaza los eventos inválidos.
  • Aplicar la forma del libro: una clase por estado y un contexto que delega.
  • Elegir entre tabla y clases, y saber cuándo un boolean basta.