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 declaración como para asignación, e intenta adivinar ( inferir) el tipo de la variable automáticamente.

Es una forma de mano corta de:

var foo int
foo = 32

// OR:
var foo int = 32

// OR:
var foo = 32

Algunas reglas

No puedes usar := fuera de funcs.

illegal := 42

func foo() {
  legal := 42
}

No puedes usarlos dos veces:{[23]]}

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

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

Sin embargo, puede usarlas dos veces en las declaraciones "multivariable", 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 redeclarando variables, solo estás reasignando nuevos valores a las variables existentes, con algunas variables nuevas.

Puede usarlos si una variable ya declarada 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, vuelve a declarar foo en some() el visor de func. foo = 314 es legal, porque, solo reasigna un nuevo valor a foo.

_

Puede usarlos para declaraciones y asignaciones multivariables:

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

_

Puede reutilizarlos en contextos de sentencias con ámbito como: si, para, cambiar :

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 volver a declarar una variable puede usar :=, o, si desea sobrescribir un valor existente, puede usar =.

:= es una abreviatura de declaración.

a := 10
b := "gopher"

a se declarará como un int e inicializado con valor 10 donde as b se declarará como una cadena e inicializado con 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ías en cualquier otro idioma.

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

:= 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)

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

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

Dentro de una función , la instrucció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.

":=" use para hacer declaración e 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

Ambos 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 para una declaración de variable regular con expresiones inicializadoras pero sin tipos.

Lea a continuación para más detalles:

Declaraciones variables

Declaraciones cortas de variables