Warum verringert das erneute Schneiden eines Go-Slices nicht immer seine Kapazität?

Slices in Golang neu aufteilen

In Go bieten Slices eine flexible Möglichkeit, Sammlungen von Elementen zu verwalten. Während das Erstellen und Zugreifen auf Slices unkompliziert ist, kann es schwierig sein, das Verhalten beim erneuten Slicen zu verstehen. Sehen wir uns einen Codeausschnitt an, der dieses Konzept veranschaulicht:

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

Dieser Code erstellt ein Segment a mit einer Länge von 5 und einer Kapazität von 5, gefolgt von zwei Segmenten b und c mit Längen und Kapazitäten von 0 und 2 bzw. Slice d wird dann als Re-Slice von c mit einem Startindex von 2 und einem Endindex von 5 erstellt.

Der verwirrende Teil entsteht, wenn man die Ausgabe betrachtet:

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]

Erneutes Schneiden verstehen

Beim erneuten Schneiden eines Slice ist es wichtig, sich daran zu erinnern Slices sind keine Kopien ihrer zugrunde liegenden Arrays. Stattdessen handelt es sich um Fenster, die auf einen Teil des Arrays verweisen.

• Im Fall von Slice c wird es als Slice der ersten beiden Elemente von Slice b erstellt. Da b eine Kapazität von 5 hat, kann Slice c um die verbleibenden drei Elemente erweitert werden. Deshalb bleibt seine Kapazität bei 5.
• Slice d wird dann als Re-Slice von c mit einem Startindex von 2 erstellt. Das bedeutet, dass d auf die Elemente von b im Bereich von [2, 5). Da in diesem Bereich nur noch drei Elemente übrig sind, beträgt die Länge von d 3 und seine Kapazität 3 (da es Teil eines größeren Slice mit einer Gesamtkapazität von 5 ist).

Weitere Erläuterungen

Der folgende Code veranschaulicht die enge Beziehung zwischen re-sliced 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)
}

Ausgabe:

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

Dies zeigt, dass sich die Änderung der Elemente von Slice d direkt auf die Elemente von Slice c auswirkt, was bestätigt, dass beide Slices gemeinsam sind die gleichen zugrunde liegenden Daten.

Das obige ist der detaillierte Inhalt vonWarum verringert das erneute Schneiden eines Go-Slices nicht immer seine Kapazität?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!