Pièges courants des fermetures de fonctions Golang

Il existe des pièges lors de l'utilisation des fermetures de fonctions dans Go : Partage de variables : modifier la variable lorsque plusieurs fermetures font référence à la même variable affectera le comportement de toutes les fermetures. Conversion de type de variable : la conversion ultérieure d'un type de variable de capture en un autre type peut conduire à des résultats imprévisibles. En pratique, le problème des fermetures de fonctions générant des séquences peut être résolu en créant une copie des variables locales pour chaque fermeture afin d'éviter de modifier les variables capturées.

Pièges courants des fermetures de fonctions en Go

En Go, une fermeture est une fonction qui fait référence à une variable locale au moment de sa création. Il peut offrir de la flexibilité au programme, mais s'il est utilisé incorrectement, il peut également introduire un comportement inattendu et des problèmes difficiles à déboguer.

Pièges de fermeture

Voici quelques pièges de fermeture de fonction courants :

1. Partage de variable

Lorsque plusieurs fermetures font référence à la même variable locale, la modification de la variable affectera le comportement de toutes les fermetures. Par exemple :

func counter() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

// 两个同时调用的闭包共享计数变量
c1 := counter()
c2 := counter()
c1()
c2()

entraînerait la valeur renvoyée à 2 au lieu des 1 et 2 attendus.

2. Conversion de type de variable

Closure capture le type d'une variable. Si le type de variable est ensuite converti en un autre type, cela peut conduire à des résultats imprévisibles. Par exemple :

func intToString() string {
    i := 42
    return func() string {
        // 会返回一个空字符串，而不是 "42"
        return strconv.Itoa(i)
    }
}

Parce que la variable que j'ai capturée par la fermeture est convertie en type chaîne, strconv.Itoa() ne peut pas être convertie correctement.

Cas pratique

Attente : Créer une fonction qui génère une séquence basée sur les nombres transmis jusqu'à ce que la valeur maximale soit atteinte.

Code :

func generateSequence(max int) []int {
    seq := []int{}
    i := 0
    return func() int {
        i++
        if i > max {
            return 0
        }
        seq = append(seq, i)
        return i
    }
}

Problème : La fermeture de cette fonction capture la variable i et la modifie lorsque la fermeture est appelée. Cependant, nous nous attendons à ce que la fermeture renvoie une nouvelle valeur i à chaque fois qu'elle est appelée.

Correction : Ce problème peut être résolu en créant une copie de la variable locale pour chaque fermeture.

func generateSequence(max int) []int {
    seq := []int{}
    return func() int {
        i := 0
        i++
        if i > max {
            return 0
        }
        seq = append(seq, i)
        return i
    }
}

Remarque : Le code fixe ne modifiera plus la variable i capturée, mais créera une nouvelle copie à chaque fois.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!