რა არის keys Flutter-ში და როდის გჭირდებათ ისინი?

Question

Accepted Answer

**Keys** Flutter-ში ეხმარება ფრეიმვორკს სწორად იდენტიფიცირება და შენახვა უნდებული ვიჯეტების გადაწყობის დროს — განსაკუთრებით მნიშვნელოვანი **stateful ვიჯეტებისთვის სიებში**, რომლებიც გადალაგდება, ემატება ან იშლება. 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-ის გაგება ღირებული უფროსი დონის ცოდნაა, რადგან ისინი გადაჭრის **დამალულ, ბნელ ხარვეზებს** stateful ვიჯეტებთან დინამიურ სიებში, და ის, რომ იცით როდის გჭირდებათ ისინი, ასახავს Flutter-ის უღრმესი გაგებას.

ძირითადი პრობლემა — რომ Flutter ჩვეულებრივ ემთხვევა ვიჯეტებს მათ state-ს **პოზიციით და ტიპით** გადაწყობის დროს, რაც ჩვეულებრივ კარგად მუშაობს მაგრამ **ითავსდება როდესაც იგივე ტიპის stateful ვიჯეტები გადალაგდება, ემატება ან იშლება სიაში** (რის გამোც state თავის აბრეშუმს მაგრამ ხელმეორედ იმ უჯრაბიან ვიჯეტებზე თავსდება) — რეალური წყაროა აღრეული, ბნელი ხარვეზებისა (არასწორი checkbox მონიშნული, არასწორი item მონიშნული, state რომელიმე უკო აბრეშუმზე "სრიალების" ზეწოვება). **Keys აძლევს ვიჯეტებს სტაბილურ იდენტობას** რომ Flutter სწორად ემთხვევა მათ ამ ცვლილებებს, ასეთი ხარვეზების გამოჯამება.

კ**ლასიკური პრობლემის** გაგება (სიდან stateful ვიჯეტის ამოშორება keys-ის გარეშე რაც state-ის დეფორმაციას იწვევს) და გადაწყვეტა (თითოეული ელემენტის მიცემა სტაბილური keys-ი, როგორიცაა `ValueKey(item.id)`) არის პრაქტიკული ცოდნა რომელიც აჭრის თავს ამ აღრეული პრობლემებიდან.

**Key ტიპების** გაგება (ValueKey მნიშვნელობით keying-ისთვის, როგორიცაა ID — ხშირი სიის ელემენტებისთვის; ObjectKey; UniqueKey; და **GlobalKey** ვიჯეტის state-ში წვდომისთვის სხვაგან, როგორიცაა Form-ის GlobalKey) და კრიტიკული **როდის გჭირდებათ keys** (ძირითადად stateful ვიჯეტებისთვის დინამიურ სიებში; stateless ვიჯეტები და სტატიკური სიები ჩვეულებრივ არ ჭირდებათ ისინი) აფიქსირებს წიფე გაგებას — keys-ის სწორად გამოყენება ვიდრე ყველგან cargo-culting ან მათი დაკარგვა თქვენ მდომარეობაში.

ვინაიდან keys გადაჭრის რეალურ, დამალულ ხარვეზებს stateful ვიჯეტებთან დინამიურ სიებში (აღრეული პრობლემა რომელიც კითხვით ხელმეორედ აქცევს ბევრი დეველოპერი) და გაგება მათი თუ როგორ გამოიყენოთ აფიქსირებს უღრმესი Flutter ცოდნის დონე, keys-ის გაგება ღირებული უფროსი დონის ცოდნაა — აჭრის თავს აღრეული state ხარვეზების კლასიდან და აფიქსირებს უღრმესი გაგების Flutter-ის widget-element matching-ის მოდელი რომელიც მოსალოდნელია უფროსი როლებისთვის, კი Tolle რაც განასხვავებს მათ რომლებიც მართლა აცნობენ Flutter-ის rendering მოდელი მათი რომლებიც მხოლოდ ზედაპირულად იყენებენ მას.