Redux Toolkit (RTK) கிளாசிக்கல் Redux ஐ விட என்ன வழங்குகிறது?

Question

IT Interview Practice · 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 இன் முன்னறிவிப்புத்தன்மையைக் காப்பாற்றுகிறது பல குழுக்களை மாற்றங்களுக்கு தள்ளிய சமारம்பத்தை அகற்றும் போது.

RTK தீர்க்கும் நகல் குறிப்பு சிக்கல்

RTK: createSlice எல்லாவற்றையும் செய்கிறது

RTK வேறு என்ன உள்ளடக்கம் உள்ளது

createAsyncThunk உதாரணம்

RTK ஏன் இப்போது தரமாக உள்ளது

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்