Slices in Go: Verwirrung und Klarheit

In GO sind Scheiben ein leistungsstarker und effizienter Weg, um Arrays von Daten darzustellen. Das Verständnis ihrer Feinheiten kann jedoch für Anfänger eine Herausforderung sein. Ein solcher Aspekt ist das Konzept des Umverlösens von Scheiben.

Betrachten Sie den folgenden Code:

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

Das Programm erstellt vier Scheiben: a, b, c und d. Das überraschende Ergebnis ist, dass Slice C, das als Stück der ersten beiden Elemente von B erstellt wurde, eine Kapazität von 5 anstelle von 2. . In Go speichern Scheiben die tatsächlichen Daten nicht. Vielmehr verweisen sie auf ein zugrunde liegendes Array. Wenn eine Scheibe erstellt wird, zeigt es auf ein Segment dieses zugrunde liegenden Arrays.

In dem obigen Beispiel, wenn B mit einer Länge von 0 erstellt wird, aber eine Kapazität von 5, behält sich 5 Slots in einem zugrunde liegenden Array vor . Wenn Slice C aus B erzeugt wird, wird es zu einem Fenster über die ersten beiden Elemente von b. Das zugrunde liegende Array und damit die Kapazität von C bleibt jedoch 5, einschließlich der nicht verwendeten Slots in b.

Dieses Konzept der Umstellung wird weiter veranschaulicht, indem der Code geringfügig geändert wird:

func hauptsächlich() { B: = make ([] int, 0, 5) C: = B [: 2] D: = C [1: 5] // Dies entspricht D: = B [1: 5] D [0] = 1 printslice ("c", c) printslice ("d", d) }

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