Wie geht Go mit erfassten Schleifenvariablen in Abschlüssen um und warum ist das wichtig?

Erfasster Abschluss (für Schleifenvariable) in Go

Grundlegendes zum Abschluss von Schleifenvariablen

In Go kann der Compiler automatisch Schleifenvariablen zur Verwendung darin erfassen Schließungen, aber dieses Verhalten variiert je nach Art der Schleife. In for...range-Schleifen werden die Schleifenvariablen als Referenzen auf die Iterationsvariablen der äußeren Schleife erfasst.

Grund für Referenzabschlüsse in for...range-Schleifen

Go treats for.. .range-Schleifen und andere for-Schleifen auf ähnliche Weise. Daher verweist der erfasste Abschluss für eine Schleifenvariable in einer for...range-Schleife auf denselben Speicherort wie die Variable der äußeren Schleife.

Konsequenzen von Referenzabschlüssen

In diesem Szenario werden alle Änderungen vorgenommen Änderungen an der Variablen des erfassten Abschlusses wirken sich auch auf die Variable der äußeren Schleife aus und führen möglicherweise zu unerwartetem Verhalten. Um dieses Problem zu vermeiden, ist es notwendig, eine Kopie der Schleifenvariablen innerhalb des Abschlusses zu erstellen, wie im Beispiel „Wert...Bereich“ unten gezeigt.

Beispielcode

Der bereitgestellte Code Das Snippet veranschaulicht den Unterschied zwischen der Erfassung einer Referenz auf die Schleifenvariable und der Erfassung derselben Wert:

func main() {
    lab1() // captured closure is not what is expected

    lab2() // captured closure is not what is expected

    lab3() // captured closure behaves ok
}

func lab3() {
    m := make(map[int32]int32)
    for i := 1; i <= 10; i++ {
        m[i] = i
    }

    l := [](func() (int32, int32)){}
    for k, v := range m {
        kLocal, vLocal := k, v // (C) captures just the right values assigned to k and v
        l = append(l, func() (int32, int32) {
            return kLocal, vLocal
        })
    }

    for _, x := range l {
        k, v := x()
        fmt.Println(k, v)
    }
}

func lab2() {
    m := make(map[int32]int32)
    for i := 1; i <= 10; i++ {
        m[i] = i
    }

    l := [](func() (int32, int32)){}
    for k, v := range m {
        l = append(l, func() (int32, int32) {
            kLocal, vLocal := k, v // (B) captures just the last values assigned to k and v from the range
            return kLocal, vLocal
        })
    }

    for _, x := range l {
        k, v := x()
        fmt.Println(k, v)
    }
}

func lab1() {
    m := make(map[int32]int32)
    for i := 1; i <= 10; i++ {
        m[i] = i
    }

    l := [](func() (int32, int32)){}
    for k, v := range m {
        l = append(l, func() (int32, int32) { return k, v }) // (A) captures just the last values assigned to k and v from the range
    }

    for _, x := range l {
        k, v := x()
        fmt.Println(k, v)
    }
}

Ausgabe

In lab1 verweisen die erfassten Abschlüsse auf die Endwerte aus der Schleife statt auf die erwarteten Einzelwerte. In Lab2 verweisen die Captures weiterhin auf die endgültigen Werte, da der erstellte Abschluss dieselben Schleifenvariablen verwendet, auf die an anderer Stelle im äußeren Bereich verwiesen wird. In lab3 erfassen die Abschlüsse Kopien der Schleifenvariablen, sodass sie die einzelnen Werte genau darstellen.

Das obige ist der detaillierte Inhalt vonWie geht Go mit erfassten Schleifenvariablen in Abschlüssen um und warum ist das wichtig?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!