Problème \'scopelint\' de Go : comment gérez-vous les variables de boucle dans les littéraux de fonction ?

Portée des variables et littéraux de fonction dans Go : comprendre le problème du "scopelint"

Dans le code Go, il est parfois nécessaire d'utiliser des variables définies dans les instructions range dans les littéraux de fonction. Cependant, cela peut déclencher une erreur de charpie : "Utilisation de la variable sur la portée x dans la fonction littérale (scopelint)". Cette erreur se produit car Go nécessite une attention particulière à la portée de la variable, en particulier lorsque vous travaillez avec des littéraux de fonction.

L'erreur "Utilisation de la variable sur la portée x dans le littéral de fonction" indique qu'un littéral de fonction (fonction anonyme) est passé comme un paramètre d'une fonction intégrée comme t.Run fait référence à une variable (ici, x) qui se trouve dans la portée de la plage. Étant donné que les variables de boucle sont disponibles par valeur uniquement, il est possible que le littéral de fonction accède à une valeur obsolète de la variable.

Considérons l'exemple suivant :

func TestGetUID(t *testing.T) {
    namespace := "lkfm"
    expecteduid := "fake_uid"
    var tests = []struct {
        description string
        expected    string
        namespace   string
        objs        []runtime.Object
    }{
        {"PositiveScenario", expecteduid, namespace, []runtime.Object{simpleNamespace(namespace)}},
    }

    for _, x := range tests {
        t.Run(x.description, func(t *testing.T) {
            client := fake.NewSimpleClientset(x.objs...)
            actual := getUID(client, x.namespace)
            assert.Equal(t, x.expected, actual)
        })
    }
}

Dans cet exemple, le La variable de boucle x est utilisée dans le littéral de fonction transmis à t.Run. Le compilateur ne peut pas garantir que la fonction littérale ne sera pas exécutée une fois la boucle terminée et la valeur de x modifiée. Cette inadéquation potentielle entre la valeur prévue et la valeur réelle de x peut conduire à un comportement imprévisible.

Pour résoudre ce problème, Go fournit un mécanisme permettant de capturer la valeur de la variable de boucle dans une nouvelle portée. Ceci peut être réalisé en créant une copie de la variable ou en la passant comme argument au littéral de la fonction. Par exemple, le code ci-dessus peut être réécrit comme suit :

func TestGetUID(t *testing.T) {
    namespace := "lkfm"
    expecteduid := "fake_uid"
    var tests = []struct {
        description string
        expected    string
        namespace   string
        objs        []runtime.Object
    }{
        {"PositiveScenario", expecteduid, namespace, []runtime.Object{simpleNamespace(namespace)}},
    }

    for _, test := range tests {
        namespaceCopy := test.namespace
        t.Run(test.description, func(t *testing.T) {
            client := fake.NewSimpleClientset(test.objs...)
            actual := getUID(client, namespaceCopy)
            assert.Equal(t, test.expected, actual)
        })
    }
}

En copiant la valeur de test.namespace dans une nouvelle variable namespaceCopy, nous nous assurons que la fonction littérale a accès à une valeur constante d'espace de noms. Cela élimine le risque d'incohérence des données et garantit que le comportement du littéral de fonction est prévisible.

En résumé, lors de l'utilisation de variables de boucle dans des littéraux de fonction, il est important d'examiner attentivement la portée de la variable et les problèmes potentiels liés à la variable. durées de vie. En utilisant les techniques décrites ci-dessus, les développeurs peuvent garantir que leur code est sûr et fiable.

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!