ક્રિયાઓ અને રીડયુસર્સ શું છે, અને રીડયુસર્સ શુદ્ધ કેમ હોવા જોઈએ?

Question

Accepted Answer

એક **ક્રિયા** એ એક સાદો વસ્તુ છે જે *શું થયું તે* વર્ણવે છે; એક **રીડયુસર** એ એક શુદ્ધ કાર્ય છે જે વર્તમાન સ્થિતি અને એક ક્રિયા લે છે અને *આગળની* સ્થિતિ આપે છે. એક સાથે તેઓ પ્રેક્ષણીય સ્થિતિ સંક્રમણો લાગુ કરે છે.

## ક્રિયાઓ — ઘટનાઓનું વર્ણન કરો

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

ક્રિયાઓ કંઈ *કરતી* નથી — તેઓ ઘટનાઓના ઘોષણાત્મક વર્ણનો છે. તેમને ભૂતકાલીન તણાવમાં નામ આપવું ("ઉમેરવામાં આવ્યું", "ટોગલ કર્યું") પ્રતિબિંબિત કરે છે કે તેઓ શું થયું તે રેકોર્ડ કરે છે.

## રીડયુસર્સ — આગળની સ્થિતિની ગણતરી કરો

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

રીડયુસરનો સહી `(state, action) => newState` છે. તે એક **નવું** સ્થિતિ ઑબ્જેક્ટ/અરે આપવો જોઈએ (અપરિવર્તનશીલતા સાથે), ક્યારેય ઇનપુટને પરિવર્તિત ન કરો.

## આચાર કેમ શુદ્ધ હોવું જોઈએ

શુદ્ધ કાર્ય: (1) સમાન ઇનપુટ માટે સમાન આউટપુટ આપે છે, અને (2) **કોઈ આગળ બાજુ અસર** નથી. રીડયુસર્સ બંને નિયમો અનુસરવા જોઈએ:

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

શુદ્ધતા Redux ના હસ્તાક્ષર સુવિધાઓને સક્ષમ બનાવે છે:

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

પાર્શ્વ અસરો (API કોલ, લોગિંગ, રેન્ડમનેસ) **મિડલવેર** (થંક્સ/સાગાસ) અથવા ઇફેક્ટ્સમાં રહે છે — ક્યારેય રીડયુસર્સમાં નહીં.

## તે શા માટે અગત્યનું છે

ક્રિયા/રીડયુસર મોડેલ Redux-સ્ટાઇલ સ્થિતિ વ્યવસ્થાપનનું હૃદય છે અને તે કારણ છે કે તે કેટલું ડીબગ કરી શકાય છે અને પરીક્ષણ કરી શકાય છે.

શુદ્ધતાની આવશ્યકતા મનસ્વી નથી: તે *જે બનાવે છે* તે સમય-ભ્રમણ ડીબગીંગ, ક્રિયા પુનરાવર્તન, અને તુચ્છ એકમ પરીક્ષણ શક્ય છે, અને તે કારણ છે કે આગળ બાજુ અસરો અન્યત્ર રહવી જોઈએ.

યુક્તિ કાર્ય-દ્વારા-સંચાલિત અપરિવર્તનશીલ અપડેટ પેટર્ન Redux, NgRx, useReducer, અને તેથી આગળ દોહરાવાય છે — તેને સમજવું (અને રીડયુસર્સ શુદ્ધ રાખવાની શિસ્ત) તે પ્રેક્ષણીય સ્થિતિમાં મૂળભૂત છે.