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 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 2

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

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 4

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

}

Answer 5

= is used as statically typed.

:= is used as dynamically typed.

example:

var a = 30   # statically typed and is a compile time check

b := 40      # dynamically checked. 

Answer 6

Note the difference in := and = in range clauses as well. The following examples are adapted from the spec.

The iteration variables may be declared by the "range" clause using a form of short variable declaration (:=). In this case their types are set to the types of the respective iteration values and their scope is the block of the "for" statement; they are re-used in each iteration. If the iteration variables are declared outside the "for" statement, after execution their values will be those of the last iteration.

= range ...:

i := 2
x = []int{3, 5, 7}
for i, x[i] = range x {  // i,x[2] = 0,x[0]
    break
}
// now i == 0 and x == []int{3, 5, 3}

var (key string; val interface{})
m := map[string]int{"mon":0, "tue":1, "wed":2, "thu":3, "fri":4, "sat":5, "sun":6}
for key, val = range m {
    h(key, val)
}
// key == last map key encountered in iteration (note order of map iteration is random)
// val == map[key]

---

:= range ...:

var a [10]string
for i, s := range a {
    // type of i is int, type of s is string
    // s == a[i]
    someFunction(i, s)
}
// i and s are no longer accessible here.

for i := range a { // roughly equivalent to `for i := 0; i < len(a); i++`
    someFunction(i, a[i])
}

for _, s := range a {
    anotherFunc(s)
}
// Above is roughly equivalent to:
{
    var s string
    for i := 0; i < len(a); i++ {
         s = a[i]
         anotherFunc(s)
    }
}
// s not accessible here

Answer 7

The most verbose way to declare a variable in Go uses the var keyword, an explicit type, and an assignment.

var x int = 10

Go also supports a short declaration format. When you are within a function, you can use the := operator to replace a var declaration that uses type inference.

var x = 10
x := 10

There is one limitation on :=. If you are declaring a variable at package level, you must use var because := is not legal outside of functions.

There are some situations within functions where you should avoid :=

• When initializing a variable to its zero value, use var x int. This makes it clear that the zero value is intended.
• When assigning an untyped constant or a literal to a variable and the default type for the constant or literal isn’t the type you want for the variable, use the long var form with the type specified. While it is legal to use a type conversion to specify the type of the value and use := to write x := byte(20), it is idiomatic to write var x byte = 20.
• Because := allows you to assign to both new and existing variables, it sometimes creates new variables when you think you are reusing existing ones. In those situations, explicitly declare all of your new variables with var to make it clear which variables are new, and then use the assignment operator (=) to assign values to both new and old variables.

While var and := allow you to declare multiple variables on the same line, only use this style when assigning multiple values returned from a function or the comma ok idiom.

Learning Go Jon Bondner