Pourquoi retrancher une Go Slice ne réduit-il pas toujours sa capacité ?

Recouper des tranches dans Golang

Dans Go, les tranches offrent un moyen flexible de gérer des collections d'éléments. Bien que la création et l'accès à des tranches soient simples, comprendre le comportement de leur retranchage peut s'avérer délicat. Explorons un extrait de code qui illustre ce concept :

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

Ce code crée une tranche a d'une longueur de 5 et d'une capacité de 5, suivie de deux tranches b et c de longueurs et de capacités de 0 et 2 respectivement. La tranche d est ensuite créée comme une retranche de c avec un indice de début de 2 et un indice de fin de 5.

La partie déroutante survient lors de l'observation du résultat :

a len=5 cap=5 [0 0 0 0 0]
b len=0 cap=5 []
c len=2 cap=5 [0 0] //why the capacity of c not 2 but 5 instead
d len=3 cap=3 [0 0 0]

Comprendre le retranchage

Lorsque vous retranchez une tranche, il est important de se rappeler que les tranches sont pas de copies de leurs tableaux sous-jacents. Au lieu de cela, ce sont des fenêtres qui font référence à une partie du tableau.

• Dans le cas de la tranche c, elle est créée comme une tranche des deux premiers éléments de la tranche b. Puisque b a une capacité de 5, la tranche c peut être étendue pour inclure les trois éléments restants. C'est pourquoi sa capacité reste à 5.
• La tranche d est ensuite créée comme une re-tranche de c avec un indice de départ de 2. Cela signifie que d référence les éléments de b dans l'intervalle de [2, 5). Puisqu'il ne reste que trois éléments dans cette plage, la longueur de d est de 3 et sa capacité est de 3 (puisqu'il fait partie d'une tranche plus grande d'une capacité totale de 5).

Clarifications supplémentaires

Le code suivant illustre la relation étroite entre les re-tranchés slices :

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

Sortie :

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

Cela démontre que la modification des éléments de la tranche d affecte directement les éléments de la tranche c, confirmant que les deux tranches partagent les mêmes données sous-jacentes.

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!