અવસ્થા સામાન્યીકરણ શું છે?

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-આધારિત લુકઅપ્સ આપે છે, અને ઊંડાઈથી નેસ્ટેડ, નકલ કરેલ ડેટાની બગ્સ અને કામગીરીની સમસ્યાઓ દૂર કરે છે.

સંબંધિત સત્તાઓ (વપરાશકર્તાઓ, પોસ્ટ્સ, ટિપ્પણીઓ) ની સૂચિ સાથેના apps માટે જે અપડેટ અને ક્રોસ-સંદર્ભિત થાય છે, સ્ટોર સામાન્યીકરણ — ઘણીવાર `createEntityAdapter` દ્વારા — સ્થિતિને સુસંગત અને કાર્યક્ષમ રાખવા માટે એક મુખ્ય તકનીક છે.