Arquetipo
Patrones de comportamientoUso: AltaComplejidad: Media

State

Estado · Máquina de estados

Permite que un objeto cambie su comportamiento cuando cambia su estado interno, como si cambiara de clase.

“El objeto se comporta distinto según su estado y todo es un if gigante.”

workEl caso real

Un pedido pasa por Pendiente de pago, Pagado, Enviado, Entregado y Cancelado. Las mismas acciones se comportan distinto según el estado: cancelar un pedido pendiente solo lo anula; cancelar uno pagado lo anula y devuelve el dinero; uno enviado ya no se puede cancelar.

warningEl problema sin el patrón

Cada método del pedido (pagar, enviar, cancelar, entregar) es un switch sobre this.estado. Añadir el estado "En reparto" obliga a revisar todos los switch, y basta olvidar uno para permitir una transición inválida.

check_circleCómo lo resuelve el patrón

Cada estado es una clase que implementa la misma interfaz con las acciones del pedido. El pedido delega en su estado actual, y es el estado quien decide qué hacer y a qué estado pasar.

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
cancelar() {
  if (this.estado === 'pendiente') { this.estado = 'cancelado'; }
  else if (this.estado === 'pagado') { reembolsar(this); this.estado = 'cancelado'; }
  else if (this.estado === 'enviado') { throw new Error('No se puede cancelar'); }
  // ...y el mismo switch en pagar(), enviar() y entregar()
}
check_circleCon el patrónDESPUÉS
interface EstadoPedido {
  pagar(p: Pedido): void;
  cancelar(p: Pedido): void;
}

class Pendiente implements EstadoPedido {
  pagar(p: Pedido) { p.cambiarEstado(new Pagado()); }
  cancelar(p: Pedido) { p.cambiarEstado(new Cancelado()); }
}

class Pagado implements EstadoPedido {
  pagar() { throw new Error('El pedido ya está pagado'); }
  cancelar(p: Pedido) { reembolsar(p); p.cambiarEstado(new Cancelado()); }
}

class Enviado implements EstadoPedido {
  pagar() { throw new Error('El pedido ya está pagado'); }
  cancelar() { throw new Error('Un pedido enviado no se puede cancelar'); }
}

class Pedido {
  private estado: EstadoPedido = new Pendiente();
  cambiarEstado(e: EstadoPedido) { this.estado = e; }
  pagar() { this.estado.pagar(this); }
  cancelar() { this.estado.cancelar(this); }
}

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

lightbulb

Matiz importante

En lenguajes con uniones discriminadas o enums con datos (Rust, Kotlin, TypeScript) también es habitual modelar la máquina de estados con un tipo por estado y un switch o match exhaustivo: el compilador avisa si olvidas un estado.

thumb_upCuándo usarlo

  • ✓Un objeto cambia de comportamiento según su estado y tiene muchos estados o transiciones.
  • ✓Los condicionales sobre el estado se repiten en muchos métodos.

do_not_disturb_onCuándo no usarlo

  • ✕Hay dos o tres estados con poca lógica: un enum y un switch son más claros.
  • ✕Las transiciones son pocas y casi nunca cambian.

memoryPrincipios en juego

  • •Responsabilidad única: el comportamiento de cada estado vive en su clase.
  • •Abierto/Cerrado: un estado nuevo es una clase nueva, sin revisar todos los switch.

hubPatrones relacionados

  • •Strategy: estructura casi idéntica; en State los estados se conocen y provocan transiciones, mientras que las estrategias son independientes y las elige el cliente.
  • •Flyweight y Singleton: si los estados no guardan datos propios, pueden compartirse como instancias únicas.
compare_arrowsSe suele confundir conState 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_blocksState en tu lenguaje

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

LO IDIOMÁTICO EN TYPESCRIPT: Cada estado es una clase. Una clase base abstracta rechaza por defecto todas las acciones (el método privado devuelve never porque siempre lanza un error), y cada estado solo sobrescribe lo que permite. El nombre del estado es un tipo literal.

state.ts · 70 líneas
type NombreEstado = 'pendiente' | 'pagado' | 'enviado' | 'cancelado';

export interface EstadoPedido {
  readonly nombre: NombreEstado;
  pagar(pedido: Pedido): void;
  enviar(pedido: Pedido): void;
  cancelar(pedido: Pedido): void;
}

abstract class EstadoBase implements EstadoPedido {
  abstract readonly nombre: NombreEstado;
  pagar(_pedido: Pedido): void { this.#prohibido('pagar'); }
  enviar(_pedido: Pedido): void { this.#prohibido('enviar'); }
  cancelar(_pedido: Pedido): void { this.#prohibido('cancelar'); }

  #prohibido(accion: string): never {
    throw new Error(`No se puede ${accion} un pedido ${this.nombre}`);
  }
}

class Pendiente extends EstadoBase {
  readonly nombre = 'pendiente';
  pagar(pedido: Pedido) { pedido.cambiarEstado(new Pagado()); }
  cancelar(pedido: Pedido) { pedido.cambiarEstado(new Cancelado()); }
}

class Pagado extends EstadoBase {
  readonly nombre = 'pagado';
  enviar(pedido: Pedido) { pedido.cambiarEstado(new Enviado()); }
  cancelar(pedido: Pedido) {
    console.log(`  reembolso del pedido ${pedido.id}`);
    pedido.cambiarEstado(new Cancelado());
  }
}

class Enviado extends EstadoBase {
  readonly nombre = 'enviado';
}

class Cancelado extends EstadoBase {
  readonly nombre = 'cancelado';
}

export class Pedido {
  #estado: EstadoPedido = new Pendiente();
  constructor(readonly id: string) {}

  cambiarEstado(nuevo: EstadoPedido): void {
    console.log(`  ${this.id}: ${this.#estado.nombre} → ${nuevo.nombre}`);
    this.#estado = nuevo;
  }

  pagar() { this.#estado.pagar(this); }
  enviar() { this.#estado.enviar(this); }
  cancelar() { this.#estado.cancelar(this); }
}

// ── Uso ──
const a = new Pedido('A-1');
a.pagar();
a.enviar();
try {
  a.cancelar();
} catch (error) {
  console.log(`  ${(error as Error).message}`); // No se puede cancelar un pedido enviado
}

const b = new Pedido('B-2');
b.pagar();
b.cancelar(); // reembolsa y cancela
Ver los 23 patrones en TypeScript →