Actions మరియు reducers ఏమిటి, మరియు reducers ఎందుకు pure ఉండాలి?

Question

Accepted Answer

**Action** అనేది *ఏమి జరిగిందో* వివరించే సాధారణ object; **reducer** అనేది ప్రస్తుత state మరియు action ను తీసుకుని *తదుపరి* state ను రిటర్న్ చేసే pure function. కలిసి అవి సూచించదగిన state transitions లను అమలు చేస్తాయి.

## Actions — events లను వివరిస్తాయి

```js
// just data: a `type` (required) + any payload
{ type: "todos/added", payload: { id: 1, text: "Learn Redux" } }
{ type: "todos/toggled", payload: 1 }
```

Actions ఏమీ *చేయవు* — అవి events ల declarative వివరణలు. వాటిని past-tense లో పేరు పెట్టడం ("added", "toggled") ఏమి జరిగిందో రికార్డ్ చేస్తాయని ప్రతిబింబిస్తుంది.

## Reducers — తదుపరి state ను గణించుకుంటాయి

```js
function todosReducer(state = [], action) {
  switch (action.type) {
    case "todos/added":
      return [...state, action.payload];              // new array
    case "todos/toggled":
      return state.map(t =>                             // new array, new object for the changed one
        t.id === action.payload ? { ...t, done: !t.done } : t
      );
    default:
      return state;                                     // unknown action → unchanged
  }
}
```

Reducer ની signature `(state, action) => newState`. ఇది **కొత్త** state object/array ను రిటర్న్ చేయాలి (immutably), ఎప్పుడూ input ని mutate చేయకూడదు.

## Reducers PURE ఉండాలి ఎందువల్ల

Pure function: (1) ఒకే input కి ఒకే output ను రిటర్న్ చేస్తుంది, మరియు (2) **side effects** లేనిది. Reducers రెండు నియమాలను కూడా పాటించాలి:

```js
// ❌ NOT pure — breaks everything
function badReducer(state, action) {
  state.value++;              // ❌ mutates input (breaks change detection, time-travel)
  fetch("/api/log");          // ❌ side effect (non-deterministic, untestable)
  return { value: Math.random() }; // ❌ non-deterministic output
}
```

Purity Redux ల signature features లను సాధ్యం చేస్తుంది:

```text
✓ Predictability   — same state + action ALWAYS gives the same result
✓ Time-travel / replay — you can re-run actions to reproduce any state
✓ Testability      — just call reducer(state, action) and assert; no mocks needed
✓ Change detection — returning new references lets the UI detect changes
```

Side effects (API calls, logging, randomness) **middleware** (thunks/sagas) లో లేదా effects లో ఉండాలి — ఎప్పుడూ reducers లో కాదు.

## ఎందుకు ఇది ముఖ్యమైనది

Action/reducer model Redux-style state management ల గుండె మరియు ఇది debuggable మరియు testable ఎందువల్ల.

Purity requirement ఏకపక్ష కాదు: ఇది *time-travel debugging, action replay, మరియు trivial unit testing ను సాధ్యం చేసేది*, మరియు side effects ఎక్కడైనా ఉండాల్సిన కారణం.

ఈ pure-function-driven, immutable update pattern Redux, NgRx, useReducer, మరియు అందుకు ఆ‌ర్ద్ధం జరుగుతుంది — దీనిని అర్థం చేసుకోవడం (మరియు reducers ను pure గా ఉంచే శిక్ష) predictable state కు ఆధారమైనది.