Come lavorare con gli slice in Go?

Gli slice in Go non sono array, ma fanno riferimento a un segmento (o a tutto) dell'array di base. Sono strutture di dati dinamiche.

Creazione di slice:

• Da un array:

// definire un array
arr := [5]int{1, 2, 3, 4, 5}
// creare uno slice da una parte dell'array
s1 := arr[1:4] // s1 contiene gli elementi arr[1], arr[2], arr[3]
// creare un altro slice
s2 := arr[:3]  // s2 contiene gli elementi arr[0], arr[1], arr[2]
// creare uno slice che punta a tutto l'array
s3 := arr[2:]  // s3 contiene gli elementi arr[2], arr[3], arr[4]
// creare uno slice che punta a tutto l'array
s4 := arr[:]

• Usando make:

// Creare uno slice con lunghezza 5 e capacità 5
s := make([]int, 5)
// Creare uno slice con lunghezza 5 e capacità 10
s_cap := make([]int, 5, 10)

• Letterale:

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

Proprietà principali dello slice:

• len(s): restituisce la lunghezza corrente dello slice.
• cap(s): restituisce la capacità dello slice (il numero massimo di elementi che può contenere prima di una riallocazione).

Aggiunta di elementi (append):

s := []int{1, 2}
s = append(s, 3)      // aggiunge un elemento
s = append(s, 4, 5)   // aggiunge più elementi
s2 := []int{6, 7}
s = append(s, s2...) // aggiunge gli elementi di un altro slice

append può causare una riallocazione dell'array di base se la capacità non è sufficiente.

Rimozione di elementi:

La rimozione di elementi da uno slice si ottiene creando un nuovo slice con gli elementi rimanenti o copiando.

s := []int{1, 2, 3, 4, 5}
// Rimuovere l'elemento all'indice i
i := 2 // rimuove l'elemento all'indice 2 (cioè 3)
s = append(s[:i], s[i+1:]...)

Copia di slice:

src := []int{1, 2, 3}
dst := make([]int, len(src))
copy(dst, src) // copia gli elementi da src a dst

copy copia il minimo tra le lunghezze dei due slice.

Iterare su un slice:

s := []string{"a", "b", "c"}
for i, v := range s {
    // i - indice, v - valore
}
for i := range s {
    // solo l'indice
}
for _, v := range s {
    // solo il valore
}

I slice sono tipi di riferimento:

Le modifiche a uno slice si riflettono nel array di base e in altri slice che fanno riferimento alla stessa memoria.

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
// Ora arr: [1, 99, 3, 4, 5]
// s1: [99, 3, 4]
// s2: [3, 4, 5] (l'elemento arr[2] è cambiato)