स्टेट मशीनें क्या हैं और वे कब मदद करती हैं?

Question

Accepted Answer

एक **state machine** एक सिस्टम को **states** के सीमित सेट के साथ मॉडल करता है साथ ही उनके बीच अनुमत **transitions**। स्वतंत्र boolean flags के साथ जूझने की जगह, आप बिल्कुल परिभाषित करते हैं कि कौन सी states मौजूद हैं और कौन से transitions वैध हैं — असंभव states को असंभव बनाता है।

## The problem: boolean soup

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

स्वतंत्र flags के साथ, कुछ भी विरोधाभासी संयोजनों को रोकता नहीं है, और आपको हर transition पर उन्हें manually सुसंगत रखना होगा — एक बग magnet।

## The state-machine model

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

एक single `state` variable वर्तमान state को धारण करता है; एक `event` एक *defined* transition को trigger करता है। अवैध transitions (जैसे idle होते समय SUCCESS) बस नहीं हो सकते — असंभव states डिज़ाइन द्वारा चले गए हैं।

## Real-world tooling: 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" } },
  },
});
```

## When state machines help

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

## यह क्यों महत्वपूर्ण है

State machines जटिल stateful logic में कठोरता लाते हैं **अमान्य states को असंभव** बनाते हुए और transitions को **स्पष्ट** करते हुए — booleans के नाजुक संयोजनों को एक स्पष्ट, व्यापक मॉडल से बदलते हुए।

वे विशेष रूप से जटिल flows (wizards, payments, auth, media) के लिए मूल्यवान हैं जहां boolean soup सूक्ष्म, कठिन-से-पुनरुत्पादन bugs की ओर ले जाता है।

यहां तक कि informally (एक `status` enum) भी यह विचार async state में सुधार करता है; formally (XState) यह visualizable, testable, robust logic प्रदान करता है।

जानना कि उन्हें कब reach करना है यह mature state design का एक निशान है।