స్టేట్ నార్మలైజేషన్ అంటే ఏమిటి?

Question

Accepted Answer

**నార్మలైజేషన్** అంటే డేటాను ఫ్లాట్, రిలేషనల్ స్ట్రక్చర్‌లో నిల్వ చేయడం — లుకప్ టేబల్‌లలో **id** ద్వారా కీ చేయబడిన — లోతైన నెస్టెడ్ ఆబ్జెక్ట్‌ల/అర్రేల కంటే బదులుగా. ఇది డేటాబేస్ నార్మలైజేషన్ వలె ఉంటుంది, క్లయింట్ స్టేట్‌కు వర్తించబడుతుంది, మరియు ఇది అప్‌డేట్‌లు మరియు లుకప్‌లను సమర్థవంతమైన మరియు సামర్థ్యవంతమైనవిగా చేస్తుంది.

## నెస్టెడ్/డినార్మలైజ్డ్ స్టేట్‌లో సమస్య

```js
// ❌ nested & duplicated — the same user appears in multiple posts
posts: [
  { id: 1, title: "A", author: { id: 10, name: "Ann" } },
  { id: 2, title: "B", author: { id: 10, name: "Ann" } }, // Ann duplicated
]
// To rename Ann, you must find and update EVERY copy → easy to miss one (drift)
// To find post #2, you must scan the array
```

నకిలీ నెస్టెడ్ డేటా చాలా చోట్ల నుండి నవీకరించాలి (సమానత్వం లేని ప్రమాద), మరియు ఐటెమ్‌ను కనుగొనడం అర్రేలను స్కాన్ చేయడం (O(n)).

## నార్మలైజ్డ్ ఆకారం

```js
// ✅ flat lookup tables keyed by id, with references by id
{
  posts: {
    byId: { 1: { id: 1, title: "A", authorId: 10 },   // reference the author by id
            2: { id: 2, title: "B", authorId: 10 } },
    allIds: [1, 2],                                     // order/iteration
  },
  users: {
    byId: { 10: { id: 10, name: "Ann" } },             // each user stored ONCE
  },
}
```

ప్రతి ఎంటిటీ ఒకసారి నిల్వ చేయబడుతుంది, id ద్వారా కీ చేయబడిన; సంబంధాలు కేవలం id సూచనలు.

## ప్రయోజనాలు

```js
state.users.byId[10];                        // ✅ O(1) lookup by id
state.users.byId[10] = { ...u, name: "Bob" }; // ✅ update Ann ONCE → reflected everywhere
state.posts.allIds.map(id => state.posts.byId[id]); // iterate via the id list
```

```text
✓ Single source of truth per entity → no duplication, no drift
✓ O(1) lookups/updates by id (vs scanning arrays)
✓ Easy to update one entity and have all references reflect it
✓ Simpler to manage relationships and merge new data
```

## సాధనాలు

```text
Redux Toolkit's createEntityAdapter generates normalized { ids, entities }
structures + CRUD reducers automatically. normalizr can normalize API responses.
```

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

నార్మలైజేషన్ క్లయింట్ స్టేట్‌లో **సంబంధిత/సంగ్రహణ డేటా** నిర్వహించడానికి ప్రామాణిక నమూనా (ముఖ్యంగా Redux లో).

ఇది ప్రతి ఎంటిటీకు సత్యం యొక్క ఒకే మూలాన్ని ఎక్కడ కర్ఫర్స్ చేస్తుంది (ఒకసారి నవీకరించండి, ప్రతిచోటా ప్రతిబింబిస్తుంది), వేగవంతమైన id-ఆధారిత లుకప్‌లను ఇస్తుంది, మరియు లోతైన నెస్టెడ్, నకిలీ డేటా యొక్క బగ్‌లు మరియు పనితీరు సమస్యలను నివారిస్తుంది.

సంబంధిత ఎంటిటీల జాబితాలు (వినియోగదారులు, పోస్ట్‌లు, వ్యాఖ్యలు) నవీకరించిన మరియు క్రాస్-రెఫర్‌లెన్స్ చేసిన అనువర్తనాల కోసం, స్టోర్‌ను నార్మలైజ్ చేయడం — తరచుగా `createEntityAdapter` ద్వారా — స్టేట్‌ను సంగతమైన మరియు సమర్థవంతమైనదిగా ఉంచడానికి ఒక కీ టెక్నిక్.