¿por qué el error global no se pánico después de la inicialización?

Al inicializar una variable de error global, puede parecer sin cambios a las funciones dentro del mismo paquete. Esta discrepancia surge de un malentendido del alcance variable.

Scoping and Initialization

En su primer ejemplo, usa: = para inicializar tanto F como loaderr dentro de la función principal:

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

Esta línea crea una nueva variable local para F y Loaderr. No modifica las variables globales definidas fuera de la función. Por lo tanto, cuando llama a CheckErr (), Loaderr todavía es nulo porque no se ha establecido en ningún lugar dentro del alcance de la función principal.

configurando la variable global

en su segundo ejemplo, usa = para establecer el valor de Loaderr al error devuelto por Os.open ():

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

mediante el uso =, está asignando explícitamente el valor de la variable ERR local a la variable de carga global. Esto permite que la función checkerr () acceda a la variable global modificada y active el pánico.

evitando la sombra

para evitar que creen inadvertidamente variables locales que sombra de variables globales, es importante declarar variables globales explícitamente antes de asignar un valor. En el primer ejemplo, puede declarar Loaderr como una variable global fuera de la función principal moviendo su definición:

var Loaderr Error func Main () { _, Loaderr = OS.open ("astasd") Si loaderr! = nil { checkerr () } Si f! = nil { fmt.println (f.name ()) } }

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

Esto garantiza que la variable de carga global sea accesible y actualizada en todo el programa.