Comment travailler avec des slices en Go?

Les slices en Go ne sont pas des tableaux, mais font référence à un segment (ou à tout) du tableau de base. Ce sont des structures de données dynamiques.

Création de slices :

• À partir d'un tableau :

// définir un tableau
arr := [5]int{1, 2, 3, 4, 5}
// créer un slice à partir d'une partie du tableau
s1 := arr[1:4] // s1 contient les éléments arr[1], arr[2], arr[3]
// créer un autre slice
s2 := arr[:3]  // s2 contient les éléments arr[0], arr[1], arr[2]
// créer un slice pointant à tout le tableau
s3 := arr[2:]  // s3 contient les éléments arr[2], arr[3], arr[4]
// créer un slice pointant à tout le tableau
s4 := arr[:]

• Avec make :

// Créer un slice de longueur 5 et capacité 5
s := make([]int, 5)
// Créer un slice de longueur 5 et capacité 10
s_cap := make([]int, 5, 10)

• Littéral :

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

Propriétés principales du slice :

• len(s): retourne la longueur actuelle du slice.
• cap(s): retourne la capacité du slice (le nombre maximum d'éléments qu'il peut contenir avant une réallocation).

Ajout d'éléments (append) :

s := []int{1, 2}
s = append(s, 3)      // ajoute un élément
s = append(s, 4, 5)   // ajoute plusieurs éléments
s2 := []int{6, 7}
s = append(s, s2...) // ajoute les éléments d'un autre slice

append peut entraîner une réallocation du tableau de base si la capacité n'est pas suffisante.

Suppression d'éléments :

La suppression d'éléments d'un slice se fait en créant un nouveau slice avec les éléments restants ou en copiant.

s := []int{1, 2, 3, 4, 5}
// Suppression de l'élément à l'indice i
i := 2 // supprimer l'élément à l'indice 2 (c'est-à-dire 3)
s = append(s[:i], s[i+1:]...)

Copie de slices :

src := []int{1, 2, 3}
dst := make([]int, len(src))
copy(dst, src) // copie les éléments de src dans dst

copy copie le minimum de la longueur des deux slices.

Itération sur un slice :

s := []string{"a", "b", "c"}
for i, v := range s {
    // i - indice, v - valeur
}
for i := range s {
    // seulement l'indice
}
for _, v := range s {
    // seulement la valeur
}

Les slices sont des types de référence :

Les modifications dans un slice se reflètent dans le tableau de base et dans d'autres slices référant à la même mémoire.

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
// Maintenant arr : [1, 99, 3, 4, 5]
// s1 : [99, 3, 4]
// s2 : [3, 4, 5] (l'élément arr[2] a changé)