Jak pracować z slices w Go?

Slicery w Go nie są tablicami, lecz odwołują się do segmentu (lub całej) tablicy bazowej. Są to dynamiczne struktury danych.

Tworzenie slice'ów:

• Z tablicy:

// definiujemy tablicę
arr := [5]int{1, 2, 3, 4, 5}
// tworzymy slice z części tablicy
s1 := arr[1:4] // s1 zawiera elementy arr[1], arr[2], arr[3]
// tworzymy inny slice
s2 := arr[:3]  // s2 zawiera elementy arr[0], arr[1], arr[2]
// tworzymy slice wskazujący na cały tablicę
s3 := arr[2:]  // s3 zawiera elementy arr[2], arr[3], arr[4]
// tworzymy slice wskazujący na cały tablicę
s4 := arr[:]

• Za pomocą make:

// Tworzymy slice o długości 5 i pojemności 5
s := make([]int, 5)
// Tworzymy slice o długości 5 i pojemności 10
s_cap := make([]int, 5, 10)

• Literal:

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

Podstawowe właściwości slice'a:

• len(s): zwraca aktualną długość slice'a.
• cap(s): zwraca pojemność slice'a (maksymalną liczbę elementów, które mogą się w nim znaleźć przed re-allocacją).

Dodawanie elementów (append):

s := []int{1, 2}
s = append(s, 3)      // dodaje jeden element
s = append(s, 4, 5)   // dodaje kilka elementów
s2 := []int{6, 7}
s = append(s, s2...) // dodaje elementy innego slice'a

append może spowodować re-allocację bazowego tablicy, jeśli pojemność jest niewystarczająca.

Usuwanie elementów:

Usuwanie elementów z slice'a osiąga się przez utworzenie nowego slice'a z pozostałymi elementami lub kopiowanie.

s := []int{1, 2, 3, 4, 5}
// Usunięcie elementu o indeksie i
i := 2 // usuwamy element o indeksie 2 (czyli 3)
s = append(s[:i], s[i+1:]...)

Kopiowanie slice'ów:

src := []int{1, 2, 3}
dst := make([]int, len(src))
copy(dst, src) // kopiuje elementy z src do dst

copy kopiuje minimalną długość z dwóch slice'ów.

Iteracja po slice'u:

s := []string{"a", "b", "c"}
for i, v := range s {
    // i - indeks, v - wartość
}
for i := range s {
    // tylko indeks
}
for _, v := range s {
    // tylko wartość
}

Slice'y są typami referencyjnymi:

Zmiany w slice'ie odzwierciedlają się w bazowym tablicy i innych slice'ach odwołujących się do tej samej pamięci.

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
// Teraz arr: [1, 99, 3, 4, 5]
// s1: [99, 3, 4]
// s2: [3, 4, 5] (element arr[2] się zmienił)