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
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()
}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.
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.
quizPon a prueba lo que leíste
Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.
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.
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 cancelaLO IDIOMÁTICO EN C# / .NET: Cada estado es una clase. La base EstadoPedido rechaza por defecto todas las acciones con métodos virtual, y cada estado solo sobrescribe (override) lo que permite. Como los estados no tienen datos propios, se reutiliza una sola instancia de cada uno (static readonly).
var a = new Pedido("A-1");
a.Pagar();
a.Enviar();
try
{
a.Cancelar();
}
catch (InvalidOperationException error)
{
Console.WriteLine($" {error.Message}"); // No se puede cancelar un pedido enviado
}
var b = new Pedido("B-2");
b.Pagar();
b.Cancelar(); // reembolsa y cancela
public abstract class EstadoPedido(string nombre)
{
public string Nombre { get; } = nombre;
public virtual void Pagar(Pedido pedido) => throw Prohibido("pagar");
public virtual void Enviar(Pedido pedido) => throw Prohibido("enviar");
public virtual void Cancelar(Pedido pedido) => throw Prohibido("cancelar");
private InvalidOperationException Prohibido(string accion) => new($"No se puede {accion} un pedido {Nombre}");
}
public sealed class Pendiente() : EstadoPedido("pendiente")
{
public override void Pagar(Pedido pedido) => pedido.CambiarEstado(Estados.Pagado);
public override void Cancelar(Pedido pedido) => pedido.CambiarEstado(Estados.Cancelado);
}
public sealed class Pagado() : EstadoPedido("pagado")
{
public override void Enviar(Pedido pedido) => pedido.CambiarEstado(Estados.Enviado);
public override void Cancelar(Pedido pedido)
{
Console.WriteLine($" reembolso del pedido {pedido.Id}");
pedido.CambiarEstado(Estados.Cancelado);
}
}
public sealed class Enviado() : EstadoPedido("enviado");
public sealed class Cancelado() : EstadoPedido("cancelado");
public static class Estados
{
public static readonly EstadoPedido Pendiente = new Pendiente();
public static readonly EstadoPedido Pagado = new Pagado();
public static readonly EstadoPedido Enviado = new Enviado();
public static readonly EstadoPedido Cancelado = new Cancelado();
}
public class Pedido(string id)
{
private EstadoPedido _estado = Estados.Pendiente;
public string Id { get; } = id;
public void CambiarEstado(EstadoPedido nuevo)
{
Console.WriteLine($" {Id}: {_estado.Nombre} → {nuevo.Nombre}");
_estado = nuevo;
}
public void Pagar() => _estado.Pagar(this);
public void Enviar() => _estado.Enviar(this);
public void Cancelar() => _estado.Cancelar(this);
}LO IDIOMÁTICO EN JAVA: En Java, una máquina de estados se escribe muy bien con un enum cuyas constantes sobrescriben métodos: cada estado es un objeto único, el conjunto está cerrado y las transiciones quedan juntas. Por defecto, una acción no permitida lanza una excepción.
void main() {
var a = new Pedido("A-1");
a.pagar();
a.enviar();
try {
a.cancelar();
} catch (IllegalStateException error) {
IO.println(" " + error.getMessage()); // No se puede cancelar un pedido enviado
}
var b = new Pedido("B-2");
b.pagar();
b.cancelar(); // reembolsa y cancela
}
enum EstadoPedido {
PENDIENTE {
@Override EstadoPedido pagar(Pedido p) { return PAGADO; }
@Override EstadoPedido cancelar(Pedido p) { return CANCELADO; }
},
PAGADO {
@Override EstadoPedido enviar(Pedido p) { return ENVIADO; }
@Override EstadoPedido cancelar(Pedido p) {
IO.println(" reembolso del pedido " + p.id());
return CANCELADO;
}
},
ENVIADO,
CANCELADO;
// Cada método devuelve el siguiente estado; por defecto, la acción no está permitida
EstadoPedido pagar(Pedido p) { throw prohibido("pagar"); }
EstadoPedido enviar(Pedido p) { throw prohibido("enviar"); }
EstadoPedido cancelar(Pedido p) { throw prohibido("cancelar"); }
private IllegalStateException prohibido(String accion) {
return new IllegalStateException("No se puede " + accion + " un pedido " + name().toLowerCase());
}
}
final class Pedido {
private final String id;
private EstadoPedido estado = EstadoPedido.PENDIENTE;
Pedido(String id) {
this.id = id;
}
String id() { return id; }
void pagar() { cambiar(estado.pagar(this)); }
void enviar() { cambiar(estado.enviar(this)); }
void cancelar() { cambiar(estado.cancelar(this)); }
private void cambiar(EstadoPedido nuevo) {
IO.println(" %s: %s → %s".formatted(id, estado.name().toLowerCase(), nuevo.name().toLowerCase()));
estado = nuevo;
}
}LO IDIOMÁTICO EN JAVASCRIPT: Cada estado es un objeto literal congelado con solo las acciones que permite. Si una acción no existe en el estado actual, se rechaza con un mensaje claro. Toda la máquina de estados queda visible de un vistazo en una tabla.
const ESTADOS = Object.freeze({
pendiente: {
pagar: (pedido) => pedido.cambiarEstado('pagado'),
cancelar: (pedido) => pedido.cambiarEstado('cancelado'),
},
pagado: {
enviar: (pedido) => pedido.cambiarEstado('enviado'),
cancelar: (pedido) => {
console.log(` reembolso del pedido ${pedido.id}`);
pedido.cambiarEstado('cancelado');
},
},
enviado: {},
cancelado: {},
});
export class Pedido {
#estado = 'pendiente';
constructor(id) { this.id = id; }
cambiarEstado(nuevo) {
console.log(` ${this.id}: ${this.#estado} → ${nuevo}`);
this.#estado = nuevo;
}
pagar() { this.#ejecutar('pagar'); }
enviar() { this.#ejecutar('enviar'); }
cancelar() { this.#ejecutar('cancelar'); }
#ejecutar(accion) {
const manejador = ESTADOS[this.#estado][accion];
if (!manejador) throw new Error(`No se puede ${accion} un pedido ${this.#estado}`);
manejador(this);
}
}
// ── Uso ──
const a = new Pedido('A-1');
a.pagar();
a.enviar();
try {
a.cancelar();
} catch (error) {
console.log(` ${error.message}`); // No se puede cancelar un pedido enviado
}
const b = new Pedido('B-2');
b.pagar();
b.cancelar(); // reembolsa y cancelaLO IDIOMÁTICO EN PYTHON: Cada estado es una clase. La clase base rechaza por defecto todas las acciones y cada estado sobrescribe solo las que permite. ClassVar marca el nombre como dato de la clase, no de cada objeto, y como los estados no guardan datos, se puede reutilizar una sola instancia de cada uno.
from typing import ClassVar
class EstadoPedido:
nombre: ClassVar[str]
def pagar(self, pedido: "Pedido") -> None:
self._prohibido("pagar")
def enviar(self, pedido: "Pedido") -> None:
self._prohibido("enviar")
def cancelar(self, pedido: "Pedido") -> None:
self._prohibido("cancelar")
def _prohibido(self, accion: str) -> None:
raise RuntimeError(f"No se puede {accion} un pedido {self.nombre}")
class Pendiente(EstadoPedido):
nombre = "pendiente"
def pagar(self, pedido: "Pedido") -> None:
pedido.cambiar_estado(PAGADO)
def cancelar(self, pedido: "Pedido") -> None:
pedido.cambiar_estado(CANCELADO)
class Pagado(EstadoPedido):
nombre = "pagado"
def enviar(self, pedido: "Pedido") -> None:
pedido.cambiar_estado(ENVIADO)
def cancelar(self, pedido: "Pedido") -> None:
print(f" reembolso del pedido {pedido.id}")
pedido.cambiar_estado(CANCELADO)
class Enviado(EstadoPedido):
nombre = "enviado"
class Cancelado(EstadoPedido):
nombre = "cancelado"
# Los estados no tienen datos propios: una instancia de cada uno basta
PENDIENTE, PAGADO, ENVIADO, CANCELADO = Pendiente(), Pagado(), Enviado(), Cancelado()
class Pedido:
def __init__(self, id: str) -> None:
self.id = id
self._estado: EstadoPedido = PENDIENTE
def cambiar_estado(self, nuevo: EstadoPedido) -> None:
print(f" {self.id}: {self._estado.nombre} → {nuevo.nombre}")
self._estado = nuevo
def pagar(self) -> None:
self._estado.pagar(self)
def enviar(self) -> None:
self._estado.enviar(self)
def cancelar(self) -> None:
self._estado.cancelar(self)
if __name__ == "__main__":
a = Pedido("A-1")
a.pagar()
a.enviar()
try:
a.cancelar()
except RuntimeError as error:
print(f" {error}") # No se puede cancelar un pedido enviado
b = Pedido("B-2")
b.pagar()
b.cancelar() # reembolsa y cancelaLO IDIOMÁTICO EN GO: Cada estado es un struct que cumple la interfaz Estado. Go no tiene herencia, pero sí incrustación (embedding): rechazaTodo aporta la respuesta por defecto (un error) y cada estado lo incrusta y solo define las acciones que permite.
package main
import "fmt"
type Estado interface {
Nombre() string
Pagar(*Pedido) error
Enviar(*Pedido) error
Cancelar(*Pedido) error
}
type rechazaTodo struct{ nombre string }
func (r rechazaTodo) Nombre() string { return r.nombre }
func (r rechazaTodo) Pagar(*Pedido) error { return r.prohibido("pagar") }
func (r rechazaTodo) Enviar(*Pedido) error { return r.prohibido("enviar") }
func (r rechazaTodo) Cancelar(*Pedido) error { return r.prohibido("cancelar") }
func (r rechazaTodo) prohibido(accion string) error {
return fmt.Errorf("no se puede %s un pedido %s", accion, r.nombre)
}
type pendiente struct{ rechazaTodo }
func (pendiente) Pagar(p *Pedido) error { p.cambiar(Pagado); return nil }
func (pendiente) Cancelar(p *Pedido) error { p.cambiar(Cancelado); return nil }
type pagado struct{ rechazaTodo }
func (pagado) Enviar(p *Pedido) error { p.cambiar(Enviado); return nil }
func (pagado) Cancelar(p *Pedido) error {
fmt.Println(" reembolso del pedido", p.ID)
p.cambiar(Cancelado)
return nil
}
// Los estados no guardan datos: basta una instancia de cada uno
var (
Pendiente Estado = pendiente{rechazaTodo{"pendiente"}}
Pagado Estado = pagado{rechazaTodo{"pagado"}}
Enviado Estado = rechazaTodo{"enviado"}
Cancelado Estado = rechazaTodo{"cancelado"}
)
type Pedido struct {
ID string
estado Estado
}
func NuevoPedido(id string) *Pedido { return &Pedido{ID: id, estado: Pendiente} }
func (p *Pedido) cambiar(nuevo Estado) {
fmt.Printf(" %s: %s → %s\n", p.ID, p.estado.Nombre(), nuevo.Nombre())
p.estado = nuevo
}
func (p *Pedido) Pagar() error { return p.estado.Pagar(p) }
func (p *Pedido) Enviar() error { return p.estado.Enviar(p) }
func (p *Pedido) Cancelar() error { return p.estado.Cancelar(p) }
func main() {
a := NuevoPedido("A-1")
for _, accion := range []func() error{a.Pagar, a.Enviar, a.Cancelar} {
if err := accion(); err != nil {
fmt.Println(" error:", err) // error: no se puede cancelar un pedido enviado
}
}
b := NuevoPedido("B-2")
for _, accion := range []func() error{b.Pagar, b.Cancelar} {
if err := accion(); err != nil {
fmt.Println(" error:", err)
}
}
}LO IDIOMÁTICO EN RUST: Rust permite llevar el patrón al sistema de tipos ("typestate"): el estado es un parámetro de tipo, Pedido<Pagado>, y cada estado solo tiene los métodos que permite. Las transiciones consumen el pedido (self) y devuelven uno en el nuevo estado, así que cancelar un pedido enviado no compila.
use std::marker::PhantomData;
struct Pendiente;
struct Pagado;
struct Enviado;
struct Cancelado;
struct Pedido<Estado> {
id: String,
estado: PhantomData<Estado>, // no ocupa memoria: solo existe para el compilador
}
impl<Estado> Pedido<Estado> {
fn pasar_a<Nuevo>(self, nombre: &str) -> Pedido<Nuevo> {
println!(" {} → {nombre}", self.id);
Pedido {
id: self.id,
estado: PhantomData,
}
}
}
impl Pedido<Pendiente> {
fn nuevo(id: &str) -> Self {
Pedido {
id: id.to_string(),
estado: PhantomData,
}
}
fn pagar(self) -> Pedido<Pagado> {
self.pasar_a("pagado")
}
fn cancelar(self) -> Pedido<Cancelado> {
self.pasar_a("cancelado")
}
}
impl Pedido<Pagado> {
fn enviar(self) -> Pedido<Enviado> {
self.pasar_a("enviado")
}
fn cancelar(self) -> Pedido<Cancelado> {
println!(" reembolso del pedido {}", self.id);
self.pasar_a("cancelado")
}
}
impl Pedido<Enviado> {
fn entregar(self) -> Pedido<Enviado> {
println!(" {} entregado al cliente", self.id);
self
}
}
fn main() {
let a = Pedido::nuevo("A-1").pagar().enviar().entregar();
// a.cancelar(); ← no compila: `Pedido<Enviado>` no tiene el método `cancelar`
let _ = a;
let _b = Pedido::nuevo("B-2").pagar().cancelar(); // reembolsa y cancela
let _c = Pedido::nuevo("C-3").cancelar(); // pendiente: se cancela sin reembolso
}LO IDIOMÁTICO EN PHP: Los enums de PHP pueden tener métodos, así que cada caso del enum es un estado y las transiciones se escriben con match ($this). Si una acción no está permitida, el default lanza una excepción. Toda la máquina de estados queda en un solo lugar.
<?php
declare(strict_types=1);
enum EstadoPedido: string
{
case Pendiente = 'pendiente';
case Pagado = 'pagado';
case Enviado = 'enviado';
case Cancelado = 'cancelado';
public function pagar(): self
{
return match ($this) {
self::Pendiente => self::Pagado,
default => throw $this->prohibido('pagar'),
};
}
public function enviar(): self
{
return match ($this) {
self::Pagado => self::Enviado,
default => throw $this->prohibido('enviar'),
};
}
public function cancelar(Pedido $pedido): self
{
return match ($this) {
self::Pendiente => self::Cancelado,
self::Pagado => $pedido->reembolsar(self::Cancelado),
default => throw $this->prohibido('cancelar'),
};
}
private function prohibido(string $accion): LogicException
{
return new LogicException("No se puede {$accion} un pedido {$this->value}");
}
}
final class Pedido
{
private EstadoPedido $estado = EstadoPedido::Pendiente;
public function __construct(public readonly string $id) {}
public function pagar(): void { $this->cambiar($this->estado->pagar()); }
public function enviar(): void { $this->cambiar($this->estado->enviar()); }
public function cancelar(): void { $this->cambiar($this->estado->cancelar($this)); }
public function reembolsar(EstadoPedido $siguiente): EstadoPedido
{
echo " reembolso del pedido {$this->id}\n";
return $siguiente;
}
private function cambiar(EstadoPedido $nuevo): void
{
echo " {$this->id}: {$this->estado->value} → {$nuevo->value}\n";
$this->estado = $nuevo;
}
}
$a = new Pedido('A-1');
$a->pagar();
$a->enviar();
try {
$a->cancelar();
} catch (LogicException $error) {
echo " {$error->getMessage()}\n"; // No se puede cancelar un pedido enviado
}
$b = new Pedido('B-2');
$b->pagar();
$b->cancelar(); // reembolsa y cancela