Slices : la structure idiomatique

Une slice est la structure de données la plus utilisée dans Go : une vue dynamique sur un tableau sous-jacent. Syntaxe : []T. Contrairement à des tableaux, la longueur ne fait pas partie du type, et vous pouvez la faire grandir avec append.

Anatomie d'une tranche

En interne, une tranche est une structure à trois champs :

• un pointeur vers le premier élément du tableau sous-jacent
• une longueur (len) : nombre d'éléments visibles
• une capacité (cap) : éléments disponibles dès le début de la vue à la fin du tableau sous-jacent

s := []int{10, 20, 30}
fmt.Println(len(s), cap(s)) // 3 3

Création

a := []int{1, 2, 3}          // letterale
b := make([]int, 3)          // [0 0 0]   len=3 cap=3
c := make([]int, 3, 10)      // len=3 cap=10 (riservata)
var d []int                  // nil slice: len=0 cap=0, ma usabile con append

append : Attribuez toujours le résultat

append ajoute des éléments et renvoie une nouvelle tranche (potentiellement allouer une nouvelle baie si la capacité n'est pas suffisante) :

s := []int{1, 2, 3}
s = append(s, 4)              // [1 2 3 4]
s = append(s, 5, 6, 7)        // aggiungi più elementi
s = append(s, altra...)       // concatena un'altra slice (spread)

Expression de tranche s[a:b]

Extrait une sous-tranche de a (inclus) à b (exclusif) :

s := []int{10, 20, 30, 40, 50}
sub := s[1:4]              // [20 30 40]
inizio := s[:2]            // [10 20]
fine := s[3:]              // [40 50]
intera := s[:]             // [10 20 30 40 50]

Les sous-tranches partagent le tableau sous-jacent avec la tranche original : les modifications dans sub[i] = ... sont également visibles dans s.

Piège : partage de tableaux

s := []int{1, 2, 3, 4}
sub := s[0:2]
sub[0] = 99
fmt.Println(s)             // [99 2 3 4] — modificato!

Pour obtenir une copie autonome, utilisez copy ou append :

out := make([]int, len(sub))
copy(out, sub)

Essayez-le vous-même

s := []int{1, 2, 3}
// (a) s = append(s, 4)
// (b) append(s, 4)

Récapitulatif

• []T : vue dynamique sur un tableau ; triple (ptr, lentille, capuchon).
• make([]T, len, cap) pour pré-attribuer ; var s []T pour une tranche utilisable nulle.
• s = append(s, ...) : TOUJOURS attribuer le résultat.
• s[a:b] partage le tableau sous-jacent : copy(...) pour les copies indépendantes.
• nil slice = OK pour lire/plage/ajouter ; très différent d'une carte nulle.