What is the difference between := and = in Go?

Question

I am new to Go programming language.

I noticed something strange in Go: I thought that it used := and substitutes = in Python, but when I use = in Go it is also works.

What is the difference between := and =?

Answer 1

= is assignment. more about assignment in Go: Assignments

the subtly difference between = and := is when = used in variable declarations.

General form of variable declaration in Go is:

var name type = expression

the above declaration creates a variable of a particular type, attaches a name to it, and sets its initial value. Either the type or the = expression can be omitted, but not both.

For example:

var x int = 1
var a int
var b, c, d = 3.14, "stackoverflow", true

:= is called short variable declaration which takes form

name := expression

and the type of name is determined by the type of expression

Note that: := is a declaration, whereas = is an assignment

So, a short variable declaration must declare at least one new variable. which means a short variable declaration doesn't necessarily declare all the variables on its left-hand side, when some of them were already declared in the same lexical block, then := acts like an assignment to those variables

For example:

 r := foo()   // ok, declare a new variable r
 r, m := bar()   // ok, declare a new variable m and assign r a new value
 r, m := bar2()  //compile error: no new variables

Besides, := may appear only inside functions. In some contexts such as the initializers for "if", "for", or "switch" statements, they can be used to declare local temporary variables.

More info:

variable declarations

short variable declarations

Answer 2

Inside a function, the := short assignment statement can be used in place of a var declaration with implicit type.

for example:

package main

import "fmt"

func main() {
    var i, j int = 1, 2
    k := 3
    c, python, java := true, false, "no!"

    fmt.Println(i, j, k, c, python, java)
}

NOTICE: the variable declared with := can only be used inside the function block.

Answer 3

:= is the "short declaration form" for declaring and initializing variables. It does type inference on the value that you are assigning to set the variable's type.

If you attempt to assign with the short declaration form to the same variable in the same scope, the compiler will throw an error.

Be on the lookout for the short declaration form "shadowing" the same variable in an enclosing scope (especially with errors)

= requires the var keyword when declaring a variable and the variable's type explicitly following the variable name. You can actually leave the = off the declaration since Go has a initial value for all types (strings are initialized as "", ints are 0, slices are empty slices). It can also be used for reassignment with just a value, ie

var s string = "a string" // declared and initialized to "a string"
s = "something else"      // value is reassigned

var n int // declared and initialized to 0
n = 3

Answer 4

= is just assignment

:= is declare-and-initialize construct for new vars (at least one new var) inside the function block (not global):

var u1 uint32      //declare a variable and init with 0
u1 = 32            //assign its value
var u2 uint32 = 32 //declare a variable and assign its value at once
//declare a new variable with defining data type:
u3 := uint32(32)        //inside the function block this is equal to: var u3 uint32 = 32
fmt.Println(u1, u2, u3) //32 32 32
//u3 := 20//err: no new variables on left side of :=
u3 = 20
fmt.Println(u1, u2, u3) //32 32 20
u3, str4 := 100, "str"        // at least one new var
fmt.Println(u1, u2, u3, str4) //32 32 100 str

Answer 5

I took time to figure out a mistake I made that could help you to clarify the difference between := and =. Consider the following code:

type mystruct struct {
    a int
    arr []int
}

func main() {   
    m := mystruct{}
    m.arr := make([]int, 5) //compilation error because m.arr is already declared.
    m.arr = make([]int, 5)  //compiles

}