Go-ban a for és egy index segítségével is végigmehetsz egy slice elemein, de használhatod a range-et is.
A range segítségével egy map elemein is végigmehetsz.
Minden iteráció két értéket ad vissza: az indexet/kulcsot és az adott indexen/kulcson lévő elem egy másolatát.
Iterálás egy slice elemein
Gyerekjáték: a ciklus a slice elemein a várt sorrendben megy végig.
xi := []int{10, 20, 30}
for i, x := range xi {
fmt.Println(i, x)
}
// outputs:
// 0, 10
// 1, 20
// 2, 30
Iterálás egy map elemein
A map elemein való iterálás új problémát vet fel.
A sorrend most véletlenszerű.
hash := map[int]int{9: 10, 99: 20, 999: 30}
for k, v := range hash {
fmt.Println(k, v)
}
// outputs, for example:
// 99 20
// 999 30
// 9 10
Első ránézésre úgy tűnhet, hogy a fenti kimenet hibás, hiszen az ember arra számítana, hogy a map deklarálásakor elsőként megadott kulcs/érték pár, a 9 10, jelenik meg először a kimenetben, nem pedig utolsóként.
A map-ek azonban természetüknél fogva rendezetlenek: nincs sem első, sem utolsó kulcs/érték pár.
Emiatt amikor egy map bejegyzésein iterálsz, a bejegyzések bejárási sorrendje véletlenszerű lesz, és nem követ semmilyen meghatározott mintát.
Ez azt jelenti, hogy a fenti kimenet lehetséges, de eltérhet attól, amit te kapsz, ha magad is lefuttatod a kódot.
Ha többet szeretnél megtudni erről, nézd meg a Go Language Spec: range clause oldalt.
Iterálás a kulcs vagy az érték elhagyásával
Go-ban a fel nem használt változó fordítási időben hibát okoz.
Néha csak az értékre van szükséged, ahogy az első példában is:
xi := []int{10, 20, 30}
for i, x := range xi {
fmt.Println(x)
}
// Go build failed: i declared but not used
Az i helyére _-t írhatsz, ami megmondja a fordítónak, hogy nem használjuk azt az értéket:
xi := []int{10, 20, 30}
for _, x := range xi {
fmt.Println(x)
}
// outputs:
// 10
// 20
// 30
Ha csak az indexet szeretnéd kiírni, az x helyére _-t tehetsz,
vagy egyszerűen elhagyhatod a deklarációt:
xi := []int{10, 20, 30}
// for i, _ := range xi {
for i := range xi {
fmt.Println(i)
}
// outputs:
// 0
// 1
// 2
Nem struct típusok
Korábban már láttad, hogyan lehet struct típusokat definiálni.
Nem struct típusokat is definiálhatsz, amelyeket beépített típusdeklaráció álneveként használhatsz, és receiver függvényeket is definiálhatsz rajtuk, hogy ugyanúgy ki tudd őket egészíteni, mint a struct típusokat.
type Name string
func SayHello(n Name) {
fmt.Printf("Hello %s\n", n)
}
n := Name("Fred")
SayHello(n)
// Output: Hello Fred
Olyan nem struct típusokat is definiálhatsz, amelyek tömbökből és map-ekből állnak.
type Names []string
func SayHello(n Names) {
for _, name := range n {
fmt.Printf("Hello %s\n", name)
}
}
n := Names([]string{"Fred", "Bill"})
SayHello(n)
// Output:
// Hello Fred
// Hello Bill
Tanulófeladat
