Ce sunt mașinile de stare și când sunt ele utile?

Question

Accepted Answer

O **mașină de stare** modelează un sistem ca un set finit de **stări** plus **tranzițiile** permise între ele. În loc să gestionezi semnale booleene independente, definești exact ce stări există și ce tranzițiile sunt legale — ceea ce face ca stările imposibile să fie nereprezentabile.

## Problema: amestec de booleeni

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

Cu semnale independente, nimic nu te oprește de la combinații contradictorii, și trebuie să le păstrezi manual în concordanță la fiecare tranzițție — o sursă de bug-uri.

## Modelul mașinii de stare

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

O singură variabilă `state` reține starea curentă; un `event` declanșează o tranzițție *definită*. Tranzițiile ilegale (de ex. SUCCESS în timp ce inactiv) pur și simplu nu pot apărea — stările imposibile sunt eliminate prin design.

## Instrumente în lumea 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" } },
  },
});
```

## Când sunt utile mașinile de stare

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

## De ce este important

Mașinile de stare aduc rigoare logicii stateful complexe prin a face **stările invalide imposibile** și tranzițiile **explicite** — înlocuind combinații fragile de booleeni cu un model clar și exhaustiv.

Sunt deosebit de valoroase pentru fluxuri complicate (ghizi, plăți, autentificare, media) unde amestecul de booleeni duce la bug-uri subtile și greu de reprodus.

Chiar și informal (o enumerare `status`) ideea îmbunătățește starea asincronă; formal (XState) oferă logică vizualizabilă, testabilă și robustă.

A ști când să le folosești este semnul unui design de stare matur.