multiple - golang version command
Diferencia del operador de Golang entre:=vs= (9)
En Go, ¿cuál es la diferencia entre el operador = y := ? ¿Ambos parecen ser para asignación? Esto podría ser obvio, pero parece que no puedo encontrarlo en los documentos.
": =" Use para hacer la declaración y la inicialización al mismo tiempo, a continuación se muestra un ejemplo.
Uso de "="
var i int
i = 10
https://play.golang.org/p/RU88ty_SGa
Uso de ": ="
i: = 10
Ambas son las diferentes técnicas de declaración de variables en el lenguaje Go.
var firstName := "John" // is a variable declaration
Y
firstName := "John" // is a short variable declaration.
Una declaración de variable corta es una abreviatura de una declaración de variable regular con expresiones de inicializador pero sin tipos.
Lea a continuación para obtener más detalles:
Como otros ya han explicado,: := es para la declaración y la asignación, e intenta adivinar ( inferir ) el tipo de la variable automáticamente.
Es una forma abreviada de:
var foo int
foo = 32
// OR:
var foo int = 32
// OR:
var foo = 32
Algunas reglas
No puede usar := fuera de funcs .
illegal := 42
func foo() {
legal := 42
}
No puedes usarlos dos veces:
legal := 42
legal := 42 // <-- error
Porque := introduce "una nueva variable" , por lo que usarla dos veces no redeclara una segunda variable, por lo que es ilegal.
Sin embargo, puede usarlos dos veces en declaraciones "multi-variable" , si una de las variables es nueva :
foo, bar := someFunc()
foo, jazz := someFunc() // <-- jazz is new
baz, foo := someFunc() // <-- baz is new
Esto es legal, porque, no está redeclarando variables, solo está reasignando nuevos valores a las variables existentes, con algunas variables nuevas.
Puede usarlos si una variable ya declaró con el mismo nombre antes:
var foo int = 34
func some() {
// because foo here is scoped to some func
foo := 42 // <-- legal
foo = 314 // <-- legal
}
Aquí, foo := 42 es legal, porque redeclara foo en el ámbito de some() func. foo = 314 es legal, porque, simplemente reasigna un nuevo valor a foo .
_
Puede usarlos para declaraciones y asignaciones de variables múltiples:
foo, bar := 42, 314
jazz, bazz := 22, 7
_
Puede reutilizarlos en contextos de sentencias con ámbito como: if , for , switch :
foo := 42
if foo := someFunc(); foo == 314 {
// foo is scoped to 314 here
// ...
}
// foo is still 42 here
Porque, if foo := ... asignación, solo accesible a esa cláusula if .
Por lo tanto, como regla general: a menos que esté redeclarando una variable, puede usar := o, si desea sobrescribir un valor existente, puede usar = .
El: = significa declarar y asignar mientras que = significa simplemente asignar.
En Go := es para declaración + asignación, mientras que = es solo para asignación.
Por ejemplo, var foo int = 10 es lo mismo que foo := 10 .
Only = es el operador de asignación.
:= realidad no es un operator en absoluto. Es una parte de la sintaxis de la cláusula de declaraciones de variables cortas .
del documento de referencia: ( tour.golang.org )
Dentro de una función , la instrucción de asignación := short se puede usar en lugar de una declaración var con tipo implícito.
Fuera de una función , cada construcción comienza con una palabra clave (var, func, etc.) y la construcción: = no está disponible.
:= declara y asigna, = simplemente asigna
Es útil cuando no quiere llenar su código con declaraciones de tipo o estructura.
// Usage with =
var i int
var U, V, W float64
var k = 0
var x, y float32 = -1, -2
// Usage with :=
i, j := 0, 10
f := func() int { return 7 }
ch := make(chan int)
:= es una abreviatura de declaración.
a := 10
b := "gopher"
a se declarará como int y se inicializará con el valor 10 donde como b se declarará como una cadena y se inicializará con el valor gopher .
Sus equivalentes usando = serían
var a = 10
var b = "gopher"
= es operador de asignación. Se usa de la misma manera que lo usaría en cualquier otro idioma.
Puede omitir el tipo cuando declara la variable y hay un inicializador presente ( http://tour.golang.org/#11 ).