maps.Keys în Go

import "maps"

func Keys[Map ~map[K]V, K comparable, V any](m Map) iter.Seq[K]
func Values[Map ~map[K]V, K comparable, V any](m Map) iter.Seq[V]

Ce face maps.Keys

maps.Keys(m) returnează un iterator (iter.Seq[K]) peste cheile map-ului, iar maps.Values(m) unul peste valori. Nu returnează slice-uri: le parcurgi cu for k := range maps.Keys(m) sau le strângi cu slices.Collect.

Ordinea de parcurgere a unui map în Go este aleatorie și diferă de la o rulare la alta. Ca să afișezi cheile mereu la fel, folosește slices.Sorted(maps.Keys(m)): primești un slice nou, sortat.

Înainte de Go 1.23 scriai o buclă: for k := range m { chei = append(chei, k) }. (În pachetul experimental golang.org/x/exp/maps, Keys returna un slice; în biblioteca standard returnează un iterator.)

Parametri

Parametru	Descriere
m	Map-ul ale cărui chei sau valori le parcurgi.

Ce returnează

Un iterator: iter.Seq[K] pentru Keys, iter.Seq[V] pentru Values.

Exemple

Exemplul 1: Cheile sortate ale unui map

package main

import (
    "fmt"
    "maps"
    "slices"
)

func main() {
    note := map[string]int{"Mihai": 7, "Ana": 9, "Ioana": 10, "Radu": 8}
    elevi := slices.Sorted(maps.Keys(note))
    fmt.Println(elevi)
    for _, nume := range elevi {
        fmt.Println(nume, note[nume])
    }
}

Rezultat

[Ana Ioana Mihai Radu]
Ana 9
Ioana 10
Mihai 7
Radu 8

Exemplul 2: Suma și maximul valorilor

Suma nu depinde de ordine, deci poți parcurge maps.Values direct. Pentru maxim strângi valorile într-un slice.

package main

import (
    "fmt"
    "maps"
    "slices"
)

func main() {
    vanzari := map[string]float64{"luni": 1250.5, "marți": 980, "miercuri": 1430.25}
    total := 0.0
    for v := range maps.Values(vanzari) {
        total += v
    }
    fmt.Printf("Total: %.2f lei\n", total)
    fmt.Println("Cea mai bună zi:", slices.Max(slices.Collect(maps.Values(vanzari))), "lei")
}

Rezultat

Total: 3660.75 lei
Cea mai bună zi: 1430.25 lei

Exemplul 3: Ordinea fără sortare nu este garantată

Fără sortare, ordinea cheilor nu este garantată: poate ieși în ordinea scrierii la o rulare și amestecată la următoarea. Mai jos este rezultatul unei rulări reale.

package main

import (
    "fmt"
    "maps"
    "slices"
)

func main() {
    m := map[string]int{"Iași": 1, "Cluj": 2, "Arad": 3, "Sibiu": 4, "Brașov": 5}
    fmt.Println(slices.Collect(maps.Keys(m)))
}

Rezultat posibil (diferă la fiecare rulare)

[Arad Sibiu Brașov Iași Cluj]

Greșeli frecvente

• Scrii chei := maps.Keys(m) și apoi chei[0] sau len(chei): rezultatul este un iterator, nu un slice. Folosește slices.Collect sau slices.Sorted.
• Te bazezi pe ordinea cheilor: în teste sau pe ecran rezultatul pare corect o dată și diferă data următoare. Sortează.

Comenzi înrudite

• maps.All: Returnează un iterator peste perechile (cheie, valoare) ale unui map, în ordine aleatorie.
• slices.Sorted: Strânge valorile unui iterator într-un slice nou și îl sortează: Sorted (ordine naturală), SortedFunc și SortedStableFunc (comparație proprie).
• slices.Collect: Collect strânge valorile unui iterator într-un slice nou; AppendSeq le adaugă la finalul unui slice existent.
• iter.Seq: Tipurile pentru iteratori: Seq produce valori una câte una, Seq2 produce perechi; ambele se parcurg cu for range.