Null-Slice, Nicht-Null-Slice, leeres Slice in der Go-Sprache

Der PHP-Editor Xiaoxin bietet Ihnen eine Einführung in den Slice-Typ in der Go-Sprache. In der Go-Sprache haben Slices drei Zustände: Null-Slice, Nicht-Null-Slice und leeres Slice. Diese drei Schnittzustände haben bei ihrer Verwendung unterschiedliche Bedeutungen und Eigenschaften. Das Verständnis der Unterschiede zwischen diesen Slice-Typen wird uns helfen, die Slice-Funktion in der Go-Sprache besser zu verstehen und zu verwenden. Lassen Sie uns als Nächstes die spezifischen Funktionen und Verwendungszwecke dieser drei Slice-Typen untersuchen.

Frageninhalt

Ich bin neu in der Go-Programmierung. Ich habe in einem Go-Programmierbuch gelesen, dass ein Slice aus drei Teilen besteht: einem Zeiger auf das Array, der Länge und der Kapazität.

Ich bin über Folgendes verwirrt:

• nil-Slice (das Slice hat kein zugrunde liegendes Array, auf das gezeigt wird, len = 0, cap=0)
• Nur Nicht-Null-Slices mit len ​​= 0, cap = 0
• Leere Scheibe.

Kann mir jemand sagen, ob Null und leeres Slice dasselbe sind? Wenn beide unterschiedlich sind, sagen Sie mir bitte, was der Unterschied zwischen diesen beiden ist. Wie teste ich, ob ein Slice leer ist? Welchen Wert hält ein Zeiger außerdem in einem Slice ungleich Null mit einer Länge und Kapazität von Null?

Workaround

Beobachtbares Verhalten

nil ist nicht dasselbe wie ein leeres Slice (Kapazität 0), aber ihr beobachtbares Verhalten ist dasselbe (fast immer). Was ich meine ist:

• Sie können sie an integrierte len() 和 cap() Funktionen
übergeben
• Sie können for range sie überschreiben (es werden 0 Iterationen sein)
• Sie können sie segmentieren (solange dies nicht gegen die in Spezifikation: Slicing-Ausdrücke beschriebenen Einschränkungen verstößt; das Ergebnis ist also auch ein leeres Slice)
• Da sie die Länge 0 haben, können Sie ihren Inhalt nicht ändern (durch das Anhängen eines Werts wird ein neuer Slice-Wert erstellt)

Sehen Sie sich dieses einfache Beispiel an (ein nil 切片和 2 个非 nil Slice und 2 nicht

leere Slices):

var s1 []int         // nil slice
s2 := []int{}        // non-nil, empty slice
s3 := make([]int, 0) // non-nil, empty slice

fmt.Println("s1", len(s1), cap(s1), s1 == nil, s1[:], s1[:] == nil)
fmt.Println("s2", len(s2), cap(s2), s2 == nil, s2[:], s2[:] == nil)
fmt.Println("s3", len(s3), cap(s3), s3 == nil, s3[:], s3[:] == nil)

for range s1 {}
for range s2 {}
for range s3 {}

Ausgabe (versuchen Sie es auf Go Playground

):

s1 0 0 true [] true
s2 0 0 false [] false
s3 0 0 false [] false

nil 切片进行切片会生成 nil 切片，对非 nil 切片进行切片会生成非 nil (Beachten Sie, dass das Schneiden einer

-Scheibe eine

-Scheibe erzeugt und das Schneiden einer Nicht-nil 进行比较来区分，它们在其他方面的行为都是相同的。 但请注意，许多软件包确实会将切片与 nil 进行比较，并且可能会基于此进行不同的操作（例如 encoding/ json 和 fmt-Scheibe eine Nicht--Scheibe erzeugt.)

Mit der Ausnahme, dass Sie den Unterschied nur erkennen können, indem Sie einen Slice-Wert mit einem vorab deklarierten Bezeichner vergleichen

