Pourquoi le retranchage d'une tranche Go entraîne-t-il des valeurs de capacité inattendues ?

Re-trancher des tranches dans Golang

Comprendre le comportement des tranches peut être déroutant, surtout lorsqu'un re-tranchage est impliqué. Dans cet extrait :

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)
}

La sortie révèle un résultat inattendu :

a len=5 cap=5 [0 0 0 0 0]
b len=0 cap=5 []
c len=2 cap=5 [0 0] 
d len=3 cap=3 [0 0 0]

Pourquoi c a-t-il une capacité de 5 et non de 2 ? Pour répondre à cette question, nous devons comprendre le concept de tranches dans Golang.

Les tranches sont des références légères à des tableaux. Lorsque nous créons une tranche, nous fournissons une opération de plage (par exemple, [:2]) pour spécifier les indices de début et de fin du tableau référencé. Toutefois, cette opération de plage ne crée pas de copie du tableau sous-jacent. Au lieu de cela, il crée une nouvelle tranche qui partage les mêmes données sous-jacentes.

Dans l'exemple donné, b est une tranche vide d'une capacité de 5. Lorsque nous créons c comme une tranche de b avec une plage de [ :2], nous créons essentiellement une référence aux deux premiers éléments de b. Puisque b a une capacité de 5, c peut potentiellement être étendu pour inclure jusqu'à 5 éléments, même si seuls 2 éléments sont actuellement référencés. C'est pourquoi c a une capacité de 5 bien que sa longueur soit 2.

De plus, lorsque nous créons d comme une tranche de c avec une plage de [2:5], nous créons effectivement une tranche qui partage les mêmes données sous-jacentes que b, mais commençant à partir de l'index 2 et s'étendant jusqu'à l'index 5. Puisque b a une capacité de 5, d a une capacité de 3 (5-2).

Le programme suivant illustre ce comportement plus clairement :

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

Sortie :

c len=2 cap=5 [0 1] // modifying d has modified c
d len=4 cap=4 [1 0 0 0] 

Comme vous pouvez le voir, la modification de d a également modifié c, démontrant que c et d sont tous deux des fenêtres sur le même sous-jacent tableau, b.

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!