Cad a sholáthraíonn Redux Toolkit (RTK) os cionn Redux clasaiceach?

Question

Accepted Answer

**Redux Toolkit (RTK)** an bealach oifigiúil agus molta chun Redux a scríobh inniu. Cuireann sé deireadh leis an boilerplate iomráiteach de Redux clasaiceach — cineálacha gníomhartha manuála, cruthaitheoir gníomhartha, loighic uachta neamh-athraitheach, socrú stór — agus é a choinneáil na bunphrionsabail chéanna.

## An fhadhb boilerplate a réiteodh RTK

```js
// ❌ classic Redux — verbose: action types, creators, switch reducers, manual immutability
const INCREMENT = "counter/increment";
const increment = () => ({ type: INCREMENT });
function reducer(state = { value: 0 }, action) {
  switch (action.type) {
    case INCREMENT: return { ...state, value: state.value + 1 };
    default: return state;
  }
}
```

## RTK: déanann createSlice gach rud

```js
import { createSlice, configureStore } from "@reduxjs/toolkit";

export const { increment, incrementBy } = counterSlice.actions; // action creators AUTO-generated
const store = configureStore({ reducer: { counter: counterSlice.reducer } });
```

Génerálonn `createSlice` cineálacha agus cruthaitheoir gníomhartha go huathoibríoch, agus — trí **Immer** — tugann sé deis duit cód laghdaitheora a scríobh atá ag athrú go sábháilte arna tiontú go nuashonruithe neamh-athraitheach. Cuireann críochtholl dhingthe amháin na píosaí manuála ar fad in ionad a chéile.

## Cad eile a bhíonn i RTK

```text
configureStore   → store setup with DevTools + thunk middleware preconfigured
createAsyncThunk → standard async (pending/fulfilled/rejected actions) for data fetching
createEntityAdapter → normalized state + CRUD reducers for collections
RTK Query        → a full data-fetching/caching layer (like React Query, built into Redux)
```

## Sampla createAsyncThunk

```js
export const fetchUsers = createAsyncThunk("users/fetch", () => api.getUsers());
// auto-dispatches users/fetch/pending | fulfilled | rejected — handle in extraReducers
```

## Cén fáth gur caighdeán RTK anois

```text
✓ ~75% less code than classic Redux
✓ Immer → no manual immutable spread logic (fewer bugs)
✓ Good defaults (DevTools, thunk) out of the box
✓ Encourages best practices (slices, normalized data)
✓ RTK Query bundles server-state management
```

## Cén fáth a bhíonn sé tábhachtach

Ba bhreall ab fhéarr a bhí ar Redux clasaiceach ná a boilerplate; tugann RTK réiteach díreach ar an fhadhb seo, agus sin an fáth go bhfuil sé anois an **moladh oifigiúil** agus cad a chiallaíonn "Redux a úsáid" i bunchodanna códa nua-aimseartha.

Tá tuiscint ar `createSlice` (cumhachtaithe ag Immer, gníomhartha a ghintear go huathoibríoch), `createAsyncThunk` (neamhsincronach), `createEntityAdapter` (normalú) agus RTK Query (stát an fhreastalaí) riachtanach do obair RTK comhaimseartha — caoimearca sé inchomhairtitheacht Redux agus cuireann sé deireadh ar an tseirimint a bhí ag solathar i leith fhear foirceann chun roghanna eile.