O que são máquinas de estado e quando elas ajudam?

Question

Accepted Answer

Uma **máquina de estado** modela um sistema como um conjunto finito de **estados** mais as **transições** permitidas entre eles. Em vez de gerenciar flags booleanas independentes, você define exatamente quais estados existem e quais transições são legais — tornando estados impossíveis não representáveis.

## O problema: caos de booleanos

```js
// ❌ multiple booleans → 2^n combinations, many of them invalid
const [isLoading, setLoading] = useState(false);
const [isError, setError] = useState(false);
const [isSuccess, setSuccess] = useState(false);
// { isLoading: true, isError: true, isSuccess: true } — nonsense, but POSSIBLE
```

Com flags independentes, nada impede combinações contraditórias, e você deve mantê-las manualmente consistentes em cada transição — uma armadilha para bugs.

## O modelo de máquina de estado

```text
States:      idle → loading → success
                       ↓
                     error → (retry) → loading

Only defined transitions are allowed; you can't be in two states at once.
```

```js
const machine = {
  idle:    { FETCH: "loading" },
  loading: { SUCCESS: "success", ERROR: "error" },
  success: { FETCH: "loading" },
  error:   { RETRY: "loading" },
};
function transition(current, event) {
  return machine[current][event] ?? current; // only legal transitions happen
}
```

Uma única variável `state` mantém o estado atual; um `event` dispara uma transição *definida*. Transições ilegais (ex. SUCCESS enquanto inativo) simplesmente não podem ocorrer — os estados impossíveis se foram por design.

## Ferramentas do mundo real: XState

```js
// libraries like XState formalize this with guards, actions, nested/parallel states
const toggleMachine = createMachine({
  initial: "inactive",
  states: {
    inactive: { on: { TOGGLE: "active" } },
    active:   { on: { TOGGLE: "inactive" } },
  },
});
```

## Quando máquinas de estado ajudam

```text
✓ Complex flows with many states: checkout, multi-step forms/wizards, media players
✓ Authentication flows (logged out → logging in → logged in → refreshing)
✓ Anything where invalid state combinations cause bugs
✗ Overkill for simple toggles or trivial state
```

## Por que isso importa

Máquinas de estado trazem rigor à lógica stateful complexa ao tornar **estados inválidos impossíveis** e transições **explícitas** — substituindo combinações frágeis de booleanos com um modelo claro e exaustivo.

São especialmente valiosas para fluxos intrincados (assistentes, pagamentos, autenticação, mídia) onde caos de booleanos leva a bugs sutis e difíceis de reproduzir.

Mesmo informalmente (um enum `status`) a ideia melhora o estado assíncrono; formalmente (XState) fornece lógica visualizável, testável e robusta.

Saber quando usá-las é um sinal de design de estado maduro.