Warum führt das erneute Slicen eines Go-Slices zu unerwarteten Kapazitätswerten?

Erneutes Schneiden von Slices in Golang

Das Verhalten von Slices zu verstehen kann verwirrend sein, insbesondere wenn es um das erneute Slicen geht. In diesem Snippet:

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

Die Ausgabe zeigt ein unerwartetes Ergebnis:

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]

Warum hat c eine Kapazität von 5 und nicht von 2? Um dies zu beantworten, müssen wir das Konzept der Slices in Golang verstehen.

Slices sind leichte Verweise auf Arrays. Wenn wir ein Slice erstellen, stellen wir eine Bereichsoperation (z. B. [:2]) bereit, um die Start- und Endindizes des referenzierten Arrays anzugeben. Diese Bereichsoperation erstellt jedoch keine Kopie des zugrunde liegenden Arrays. Stattdessen wird ein neues Slice erstellt, das dieselben zugrunde liegenden Daten teilt.

Im gegebenen Beispiel ist b ein leeres Slice mit einer Kapazität von 5. Wenn wir c als Slice von b mit einem Bereich von [ erstellen :2] erstellen wir im Wesentlichen einen Verweis auf die ersten beiden Elemente von b. Da b eine Kapazität von 5 hat, kann c möglicherweise auf bis zu 5 Elemente erweitert werden, auch wenn derzeit nur auf 2 Elemente verwiesen wird. Aus diesem Grund hat c trotz seiner Länge von 2 eine Kapazität von 5.

Wenn wir außerdem d als Teil von c mit einem Bereich von [2:5] erstellen, erstellen wir effektiv einen Teil, der geteilt wird die gleichen zugrunde liegenden Daten wie b, jedoch beginnend mit Index 2 und erweitert bis Index 5. Da b eine Kapazität von 5 hat, hat d eine Kapazität von 3 (5-2).

Das folgende Programm veranschaulicht dieses Verhalten deutlicher:

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

Ausgabe:

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

Wie Sie sehen können, hat die Änderung von d auch c geändert, was zeigt, dass c und d beide Fenster über demselben Basiswert sind Array, b.

Das obige ist der detaillierte Inhalt vonWarum führt das erneute Slicen eines Go-Slices zu unerwarteten Kapazitätswerten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!