Pourquoi la variable d'erreur globale ne panique-t-elle pas après l'initialisation?

Lors de l'initialisation d'une variable d'erreur globale, il peut apparaître inchangé aux fonctions dans le même package. Cette divergence provient d'un malentendu de l'évanouissement variable.

Scoping and Initialisation

Dans votre premier exemple, vous utilisez: = pour initialiser F et Loaderr dans la fonction principale:

func main() {
    f, loadErr := os.Open("asdasd")
    if loadErr != nil {
        checkErr()
    }
    if f != nil {
        fmt.Println(f.Name())
    }
}

Cette ligne crée une nouvelle variable locale pour F et Loaderr. Il ne modifie pas les variables globales définies en dehors de la fonction. Ainsi, lorsque vous appelez CheckerR (), Loaderr est encore nul car il n'a été défini nulle part dans le cadre de la fonction principale.

Définition de la variable globale

Dans votre deuxième exemple, vous utilisez = pour définir la valeur de Loadrr sur l'erreur renvoyée par OS.Open ():

func main() {
    _, err := os.Open("asdasd")
    loadErr = err
    if loadErr != nil {
        checkErr()
    }
}

En utilisant =, vous attribuez explicitement la valeur de la variable ERR locale à la variable Global Loaderr. Cela permet à la fonction checkerr () d'accéder à la variable globale modifiée et de déclencher la panique.

éviter l'observation

pour éviter de créer par inadvertance des variables locales qui ont des variables globales d'ombre, il est important de déclarer des variables globales explicitement avant d'attribuer une valeur. Dans le premier exemple, vous pouvez déclarer Loaderr en tant que variable globale à l'extérieur de la fonction principale en déplaçant sa définition:

var loadErr error

func main() {
    _, loadErr = os.Open("asdasd")
    if loadErr != nil {
        checkErr()
    }
    if f != nil {
        fmt.Println(f.Name())
    }
}

Cela garantit que la variable Global Loaderr est accessible et mise à jour tout au long du programme.