Re-Slice Slices in Go: Confusion and Clarity

Dans Go, les tranches sont un moyen puissant et efficace de représenter les tableaux de données. Cependant, comprendre leurs subtilités peut être difficile pour les débutants. L'un de ces aspects est le concept de tranches de re-sifflement.

Considérez le code suivant:

package main

import "fmt"

func main() {
    a := make([]int, 5)
    printSlice("a", a)
    b := make([]int, 0, 5)
    printSlice("b", b)
    c := b[:2]
    printSlice("c", c)
    d := c[2:5]
    printSlice("d", d)
}

func printSlice(s string, x []int) {
    fmt.Printf("%s len=%d cap=%d %v\n",
        s, len(x), cap(x), x)
}

Le programme crée quatre tranches: a, b, c et d. Le résultat surprenant est que la tranche C, créée comme une tranche des deux premiers éléments de B, a une capacité de 5 au lieu de 2.

pour comprendre ce comportement, nous devons nous plonger dans le concept de tableaux sous-jacents . En Go, les tranches ne stockent pas les données réelles; Ils font plutôt référence à un tableau sous-jacent. Lorsqu'une tranche est créée, elle pointe vers un segment de ce tableau sous-jacent.

Dans l'exemple ci-dessus, lorsque B est créé avec une longueur de 0 mais une capacité de 5, il réserve 5 emplacements dans un tableau sous-jacent . Lorsque la tranche C est créée à partir de B, il devient une fenêtre sur les deux premiers éléments de B. Cependant, le tableau sous-jacent et donc la capacité de C demeure 5, qui inclut les emplacements inutilisés en b.

Ce concept de rediffusion est illustré en modifiant légèrement le code:

func main() {
    b := make([]int, 0, 5)
    c := b[:2]
    d := c[1:5] // this is equivalent to d := b[1:5]
    d[0] = 1
    printSlice("c", c)
    printSlice("d", d)
}

Dans ce cas, la modification de la valeur de D modifie également la valeur de C, démontrant que C et D sont juste des fenêtres différentes sur le même tableau sous-jacent.

Comprendre le concept de re Le tranchage est crucial pour travailler efficacement avec des tranches en Go. Il vous permet de créer des tranches qui s'adaptent dynamiquement à différentes tailles de données sans avoir besoin de copier ou de réaffectation de la mémoire.