நிலை இயல்பாக்கம் என்றால் என்ன?

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` மூலம் — நிலை சந்தர்பமாக மற்றும் திறமையாக வைத்திருக்க ஒரு முக்கிய நுட்பமாக உள்ளது.