Czym są automaty stanów i kiedy są przydatne?

Question

Accepted Answer

**Automat stanów** modeluje system jako skończony zbiór **stanów** oraz dopuszczalne **przejścia** między nimi. Zamiast żonglować niezależnymi flagami logicznymi, definiujesz dokładnie, które stany istnieją i które przejścia są legalne — dzięki czemu niemożliwe stany stają się reprezentowalne.

## Problem: gmatwanina zmiennych logicznych

```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
```

Przy niezależnych flagach nic nie hamuje sprzecznych kombinacji, a ty musisz ręcznie utrzymywać je w zgodzie przy każdym przejściu — magnes na błędy.

## Model automatu stanów

```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
}
```

Jedna zmienna `state` przechowuje aktualny stan; `event` wyzwala *zdefiniowane* przejście. Nielegalne przejścia (np. SUCCESS gdy bezczynny) po prostu nie mogą się wydarzyć — niemożliwe stany są wyeliminowane przez projektowanie.

## Narzędzia z praktyki: 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" } },
  },
});
```

## Kiedy automaty stanów pomagają

```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
```

## Dlaczego to ważne

Automaty stanów wnoszą rygor do złożonej logiki stanowej, czyniąc **nieważne stany niemożliwymi** i przejścia **jawnymi** — zastępując kruchą kombinację zmiennych logicznych jasnym, wyczerpującym modelem.

Są szczególnie cenne dla skomplikowanych przepływów (kreatury, płatności, autentykacja, media), gdzie gmatwanina zmiennych logicznych prowadzi do subtelnych, trudnych do odtworzenia błędów.

Nawet nieformalnie (enum `status`) idea poprawia stan asynchroniczny; formalnie (XState) dostarcza wizualizowaną, testowaną, niezawodną logikę.

Wiedzenie, kiedy sięgnąć po automaty stanów, jest znamieniem dojrzałego projektowania stanów.