Flutter-இல் keys என்றால் என்ன மற்றும் எப்போது அவற்றைப் பயன்படுத்த வேண்டும்?

Question

Accepted Answer

**Keys** Flutter-இல் widget-களை மீண்டும் கட்டமைக்கும்போது சரியாகக் கண்டறிந்து பாதுகாக்க framework-ஐ உதவுகின்றன — **தொகுப்புக்களில் stateful widget-கள்** மறுவரிசைப்படுத்தப்பட்டு, சேர்க்கப்பட்டு அல்லது அகற்றப்படும்போது இது மிகவும் முக்கியமாக உள்ளது. Keys எப்போது தேவைப்படுகிறது என்பதைப் புரிந்துகொள்வது நுணுக்கமான, குழப்பமான பிழைகளைத் தடுக்கிறது.

## Keys என்ன செய்கிறது

```text
During rebuilds, Flutter MATCHES new widgets to existing elements/state by POSITION and
TYPE. Usually this works fine. But when widgets of the SAME TYPE are reordered/added/
removed in a list, position-matching gets confused → state attaches to the WRONG widget.
→ KEYS give widgets a stable IDENTITY so Flutter matches them correctly across changes.
```

## கிளாசிக் சிக்கல் (keys இல்லாமல்)

```text
A list of STATEFUL widgets (e.g. items with their own state). You remove the FIRST item:
  ✗ WITHOUT keys → Flutter matches by position → the state stays at each position, so
    state appears attached to the WRONG items (state "shifts" incorrectly)
  ✓ WITH keys → Flutter matches by key → state follows the correct widget
→ This causes confusing bugs (wrong checkbox checked, wrong item highlighted, etc.).
```

```dart
// give list items stable keys (e.g. a unique id)
ListView(children: items.map((item) =>
  MyStatefulItem(key: ValueKey(item.id), item: item)   // stable identity
).toList())
```

## Key வகைகள் மற்றும் எப்போது பயன்படுத்த வேண்டும்

```text
ValueKey → key by a value (e.g. an item's unique id) — common for list items
ObjectKey → key by an object's identity
UniqueKey → a guaranteed-unique key (forces a new identity each build — use carefully)
GlobalKey → a globally-unique key; access a widget's state/context from elsewhere
  (e.g. Form's GlobalKey) — powerful but heavier; use sparingly
WHEN NEEDED: mainly for STATEFUL widgets in dynamic lists (reorder/add/remove).
  Stateless widgets and static lists usually DON'T need keys.
```

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

Keys புரிந்துகொள்வது மதிப்பிடப்பட்ட senior-நிலை அறிவாகும், ஏனெனில் அவை **dynamic தொகுப்புக்களில் stateful widget-களுடன் நுணுக்கமான, குழப்பமான பிழைகளை** தீர்க்கின்றன, மேலும் அவை எப்போது தேவைப்படுகிறது என்பதை அறிந்திருப்பது ஆழமான Flutter புரிதலை பிரதிபலிக்கிறது.

মূল சிக்கல் — Flutter பொதுவாக widget-களை **நிலை மற்றும் வகை** மூலம் மீண்டும் கட்டப்படும்போது அவற்றின் state-க்கு பொருத்துகிறது, இது பொதுவாக நன்றாக செயல்படும் ஆனால் **ஒரே வகையின் stateful widget-கள் தொகுப்பில் மறுவரிசைப்படுத்தப்படும், சேர்க்கப்படும் அல்லது அகற்றப்படும் போது உடைகிறது** (state தவறான widget-களுக்கு இணைக்கப்படுவதாக) — இது விடுவிக்க முடியாத பிழைகளின் உண்மையான மூல ஆகும் (தவறான checkbox நிரീட்ஷணம், தவறான item முன்னிலைப்படுத்தப்படுதல், state தவறாகப் "மாறுவது" போலத் தோன்றுதல்). **Keys widget-களுக்கு ஒரு நிலையான அடையாளம் வழங்குகிறது** இந்த மாற்றங்களில் Flutter அவற்றை சரியாக பொருத்தும்படி, அத்தகைய பிழைகளை சரிசெய்ய.

**கிளாசிக் சிக்கல்** (keys இல்லாமல் stateful widget-களின் தொகுப்பிலிருந்து ஒரு item அகற்றுவது state ஐ தவறாக சீரமைக்க) மற்றும் தீர்வு (`ValueKey(item.id)` போன்ற நிலையான keys வழங்குவது) புரிந்துகொள்வது இந்த குழப்பமான சிக்கல்களைத் தீர்க்கும் நடைமுறை அறிவாகும்.

**Key வகைகள்** (ValueKey - ஒரு id போன்ற மதிப்பு மூலம் keying செய்ய — தொகுப்பு item-களுக்கு பொதுவானது; ObjectKey; UniqueKey; மற்றும் **GlobalKey** — ஒரு widget-ஆன் state-ஐ வேறிடத்திலிருந்து அணுக, Form-ன் GlobalKey போல) மற்றும் முக்கியமாக **keys எப்போது தேவைப்படுகிறது** (முக்கியமாக dynamic தொகுப்புக்களில் stateful widget-களுக்கு; stateless widget-கள் மற்றும் static தொகுப்புக்கள் பொதுவாக அவற்றை தேவையில்லை) புரிந்துகொள்வது பக்குவ புரிதலைப் பிரதிபலிக்கிறது — keys-ஐ பொருத்தமாகப் பயன்படுத்துவது cargo-cult செய்வதை விட அல்லது தேவையான இடங்களில் அவற்றை தவிர்ப்பதை விட.

Keys dynamic தொகுப்புக்களில் stateful widget-களுடன் உண்மையான, நுணுக்கமான பிழைகளைத் தீர்க்கிறது (பல விকাশকர்களை குழப்பிக்கும் குழப்பமான சிக்கல்) மற்றும் அவற்றை எப்போது மற்றும் எப்படி பயன்படுத்த வேண்டும் என்பதைப் புரிந்துகொள்வது ஆழமான Flutter அறிவைப் பிரதிபலிக்கிறது என்பதால், keys புரிந்துகொள்வது மதிப்பிடப்பட்ட senior-நிலை அறிவாகும் — state பிழைகளின் ஒரு வகுப்பைத் தீர்க்கிறது மற்றும் senior பாத்திரங்களுக்கு எதிர்பார்க்கப்படும் Flutter-ன் rendering மாதிரির ஆழமான புரிதலைப் பிரதிபலிக்கிறது, Flutter-ஐ உண்மையாகப் புரிந்துகொள்பவர்கள் மற்றும் யார் மேலே பயன்படுத்துபவர்களை வேறுபடுத்தும் ஒரு தலைப்பு அல்ப உணர்வை.