Cad iad gníomharracha agus laghdaitheoirí, agus cén fáth ar ghá go mbeadh laghdaitheoirí glan?

Question

Accepted Answer

Is **gníomharrach** ann rud a bhíonn i gcomhréir agus a dhéanann cur síos ar *an rud a tharla* ; is **laghdaitheoir** ann feidhm gheal a ghlacann an staid reatha agus gníomharrach agus a thugann ar ais an staid *a leanas*. Le chéile cuireann siad i bhfeidhm athruithe stáit tuartha.

## Gníomharracha — déan cur síos ar imeachtaí

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

Ní dhéanann gníomharracha rud ar bith — tuairisceáin dhéarbhachtúla ar imeachtaí atá iontu. An iad a ainmniú in am athuair ("curtha leis", "scortha") a léiríonn go ndéanann siad taifead ar an rud a tharla.

## Laghdaitheoirí — ríomhtar an chéad staid

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

Is é síniúchán laghdaitheoirí `(state, action) => newState`. Ní mór dó staid **nua** a thabhairt ar ais (go neamhathraithe), gan an ionchuir a dhó-athrú.

## Cén fáth ar ghá go mbeadh laghdaitheoirí glan

Feidhm dheal: (1) an t-aschur céanna a thugann ar ais do an ionchuir céanna, agus (2) **níl aon thaobhghníomharracha** aici. Ní mór do laghdaitheoirí an dá riail a leanas a leanúint:

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

Cuireann gealfheidhmeanna na gné-bharrúlacha suntasacha Redux in fheidhm:

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

Baineann taobhghníomharracha (glaonna API, logáil, randamacht) le **middleware** (thunks/sagas) nó le héifeachtaí — nach i laghdaitheoirí a bhíonn siad riamh.

## An fáth gur mór an tábhacht

Is é an tsamhail gníomharrach/laghdaitheoirí croílár an bhainistíochta stáit i stíl Redux agus an fáth gur bhfuil sé chomh dheasca dífhabhtú agus tástáil.

Ní rud treallach an riachtanas gealfheidhme: is é *an rud a dhéanann* dífhabhtú taistil-ama, athrá gníomharrach, agus tástáil aonaid fánach indéanta, agus ba cheart go mbeadh taobhghníomharracha i láthair ó dheas.

Taispeántar an patrún uachta neamhathraithe-tiomáinte ag feidhmeanna geal ar fud Redux, NgRx, useReducer, agus ar bharr — a thuiscint (agus disciplíne a choinneáil laghdaitheoirí geal) tá sé bunúsach go staid intuigthe.