, verhalten sie sich ansonsten identisch. Beachten Sie jedoch, dass viele Pakete Slices mit vergleichen und auf dieser Grundlage möglicherweise anders vorgehen (z. B. encoding/ json und fmt Paket). nil 切片转换为数组指针将生成非 nil 指针，将 nil 切片转换为数组指针将生成 nil

Der einzige Unterschied besteht in der

Konvertierung von Slices in Array-Zeiger0 进行比较：len(s) == 0。无论它是 nil 切片还是非 nil (in

Go 1.17 zur Sprache hinzugefügt

). Das Konvertieren eines Nicht--Slice in einen Array-Zeiger erzeugt einen Nicht--Zeiger, und das Konvertieren eines

-Slice in einen Array-Zeiger erzeugt einen

-Zeiger.

Um festzustellen, ob ein Slice leer ist, vergleichen Sie einfach seine Länge mit 0: len(s) == 0. Ob es sich um ein -Slice oder ein Nicht-reflect.SliceHeader-Slice handelt, es spielt keine Rolle, ob es eine positive Kapazität hat; wenn es keine Elemente hat, ist es leer.

s := make([]int, 0, 100)
fmt.Println("Empty:", len(s) == 0, ", but capacity:", cap(s))

Drucken (versuchen Sie es auf

Go Playgroundnil 切片，该结构将具有其零值，即其所有字段都将为零值，即：0):

Empty: true , but capacity: 100

Untere Schichtnil 切片的容量和长度等于 0、Len 和 Cap 字段，则很可能是 0，但 Data 指针可能不是。它不会，这就是它与 nil

Slice-Werte werden durch die in

definierte Struktur dargestellt:

type SliceHeader struct {
    Data uintptr
    Len  int
    Cap  int
}

🎜Für ein 🎜-Slice hat die Struktur ihren Nullwert, d. h. alle ihre Felder haben den Nullwert, d. h.: 0. 🎜 🎜Wenn die Kapazität und Länge des Nicht-🎜-Slices den Feldern 0, Len und Cap entsprechen, dann handelt es sich höchstwahrscheinlich um 0 , der Data-Zeiger jedoch möglicherweise nicht. Das ist nicht der Fall, das ist der Unterschied zu 🎜 Scheiben. Es zeigt auf ein zugrunde liegendes Array der Größe Null. 🎜 🎜Bitte beachten Sie, dass die Go-Spezifikation zulässt, dass Werte unterschiedlichen Typs mit der Größe 0 dieselbe Speicheradresse haben. 🎜Spezifikationen: Systemhinweise: Größen- und Ausrichtungsgarantien: 🎜🎜

让我们检查一下。为此，我们调用 unsafe 包的帮助，并“获取” reflect.SliceHeader 结构“视图” “我们的切片值：

var s1 []int
s2 := []int{}
s3 := make([]int, 0)

fmt.Printf("s1 (addr: %p): %+8v\n",
    &s1, *(*reflect.SliceHeader)(unsafe.Pointer(&s1)))
fmt.Printf("s2 (addr: %p): %+8v\n",
    &s2, *(*reflect.SliceHeader)(unsafe.Pointer(&s2)))
fmt.Printf("s3 (addr: %p): %+8v\n",
    &s3, *(*reflect.SliceHeader)(unsafe.Pointer(&s3)))

输出（在 Go Playground 上尝试一下）：

s1 (addr: 0x1040a130): {Data:       0 Len:       0 Cap:       0}
s2 (addr: 0x1040a140): {Data: 1535812 Len:       0 Cap:       0}
s3 (addr: 0x1040a150): {Data: 1535812 Len:       0 Cap:       0}

我们看到了什么？

• 所有切片（切片头）都有不同的内存地址
• nil 切片具有 0 数据指针
• s2 和 s3 切片确实具有相同的数据指针，共享/指向相同的 0 大小的内存值

Das obige ist der detaillierte Inhalt vonNull-Slice, Nicht-Null-Slice, leeres Slice in der Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!