Redux Toolkit (RTK) క్లాసిక్ Redux కంటే ఏమిటిని అందిస్తుంది?

Question

Accepted Answer

**Redux Toolkit (RTK)** అనేది నేటి Redux రాయడానికి సరిహద్దులుగా సిఫారసు చేయబడిన అధికారిక మార్గం. ఇది Redux యొక్క కుఖ్యాతి చెందిన బాక్స్ కోడ్ను తొలగిస్తుంది — నిర్మాణాత్మక చర్య రకాలు, చర్య సృష్టికర్తలు, మార్పులేని అప్‌డేట్ లాజిక్, స్టోర్ సెటప్ — అదే ప్రధాన సూత్రాలను నిర్వహిస్తూ.

## 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: createSlice ఎంతటిని చేస్తుంది

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

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

`createSlice` చర్య రకాలు మరియు సృష్టికర్తలను స్వయంచాలకంగా ఉత్పాదిస్తుంది, మరియు — **Immer** ద్వారా — "ఆటోమోటివ్" రిడ్యూసర్ కోడ్‌ను ఎழుతూ అనుమతిస్తుంది, ఇది సురక్షితంగా మార్పులేని అప్‌డేట్‌లుగా మార్చబడుతుంది. ఒక సంక్షిప్త స్లైస్ అన్ని నిర్మాణాత్మక భాగాలను భర్తీ చేస్తుంది.

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

## createAsyncThunk ఉదాహరణ

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

## RTK ఇప్పుడు ఎందుకు ప్రమాణం

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

## ఎందుకు ఇది ముఖ్యమైనది

క్లాసిక్ Redux యొక్క గొప్ప విమర్శన దాని బాక్స్ కోడ్ ఉంది; RTK దానిని నేరుగా సరిచేస్తుంది, అందువలన ఇది ఇప్పుడు **సరిహద్దులుగా సిఫారసు** మరియు ఆధునిక కోడ్‌బేస్‌లలో "Redux ఉపయోగించడం" అనగా ఏమిటో.

`createSlice` (Immer-సంచాలిత, స్వయంచాలక-ఉత్పన్న చర్యలు), `createAsyncThunk` (అసమకాలిక), `createEntityAdapter` (సాధారణీకరణ) మరియు RTK Query (సర్వర్ స్థితి) సమకాలీన Redux పనికి అవసరం — ఇది Redux యొక్క ఊహింపదగిన నిలువుసూచిని నిర్వహిస్తూ అనేక గుంపులను ప్రత్యామ్నాయాలకు నెట్టిన సమారంభాన్ని తీసివేస్తుంది.