Kártyatrükkök

Szeletek

A Go szeletei más nyelvek listáihoz vagy tömbjeihez hasonlítanak. Egy adott típus (vagy interfész) több elemét tárolják.

A Go szeletei tömbökön alapulnak. A tömbök mérete fix. A szelet ezzel szemben egy tömb elemeinek dinamikus méretű, rugalmas nézete.

A szeletet []T formában írjuk le, ahol T a szelet elemeinek típusa:

var empty []int                 // an empty slice
withData := []int{0,1,2,3,4,5}  // a slice pre-filled with some data

Egy elemet egy adott nullaalapú indexen szögletes zárójeles jelöléssel kérhetsz le vagy állíthatsz be:

withData[1] = 5
x := withData[1] // x is now 5

Új szeletet hozhatsz létre egy meglévő szeletből úgy, hogy egy elemtartományt kérsz le. Megint szögletes zárójeles jelölést használunk, de megadjuk a kezdő (inkluzív) és a záró (exkluzív) indexet is. Ha nem adsz meg kezdő indexet, az alapértelmezés 0. Ha nem adsz meg záró indexet, az alapértelmezés a szelet hossza.

newSlice := withData[2:4]
// => []int{2,3}
newSlice := withData[:2]
// => []int{0,1}
newSlice := withData[2:]
// => []int{2,3,4,5}
newSlice := withData[:]
// => []int{0,1,2,3,4,5}

Elemeket az append függvénnyel adhatsz a szelethez. Az alábbi példában a 4-et és a 2-t fűzzük az a szelethez.

a := []int{1, 3}
a = append(a, 4, 2)
// => []int{1,3,4,2}

Az append mindig új szeletet ad vissza, és ha csak elemeket szeretnénk egy meglévő szelethez fűzni, gyakran ugyanahhoz a szeletváltozóhoz rendeljük vissza az eredményt, amelyet első argumentumként átadtunk, ahogy fent is tettük.

Az append két szelet összefűzésére is használható:

nextSlice := []int{100,101,102}
newSlice  := append(withData, nextSlice...)
// => []int{0,1,2,3,4,5,100,101,102}

Variádikus függvények

A Go-ban a függvények általában csak rögzített számú argumentumot fogadnak el. A Go-ban azonban variádikus függvényeket is írhatunk.

A variádikus függvény olyan függvény, amely változó számú argumentumot fogad el.

Ha egy függvénydefinícióban az utolsó paraméter típusa előtt három pont (...) áll, akkor a függvény ahhoz a paraméterhez tetszőleges számú argumentumot fogadhat el.

func find(a int, b ...int) {
    // ...
}

A fenti függvényben a b paraméter variádikus, és 0 vagy több argumentumot adhatunk át neki.

find(5, 6)
find(5, 6, 7)
find(5)

A variádikus függvények úgy működnek, hogy a változó számú argumentumot a variádikus paraméter típusának megfelelő szeletté alakítják.

Íme egy példa egy variádikus függvény megvalósítására.

func find(num int, nums ...int) {
    fmt.Printf("type of nums is %T\n", nums)

    for i, v := range nums {
        if v == num {
            fmt.Println(num, "found at index", i, "in", nums)
            return
        }
    }

    fmt.Println(num, "not found in ", nums)
}

func main() {
    find(89, 90, 91, 95)
    // =>
    // type of nums is []int
    // 89 not found in  [90 91 95]

    find(45, 56, 67, 45, 90, 109)
    // =>
    // type of nums is []int
    // 45 found at index 2 in [56 67 45 90 109]

    find(87)
    // =>
    // type of nums is []int
    // 87 not found in  []
}

A fenti program find(89, 90, 91, 95) sorában a find függvény változó számú argumentuma a 90, a 91 és a 95. A find függvény a num után egy variádikus int paramétert vár. Ezért ezt a három argumentumot a fordító int típusú szeletté alakítja ([]int{90, 91, 95}), majd nums néven átadja a find függvénynek.

Előfordul, hogy már van egy szeleted, és szeretnéd átadni egy variádikus függvénynek. Ezt úgy teheted meg, hogy a szelet után ...-ot adsz át. Ez jelzi a fordítónak, hogy a szeletet változatlanul használja a variádikus függvényben. A fent leírt, szeletet létrehozó lépés ebben az esetben egyszerűen elmarad.

list := []int{1, 2, 3}
find(1, list...) // "find" defined as shown above