Conas a oibríonn maps i Go?

Question

Accepted Answer

Is **map** a chéile Go an tábla hash ionsuite — bailiúchán neamhordeaithe de **péireanna eochair-luacha** le cuardach meánach O(1). Is é an gnáth-bhealach a chleachtar chun eochracha a cheangal le luachanna.

## Creating and using maps

```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
```

## The comma-ok idiom — distinguishing "missing" from "zero"

```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
}
```

Tá sé ríthábhachtach: má rochtaíonn tú ar eochair ar iarraidh, tugann sé ar ais luach nialais an chineáil (0, "", nil), mar sin **ní féidir leat** "eochair ar iarraidh" a dhifreáil ó "eochair i láthair le luach nialais" ó thuaidh ar an luach amháin — tugann an booleach `, ok` soiléireacht.

## Iterating (order is RANDOM)

```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.
```

Tuarann Go go dúshuaimhneach an t-ord foluain maps (chun cosc a chur ar chód a bheith ag brath air) — má theastaíonn foluain ordaithe uait, sórtáil na heochracha tú féin.

## The nil map trap

```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)
```

Is féidir map nil a léamh ach **panic ar scríobh** — caithfidh tú a dhéanamh le `make()` (nó literal) roimh stóráil.

## Keys must be comparable

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

## Cén fáth a bhíonn tábhacht ann

Is iad maps struchtúr sonraí Go bunúsach agus in-úsáide i gconaí do cheangail eochair-luacha agus cuardachtaí tapa (taisce, innéacsanna, comhaireamh, grúpáil).

Tá iompar drithuigthe éigeantach agus iad ina fhoinse coitianta botúin: an **idiom comma-ok** (an t-aon bhealach iontaofa a sheiceáil do dhíochas eochair, ó thuaidh ar eochair ar iarraidh a bhíonn ar ais ar luach nialais), an **ord foluain randomaithe** (ná bíodh iontaoibh agatsa ann — sórtáil eochracha le haghaidh aschur ordaithe), agus an **panic scríobh ar nil-map** (i gcónaí a dhúshuí roimh scríobh).

An tuiscint seo — móide go caithfidh eochracha a bheith ina gcineálacha comhpháirteach — atá riachtanach do Go ceart go laethúil agus léiríonn sé an cineál miondétail phraiticiúil a dhéanann idirdhealú ar fhorbróirí Go soladach agus a bhíonn go minic i gceistneoimh agallamh.