W Go, {[0] } jest dla deklaracji + przypisanie, podczas gdy = jest tylko dla przypisania.

Na przykład, var foo int = 10 jest tym samym co foo := 10.

Jak już inni wyjaśnili, {[7] } jest zarówno deklaracją, jak i przypisaniem i próbuje odgadnąć (wywnioskować) typ zmiennej automatycznie.

To krótka forma:

var foo int
foo = 32

// OR:
var foo int = 32

// OR:
var foo = 32

Niektóre zasady

Nie możesz użyć := z funcs.

illegal := 42

func foo() {
  legal := 42
}

Nie możesz użyć ich dwa razy:

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

Ponieważ, := wprowadza "nową zmienną" , dlatego użycie jej dwa razy nie powoduje ponownego zapisania drugiej zmiennej, więc jest nielegalne.

Można jednak użyć ich dwukrotnie w "deklaracjach wielowarstwowych", jeśli jedna ze zmiennych jest nowa :

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

Jest to legalne, ponieważ nie zmieniasz zmiennych, po prostu przypisujesz nowe wartości do istniejących zmiennych, z nowymi zmiennymi.

Możesz ich użyć, jeśli zmienna już wcześniej zadeklarowana o tej samej nazwie:

var foo int = 34

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

Tutaj, foo := 42 jest legalne, ponieważ, to redeclares foo w some() luneta func. foo = 314 jest legalne, ponieważ po prostu przypisuje nową wartość foo.

_

Można ich używać do deklaracji i przypisań wielu zmiennych:

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

_

Możesz użyć ich ponownie w kontekstach takich jak: jeśli, na, przełącznik :

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

Ponieważ, if foo := ... przypisanie, dostępne tylko dla tego if klauzuli.

Więc, zgodnie z ogólną zasadą: chyba że jesteś ponowne zadeklarowanie zmiennej można użyć :=, lub, jeśli chcesz nadpisać istniejącą wartość, można użyć =.

:= jest skrótem do deklaracji.

a := 10
b := "gopher"

a zostanie zadeklarowana jako int i zainicjalizowana wartością 10 gdzie jako b zostanie zadeklarowana jako łańcuch znaków i zainicjalizowana wartością gopher.

Ich odpowiednikami przy użyciu = będą

var a = 10
var b = "gopher"

= jest operatorem przypisania. Jest używany w ten sam sposób, w jaki można go używać w każdym innym języku.

Możesz pominąć Typ, gdy zadeklarujesz zmienną i jest obecny inicjalizator ( http://tour.golang.org/#11).

:= deklaruje i przydziela, = po prostu przydziela

Jest to przydatne, gdy nie chcesz wypełniać kodu deklaracjami typu lub struktury.

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

: = oznacza zadeklarować i przypisać, podczas gdy = oznacza po prostu przypisać.

Z dokumentu referencyjnego: ( tour.golang.org )

Wewnątrz funkcji , krótka instrukcja przypisania := może być użyta zamiast deklaracji var z typem niejawnym.

Poza funkcją , każdy konstrukt zaczyna się od słowa kluczowego (var, func, itd.), a := construct nie jest dostępny.

":= " służy do wykonywania deklaracji i inicjalizacji w tym samym czasie, poniżej znajduje się przykład.

Użycie "= "

Var i int

I = 10

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

Użycie": = "

I: = 10

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

Obie są inną techniką deklaracji zmiennych w języku Go.

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

I

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

Krótka deklaracja zmiennej jest skrótem zwykłej deklaracji zmiennej z wyrażeniami inicjalizującymi, ale bez typów.

Czytaj poniżej, aby poznać szczegóły:

Deklaracje zmiennych

Krótkie deklaracje zmiennych