Cén fáth go bhfuil neamhathraitheacht tábhachtach i mbainistíochtaí staid?

Question

Accepted Answer

**Neamhathraitheacht** a chiallaíonn nach dtagann tú ar staid in áit — ina áit sin, cruthaíonn tú **réad** nua/array leis na hathruithe. Is é seo an rud lárnach don chaoi ar bhraithníonn React, Redux agus uirlisí cosúil leis athruithe agus an UI a thabhairt cothrom le dáta i gceart.

## An fhadhb le mutatú

```jsx
// ❌ mutating — React doesn't detect the change
function addItem(item) {
  items.push(item);   // same array reference → React sees "no change" → no re-render
  setItems(items);    // passing the same reference back
}

// ✅ immutable — a NEW array, new reference → React re-renders
function addItem(item) {
  setItems([...items, item]); // create a new array
}
```

Braithníonn React (agus Redux) athruithe trí **tagartha** a chur i gcomparáid (`oldState === newState`), ní thábhair domhain — do fheidhmíocht. Má dhéanann tú mutatú in áit, fanann an tagairt mar an gcéanna, mar sin shíleann an creat nach raibh aon rud athraithe agus scipeanna an athghiniúint.

## Patrúin nuashonraiththe neamhathraithe

```js
// arrays
setItems([...items, newItem]);                  // add
setItems(items.filter(i => i.id !== id));        // remove
setItems(items.map(i => i.id === id ? { ...i, done: true } : i)); // update one

// objects
setUser({ ...user, name: "Bob" });               // update a field
setUser({ ...user, address: { ...user.address, city: "NY" } }); // nested update
```

Cruthaíonn an t-oibreoir spread cóipeanna foluain; do dhonraigí foluain tú cóipeanna gach leibhéal a athrú tú.

## Cén fáth go bhfuil níos mó sochar le neamhathraitheacht

```text
✓ Reliable change detection → correct, efficient re-renders (reference equality)
✓ Enables performance optimizations (React.memo, OnPush, useMemo) that compare references
✓ Predictable state — old state is never altered, easing debugging
✓ Time-travel debugging & undo/redo (keep past state snapshots)
```

## Uirlisí a chabhraíonn

```js
// Immer (used by Redux Toolkit) lets you "mutate" a draft → produces an immutable result
produce(state, draft => { draft.items.push(item); }); // safe + readable
```

Déanann Immer nuashonraithí neamhathraithe foluain ergonomic trí ligean duit cód atá cosúil le mutatú a scríobh ar dhréacht a thiontaíonn sé go nuashonrú neamhathraithe.

## Cén fáth a bhfuil sé tábhachtach

Neamhathraitheacht an meicníc atá i bhfeidhm go bhraistear athrú bunaithe ar thagairt — is é sin *cén fáth* go dtógann `[...items]` athghiniúint ach `items.push()` nach ndéanann.

Taobh amuigh den cheart, osclaíonn sé barrainní feidhmíochta (cloinn comparáid tagairtí) agus gné cumhachtacha (scrios/déan arís, taisteal-ama).

Bheith ar thuiscint ar phatrúin nuashonraiththe neamhathraithe (agus uirlisí cosúil le Immer) riachtanach do dhóchas a dhéanamh i gceart le React/Redux; mutatú staid is ceann de na fabhtanna is coitianta ag tosaitheoirí.