Wann erstellt die append()-Funktion von Go ein neues Slice?

Wann erstellt Gos Append() ein neues Slice?

Die append()-Funktion der Go-Sprache wird zum Erweitern bestehender Slices verwendet. Laut der integrierten API-Dokumentation erstellt append() möglicherweise ein neues Slice mit einer größeren Kapazität, wenn die Kapazität des ursprünglichen Slice nicht ausreicht.

Dieses Verhalten wirft jedoch Fragen auf, wenn es im Kontext rekursiver Algorithmen betrachtet wird. Insbesondere generiert der folgende Algorithmus Kombinationen eines Alphabets:

<code class="go">package main

import (
    "fmt"
)

func AddOption(c chan []bool, combo []bool, length int) {
    if length == 0 {
        fmt.Println(combo, "!")
        c <- combo
        return
    }
    var newCombo []bool
    for _, ch := range []bool{true, false} {
        newCombo = append(combo, ch)
        AddOption(c, newCombo, length-1)
    }
}

func main() {
    c := make(chan []bool)
    go func(c chan []bool) {
        defer close(c)
        AddOption(c, []bool{}, 4)
    }(c)
    for combination := range c {
        fmt.Println(combination)
    }
}</code>

In diesem Code fügt die AddOption-Funktion rekursiv Mitglieder eines Alphabets zu einem Slice hinzu und sendet das Ergebnis über einen Kanal. Beobachtungen zeigen jedoch, dass in den Kanal gesendete Slices nach dem Senden geändert werden.

Der Widerspruch entsteht, weil die Dokumentation vorschlägt, dass append() ein neues Slice zurückgeben sollte, das Verhalten im Code jedoch etwas anderes impliziert. In diesem Artikel wird der zugrunde liegende Mechanismus von append() untersucht und erläutert, wann ein neues Slice erstellt wird.

Slice-Darstellung verstehen

Um das Verhalten von append() zu verstehen, ist es entscheidend, um die interne Darstellung eines Slice zu verstehen. Ein Slice ist trotz seines eigenständigen Erscheinungsbilds keine in sich geschlossene Datenstruktur. Stattdessen besteht er aus einem Deskriptor, der auf ein zugrunde liegendes Array der tatsächlichen Daten verweist.

Der Slice-Deskriptor besteht aus drei Komponenten:

1. Länge: Die Anzahl der Elemente, die sich derzeit im Slice befinden .
2. Kapazität: Die Anzahl der Elemente, die das zugrunde liegende Array aufnehmen kann.
3. Datenzeiger: Ein Zeiger auf das erste Element des zugrunde liegenden Arrays.

Rückgabewert von Append()

Wenn append() verwendet wird, erstellt die Funktion einen neuen Slice-Deskriptor mit eigener Länge, Kapazität und eigenem Datenzeiger. Dies steht im Einklang mit der Dokumentation, in der es heißt, dass append() „[s] neu zuordnet und[e] in einen neuen Array-Block kopiert.“

Dies wirft jedoch eine andere Frage auf: Warum werden Änderungen am Slice vorgenommen? Deskriptor, nachdem er in den Kanal gesendet wurde, im ursprünglichen Slice bestehen bleibt?

Grundlegendes zur gemeinsamen Referenz

Der Schlüssel zur Lösung dieses Problems liegt darin, die Natur des Datenzeigers im zu verstehen Slice-Deskriptor. Dieser Zeiger erstellt keine Kopie der zugrunde liegenden Daten; es zeigt auf die gleichen Daten wie das ursprüngliche Slice.

Wenn append() auf ein Slice angewendet wird, bleibt der Datenzeiger zwar derselbe, obwohl ein neuer Slice-Deskriptor erstellt wird. Dies bedeutet, dass alle an den Elementen eines Slice-Deskriptors vorgenommenen Änderungen in beiden Slices widergespiegelt werden, unabhängig davon, wo die Änderungen auftreten.

Demonstration

Zur Veranschaulichung dieses Konzepts Beachten Sie den folgenden Codeausschnitt:

<code class="go">package main

import "fmt"

func main() {
    s := make([]int, 0, 5)
    s = append(s, []int{1, 2, 3, 4}...)

    a := append(s, 5)
    fmt.Println(a)

    b := append(s, 6)
    fmt.Println(b)
    fmt.Println(a)
}</code>

Wenn dieser Code ausgeführt wird, wird Folgendes ausgegeben:

<code class="go">package main

import (
    "fmt"
)

func AddOption(c chan []bool, combo []bool, length int) {
    if length == 0 {
        fmt.Println(combo, "!")
        c <- combo
        return
    }
    var newCombo []bool
    for _, ch := range []bool{true, false} {
        newCombo = append(combo, ch)
        AddOption(c, newCombo, length-1)
    }
}

func main() {
    c := make(chan []bool)
    go func(c chan []bool) {
        defer close(c)
        AddOption(c, []bool{}, 4)
    }(c)
    for combination := range c {
        fmt.Println(combination)
    }
}</code>

In diesem Beispiel teilen beide Slices a und b zunächst dieselben zugrunde liegenden Daten. Wenn b jedoch ein neuer Wert zugewiesen wird, wird ein neues zugrunde liegendes Datenarray erstellt und der Datenzeiger von b wird aktualisiert, um darauf zu zeigen. Da a immer noch auf denselben Datenzeiger verweist, greift es weiterhin auf das alte Datenarray zu.

Durch Ändern der Slice-Kapazität kann gezeigt werden, dass Slices tatsächlich die zugrunde liegenden Daten gemeinsam nutzen, wenn die Kapazität ausreicht, um eine Neuzuweisung zu vermeiden.

Fazit

Gos append()-Funktion weist einen neuen Slice-Deskriptor zu, behält aber einen Verweis auf das ursprüngliche Datenarray bei. Das bedeutet, dass Änderungen an Slices innerhalb eines rekursiven Algorithmus in allen Slices sichtbar sind, die dieselbe Datenreferenz haben. Das Verständnis dieses Verhaltens ist entscheidend für die effektive Arbeit mit Slices in Go.

Das obige ist der detaillierte Inhalt vonWann erstellt die append()-Funktion von Go ein neues Slice?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!