Hogyan dolgozzunk a szeletekkel Go-ban?

A Go nyúlványai nem tömbök, hanem a alap tömb egy szegmensére (vagy az egészre) hivatkoznak. Ezek dinamikus adatstruktúrák.

A nyúlványok létrehozása:

• Egy tömbből:

// tömb definiálása
arr := [5]int{1, 2, 3, 4, 5}
// nyúlvány létrehozása a tömb egy részéből
s1 := arr[1:4] // s1 tartalmazza az arr[1], arr[2], arr[3] elemeket
// másik nyúlvány létrehozása
s2 := arr[:3]  // s2 tartalmazza az arr[0], arr[1], arr[2] elemeket
// egy nyúlvány, ami a teljes tömbre mutat
s3 := arr[2:]  // s3 tartalmazza az arr[2], arr[3], arr[4] elemeket
// egy nyúlvány, ami a teljes tömbre mutat
s4 := arr[:]

• make segítségével:

// 5 hosszúságú és kapacitású nyúlvány létrehozása
s := make([]int, 5)
// 5 hosszúságú és 10 kapacitású nyúlvány
s_cap := make([]int, 5, 10)

• Literál:

s := []int{1, 2, 3}

A nyúlványok fő tulajdonságai:

• len(s): visszaadja a nyúlvány aktuális hosszát.
• cap(s): visszaadja a nyúlvány kapacitását (a maximális elemek száma, amit tartalmazhat, mielőtt újraallokáció történne).

Elemek hozzáadása (append):

s := []int{1, 2}
s = append(s, 3)      // egy elemet ad hozzá
s = append(s, 4, 5)   // több elemet ad hozzá
s2 := []int{6, 7}
s = append(s, s2...) // másik nyúlvány elemeit adja hozzá

Az append okozhat újraallokációt, ha a kapacitás nem elegendő.

Elemek törlése:

A nyúlványból való elem törlése úgy történik, hogy egy új nyúlványt hozunk létre a megmaradt elemekkel, vagy másolással.

s := []int{1, 2, 3, 4, 5}
// Egy elem törlése az i indexnél
i := 2 // töröljük a 2-es indexű elemet (azaz 3)
s = append(s[:i], s[i+1:]...)

Nyúlványok másolása:

src := []int{1, 2, 3}
dst := make([]int, len(src))
copy(dst, src) // másolja az elemeket a src-ből a dst-be

A copy a két nyúlvány minimális hosszát másolja.

Iterálás nyúlványon:

s := []string{"a", "b", "c"}
for i, v := range s {
    // i - index, v - érték
}
for i := range s {
    // csak az index
}
for _, v := range s {
    // csak az érték
}

A nyúlványok referencia típusok:

A nyúlványban végzett módosítások a tömbben és más nyúlványokban is megjelennek, amelyek ugyanarra a memóriára mutatnak.

arr := [5]int{1, 2, 3, 4, 5}
s1 := arr[1:4] // [2, 3, 4]
s2 := arr[2:5] // [3, 4, 5]

s1[0] = 99
// Most arr: [1, 99, 3, 4, 5]
// s1: [99, 3, 4]
// s2: [3, 4, 5] (az arr[2] elem változott)