Как да работите със слайсове в Go?

Слайсовете в Go не са масиви, а се отнасят към сегмент (или цялата) на базовия масив. Те са динамични структури от данни.

Създаване на слайсове:

• От масив:

// определяне на масив
arr := [5]int{1, 2, 3, 4, 5}
// създаване на слайс от част от масива
s1 := arr[1:4] // s1 съдържа елементите arr[1], arr[2], arr[3]
// създаване на друг слайс
s2 := arr[:3]  // s2 съдържа елементите arr[0], arr[1], arr[2]
// слайс, който сочи към цялата матрица
s3 := arr[2:]  // s3 съдържа елементите arr[2], arr[3], arr[4]
// слайс, който сочи към цялата матрица
s4 := arr[:]

• С помощта на make:

// създаване на слайс с дължина 5 и капацитет 5
s := make([]int, 5)
// създаване на слайс с дължина 5 и капацитет 10
s_cap := make([]int, 5, 10)

• Литерал:

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

Основни свойства на слайса:

• len(s): връща текущата дължина на слайса.
• cap(s): връща капацитета на слайса (максималният брой елементи, които може да съдържа преди ре-алокация).

Добавяне на елементи (append):

s := []int{1, 2}
s = append(s, 3)      // добавя един елемент
s = append(s, 4, 5)   // добавя няколко елемента
s2 := []int{6, 7}
s = append(s, s2...) // добавя елементите на друг слайс

append може да предизвика ре-алокация на базовия масив, ако капацитетът не е достатъчен.

Премахване на елементи:

Премахването на елементи от слайс се постига чрез създаване на нов слайс с останалите елементи или чрез копиране.

s := []int{1, 2, 3, 4, 5}
// Премахване на елемент по индекс i
i := 2 // премахваме елемента по индекс 2 (т.е. 3)
s = append(s[:i], s[i+1:]...)

Копиране на слайсове:

src := []int{1, 2, 3}
dst := make([]int, len(src))
copy(dst, src) // копира елементите от src в dst

copy копира минималната дължина между двата слайса.

Итерация по слайс:

s := []string{"a", "b", "c"}
for i, v := range s {
    // i - индекс, v - стойност
}
for i := range s {
    // само индекс
}
for _, v := range s {
    // само стойност
}

Слайсовете са референтни типове:

Промените в слайс се отразяват на базовия масив и на други слайсове, които сочат към същата памет.

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
// Сега arr: [1, 99, 3, 4, 5]
// s1: [99, 3, 4]
// s2: [3, 4, 5] (елементът arr[2] се е променил)