问题

In Go, what is the difference between the = and := operator? They both seem to be for assignment? This might be obvious but I can't seem to find it in the docs.

回答1:

Only = is the assignment operator.

:= is a part of the syntax of the Short variable declarations clause.

回答2:

In Go, := is for declaration + assignment, whereas = is for assignment only.

For example, var foo int = 10 is the same as foo := 10.

回答3:

As others have explained already, := is for both declaration, assignment, and also for redeclaration; and it guesses (infer) the variable's type automatically.

It's a short-hand form of:

var foo int
foo = 32

// OR:
var foo int = 32

// OR:
var foo = 32

Some rules

You can't use := out of funcs. It's because, out of any func, a statement should start with a keyword.

illegal := 42

func foo() {
  legal := 42
}

You can't use them twice (in the same scope):

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

Because, := introduces "a new variable", hence using it twice does not redeclare a second variable, so it's illegal.

However, you can use them twice in "multi-variable" declarations, if one of the variables is new:

foo, bar  := someFunc()
foo, jazz := someFunc()  // <-- jazz is new
baz, foo  := someFunc()  // <-- baz is new

This is legal, because, you're not declaring all the variables, you're just reassigning new values to the existing variables, and declaring new variables at the same time.

You can use the short declaration to declare a variable in a newer scope even that variable is already declared with the same name before:

var foo int = 34

func some() {
  // because foo here is scoped to some func
  foo := 42  // <-- legal
  foo = 314  // <-- legal
}

Here, foo := 42 is legal, because, it declares foo in some() func's scope. foo = 314 is legal, because, it just assigns a new value to foo.

You can use them for multi-variable declarations and assignments:

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

You can declare the same name in short statement blocks like: if, for, switch:

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

Because, foo in if foo := ..., only belongs to that if clause and it's in a different scope.

So, as a general rule: If you want to easily declare a variable you can use :=, or, if you only want to overwrite an existing variable, you can use =.

References:

Short Variable Declaration Rules
A Visual Guide to Go Variables

回答4:

:= is a short-hand for declaration.

a := 10
b := "gopher"

a will be declared as an int and initialized with value 10 where as b will be declared as a string and initialized with value gopher.

Their equivalents using = would be

var a = 10
var b = "gopher"

= is assignment operator. It is used the same way you would use it in any other language.

You can omit the type when you declare the variable and an initializer is present (http://tour.golang.org/#11).

回答5:

The := means declare and assign while the = means to simply assign.

回答6:

:= declares and assigns, = just assigns

It's useful when you don't want to fill up your code with type or struct declarations.

// 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)

回答7:

from the reference doc : (tour.golang.org)

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

Outside a function, every construct begins with a keyword (var, func, and so on) and the := construct is not available.

回答8:

“:=” use to do declaration and initilization at the same time, following is an example.

Usage of “=”

var i int

i = 10

https://play.golang.org/p/RU88ty_SGa

Usage of “:=”

i := 10

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

回答9:

As many already said - The := means declare and assign ; the = means to simply assign. Important note here is that if in function you do

foo := 2.5

then Go is deciding if foo is float32 or float64 based on several things, but once decided and compiled as float64 you cannot use foo as float32 and vice versa. Therefore sometimes it's better to use the full syntax.

回答10:

Both are the different technique of variable declaration in Go language.

var firstName = "John" // is a variable declaration

AND

firstName := "John"   // is a short variable declaration.

A short variable declaration is a shorthand for a regular variable declaration with initializer expressions but no types.

Read below for detail:

Variable declarations

Short variable declarations

来源：https://stackoverflow.com/questions/17891226/difference-between-and-operators-in-go

标签

colon-equals

Difference between := and = operators in Go

问题