Comment le re-découpage se comporte-t-il avec les tableaux sous-jacents dans Go Slices ?

Re-découper des tranches dans Go : confusion et clarté

Dans Go, les tranches sont un moyen puissant et efficace de représenter des 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 retranchage de tranches.

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 approfondir le concept de tableaux sous-jacents . Dans 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, elle devient une fenêtre sur les deux premiers éléments de b. Cependant, le tableau sous-jacent et donc la capacité de c restent 5, ce qui inclut les emplacements inutilisés dans b.

Ce concept de re-slicing est illustré davantage 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, modifier la valeur de d modifie également la valeur de c, démontrant que c et d sont simplement des fenêtres différentes sur le même sous-jacent array.

Comprendre le concept de re-slicing est crucial pour travailler efficacement avec les tranches dans Go. Il vous permet de créer des tranches qui s'ajustent dynamiquement à différentes tailles de données sans avoir besoin de copier ou de réallouer de la mémoire.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!