tipos - ¿Por qué hay dos formas de declarar variables en Go, cuál es la diferencia y cuál usar?

long golang

Question

Según la referencia Go hay dos formas de declarar una variable

Variable_declarations (en el formato de var count = 0 o var count int )
y
Variable_declarations (en el formato de count := 0 )

Encontré que es muy confuso decidir cuál usar.

Las diferencias que conozco (hasta ahora) son que:

• Solo puedo usar un formato count := 0 cuando estoy en el alcance de una función.
• count := 0 puede volver a declarar en una declaración corta multivariable .

Pero se comportan igual que yo sepa . Y en la referencia también Variable_declarations :

Es (la count:=0 vías) es una abreviatura para una declaración de variable regular con expresiones de inicializador pero sin tipos

Mis confusiones son:

• Si uno es solo la forma abreviada del otro, ¿por qué se comportan de manera diferente?
• ¿En qué preocupación el autor de Go crea dos formas de declarar una variable (por qué no se fusionan de una manera)? ¿Solo para confundirnos?
• ¿Hay algún otro aspecto que deba mantener mis ojos abiertos cuando los uso, en caso de que me caiga en un pozo?

Answer 1

Las Variable_declarations dejan claro que las variables están declaradas. La palabra clave var es obligatoria, es breve y expresa lo que se hace (en el nivel de archivo, todo lo que excluye los comentarios debe comenzar con una palabra clave, por ejemplo, package , import , const , type , var , func ). Como cualquier otro bloque, las declaraciones de variables se pueden agrupar así:

var (
count int
sum float64
)

No se puede hacer eso con declaraciones de variables cortas . También puede usar declaraciones de variables sin especificar el valor inicial, en cuyo caso cada variable tendrá el valor cero de su tipo. La declaración de variable corta no permite esto, tiene que especificar el valor inicial.

Uno de los principios de diseño de la guía de Go era limpiar la sintaxis. Muchas declaraciones requieren o es útil que permitan declarar variables locales que solo estarán disponibles en el cuerpo de la declaración, como for , if , switch , etc. No es ambiguo lo que hacen.

for idx, value := range array {
// Do something with index and value
}
if num := runtime.NumCPU(); num > 1 {
fmt.Println("Multicore CPU, cores:", num)
}

Otra diferencia: la redeclaración.

Citando de la especificación del lenguaje:

A diferencia de las declaraciones de variables regulares, una declaración de variable corta puede volver a declarar las variables siempre que hayan sido declaradas originalmente anteriormente en el mismo bloque con el mismo tipo, y al menos una de las variables que no están en blanco es nueva. Como consecuencia, la redeclaración solo puede aparecer en una declaración corta multivariable. La redeclaración no introduce una nueva variable; simplemente asigna un nuevo valor al original.

Este también es útil. Supongamos que desea realizar un manejo adecuado de errores, puede reutilizar una variable de err porque lo más probable es que solo lo necesite para verificar si hubo algún error durante la última llamada a la función:

var name = "myfile.txt"
fi, err := os.Stat(name) // fi and err both first declared
if err != nil {
log.Fatal(err)
}
fmt.Println(name, fi.Size(), "bytes")
data, err := ioutil.ReadFile(name) // data is new but err already exists
// so just a new value is assigned to err
if err != nil {
log.Fatal(err)
}
// Do something with data