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 descriptions. அவற்றை 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), உள்ளீட்டை எப்போதும் mutate செய்யக்கூடாது.

## Reducers PURE ஆக இருக்க வேண்டியது ஏன்

Pure function: (1) ஒரே உள்ளீட்டிற்கு ஒரே வெளியீட்டை திருப்பி கொடுக்கிறது, மற்றும் (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 ஆக வைக்கும் disiplin) predictable state க்கு அடிப்படையாக உள்ளது.