Cum să lucrezi cu slices în Go?

Slice-urile în Go nu sunt matrice, ci fac referire la un segment (sau întregul) matricei de bază. Sunt structuri de date dinamice.

Crearea de slice-uri:

• Dintr-o matrice:

// definirea unei matrice
arr := [5]int{1, 2, 3, 4, 5}
// crearea unui slice dintr-o parte a matricei
s1 := arr[1:4] // s1 conține elementele arr[1], arr[2], arr[3]
// crearea unui alt slice
s2 := arr[:3]  // s2 conține elementele arr[0], arr[1], arr[2]
// un slice care indică întreaga matrice
s3 := arr[2:]  // s3 conține elementele arr[2], arr[3], arr[4]
// un slice care indică întreaga matrice
s4 := arr[:]

• Cu make:

// Crearea unui slice cu lungimea 5 și capacitatea 5
s := make([]int, 5)
// Crearea unui slice cu lungimea 5 și capacitatea 10
s_cap := make([]int, 5, 10)

• Literal:

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

Proprietățile principale ale slice-urilor:

• len(s): returnează lungimea curentă a slice-ului.
• cap(s): returnează capacitatea slice-ului (numărul maxim de elemente pe care le poate conține înainte de realocare).

Adăugarea de elemente (append):

s := []int{1, 2}
s = append(s, 3)      // adaugă un element
s = append(s, 4, 5)   // adaugă mai multe elemente
s2 := []int{6, 7}
s = append(s, s2...) // adaugă elementele altui slice

append poate cauza o realocare a matricei de bază dacă capacitatea nu este suficientă.

Ștergerea elementelor:

Ștergerea elementelor dintr-un slice se face prin crearea unui nou slice cu elementele rămase sau prin copiere.

s := []int{1, 2, 3, 4, 5}
// Ștergerea elementului de la indexul i
i := 2 // șterge elementul de la indexul 2 (adică 3)
s = append(s[:i], s[i+1:]...)

Copierea slice-urilor:

src := []int{1, 2, 3}
dst := make([]int, len(src))
copy(dst, src) // copiază elementele din src în dst

copy copiază minimul dintre lungimile celor două slice-uri.

Iterarea peste un slice:

s := []string{"a", "b", "c"}
for i, v := range s {
    // i - index, v - valoare
}
for i := range s {
    // doar indexul
}
for _, v := range s {
    // doar valoarea
}

Slice-urile sunt tipuri de referință:

Modificările într-un slice se reflectă în matricea de bază și în alte slice-uri care fac referire la aceeași memorie.

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
// Acum arr: [1, 99, 3, 4, 5]
// s1: [99, 3, 4]
// s2: [3, 4, 5] (elementul arr[2] s-a schimbat)