როგორ მუშაობენ რუკები Go-ში?

Question

Accepted Answer

**map** არის Go-ს ჩაშენებული hash table — **key-value წყვილების** დაუწესრიგებელი კოლექცია საშუალო O(1) lookup-ით. ეს არის სტანდარტული გზა, რომ დააკავშიროთ keys მნიშვნელობებთან.

## რუკების შექმნა და გამოყენება

```go
// create with make
ages := make(map[string]int)    // map from string keys to int values
ages["Ann"] = 30                 // set
age := ages["Ann"]               // get → 30

// or with a literal
scores := map[string]int{
    "math":    90,
    "science": 85,
}

delete(scores, "math")           // remove a key
len(scores)                       // number of entries
```

## comma-ok იდიომა — "აკლია" და "ნული"-ის განსხვავება

```go
// ⚠️ a missing key returns the ZERO VALUE, not an error
value := scores["missing"]       // 0 — but was it stored as 0, or absent? Ambiguous!

// ✅ the comma-ok form tells you if the key EXISTS
value, ok := scores["missing"]
if ok {
    fmt.Println("found:", value)
} else {
    fmt.Println("not present")    // key doesn't exist
}
```

ეს აუცილებელია: აკლებული key-ზე წვდომა აბრუნებს value type-ის ნულოვან მნიშვნელობას (0, "", nil), ამიტომ თქვენ **ვერ გააკოცნებთ** "key აკლია" "key აქვს ნულოვანი მნიშვნელობით"-ის მხოლოდ მნიშვნელობიდან — `, ok` boolean-ი აარკვევს ამას.

## განმეორება (ბრძანება არის ᲨᲔᲛᲗᲮᲕᲔᲕᲘᲗᲘ)

```go
for key, value := range scores {
    fmt.Println(key, value)
}
// ⚠️ iteration order is RANDOMIZED — never rely on map order!
// To iterate in order: collect keys into a slice, sort it, then iterate.
```

Go განზრახ აკეთებს რუკის iteration order-ს შემთხვევით (რომ შეიცვალოს კოდი მასზე დამოკიდებულობა) — თუ გჭირდებათ ordered iteration, დაალაგეთ keys თქვენ თავიდან.

## nil რუკის სახიფათო

```go
var m map[string]int        // nil map (declared but not initialized)
v := m["x"]                 // ✅ reading is OK → 0
m["x"] = 1                  // 💥 PANIC: assignment to entry in nil map
// must initialize first: m = make(map[string]int)
```

nil რუკა შეიძლება წაიკითხოს მაგრამ **panicდება ჩაწერაზე** — თქვენ უნდა `make()` ის (ან გამოიყენოთ literal) ჩაწერამდე.

## Keys უნდა იყვნენ შედარებადი

```text
Valid keys: comparable types (string, int, bool, structs of comparable fields, pointers)
Invalid keys: slices, maps, functions (not comparable) → compile error
```

## რატომ არის ეს მნიშვნელოვანი

რუკები არის Go-ს ფუნდამენტური, მუდმივად გამოყენებული data structure key-value ასოცირებისა და სწრაფი lookup-ის (caches, indexes, counting, grouping) განსახორციელებლად.

რამდენიმე ქცევა აუცილებელია ცოდნა და არის bug-ების გავრცელებული წყარო: **comma-ok იდიომა** (ერთადერთი საიმედო გზა key existence-ის შესამოწმებლად, რადგან აკლებული key აბრუნებს zero value-ს), **randomized iteration order** (არასოდეს დამოკიდებული იყოთ მასზე — დაალაგეთ keys ordered output-ისთვის), და **nil-map write panic** (ყოველთვის initialize-იყავით ჩაწერამდე).

ამის გაგება — პლუს ის, რომ keys უნდა იყვნენ comparable types — აუცილებელია სწორი ყოველდღიური Go-სა და ასახავს პრაქტიკული დეტალის ტიპს, რომელიც განასხვავებს მყარ Go დეველოპერებს და ხშირად ჩნდება ინტერვიუებში.