Diferencia entre: = y = operadores en Go

¿Cuál es la diferencia entre el =y :=los operadores, y cuáles son los casos de uso de ellos? Ambos parecen ser para una tarea?

Solo =es el operador de asignación.

:=es parte de la sintaxis de la cláusula de declaraciones de variables cortas .

Though Sin embargo, hay algunas reglas. Vea esta otra respuesta para más detalles.

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.

Como ya han explicado otros, :=es tanto para la declaración, la asignación y también para la redeclaración; y adivina ( infiere ) el tipo de variable automáticamente.

Por ejemplo, foo := 32es una forma abreviada de:

var foo int
foo = 32

// OR:
var foo int = 32

// OR:
var foo = 32

/ * Hay algunas reglas: * /

★ primera regla:

No se puede utilizar :=fuera de funcs. Es porque, de cualquier función, una declaración debe comenzar con una palabra clave.

// no keywords below, illegal.
illegal := 42

// `var` keyword makes this statement legal.
var legal = 42

func foo() {
  alsoLegal := 42
  // reason: it's in a func scope.
}

★ segunda regla:

No puede usarlos dos veces ( en el mismo alcance ):

legal := 42
legal := 42 // <-- error

Porque, :=introduce "una nueva variable" , por lo tanto, usarla dos veces no declara una segunda variable, por lo que es ilegal.

★ 3ra regla:

Puede usarlos para declaraciones y asignaciones de variables múltiples:

foo, bar   := 42, 314
jazz, bazz := 22, 7

★ 4ta Regla (Redeclaración):

Puede usarlos dos veces en declaraciones "multi-variables" , 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ás declarando todas las variables, solo estás reasignando nuevos valores a las variables existentes y declarando nuevas variables al mismo tiempo. Esto se llama redeclaración .

★ 5ta regla:

Puede usar la declaración breve para declarar una variable en un ámbito más nuevo, incluso si esa variable ya se ha declarado 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 := 42es legal, porque se declara fooen some()el alcance de la función. foo = 314es legal porque simplemente asigna un nuevo valor a foo.

★ sexta regla:

Puede declarar el mismo nombre en bloques de instrucciones breves como: if , for , switch :

foo := 42
if foo := someFunc(); foo == 314 {
  // foo is scoped to 314 here
  // ...
}
// foo is still 42 here

Porque, fooen if foo := ..., solo pertenece a esa ifcláusula y está en un alcance diferente.

Entonces, como regla general: si desea declarar fácilmente una variable que puede usar :=, o, si solo desea sobrescribir una variable existente, puede usarla =.

Referencias

• Reglas de declaración variable corta

• Una guía visual para ir variables

:= es una abreviatura para la declaración.

a := 10
b := "gopher"

aserá declarado como inte inicializado con valor 10donde como bserá declarado como una cadena e inicializado con valorgopher .

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ías en cualquier otro idioma.

Puede omitir el tipo cuando declara la variable y hay un inicializador presente ( http://tour.golang.org/#11 ).

El: = significa declarar y asignar, mientras que el = significa simplemente asignar.

:=declara y asigna, =solo asigna

Es útil cuando no desea 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)

del documento de referencia: ( tour.golang.org )

Dentro de una función , la :=declaración de asignación corta 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.

“: =” Se usa 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

https://play.golang.org/p/XBdjBh-DQB

Ambas son la técnica diferente 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 más detalles:

Declaraciones variables

Declaraciones de variables cortas