Różnica między: = i = operatorami w Go

Jaka jest różnica między =i :=operatorów, a jakie są przypadki użycia dla nich? Oboje wydają się być na zlecenie?

Tylko =operator przypisania.

:=jest częścią składni klauzuli Krótkie deklaracje zmiennych .

👉 Istnieją jednak pewne zasady. Zobacz tę inną odpowiedź, aby uzyskać więcej informacji.

W Go :=służy do deklaracji + przypisania, natomiast =dotyczy tylko przypisania.

Na przykład var foo int = 10 jest taki sam jak foo := 10.

Jak już wyjaśnili inni, dotyczy :=to zarówno deklaracji, cesji, jak i redeklaracji; i automatycznie zgaduje ( wnioskuje ) typ zmiennej.

Na przykład foo := 32jest krótką formą:

var foo int
foo = 32

// OR:
var foo int = 32

// OR:
var foo = 32

/ * Istnieją pewne zasady: * /

★ 1. reguła:

Nie możesz użyć :=z funcs. Wynika to z faktu, że z dowolnej funkcji instrukcja powinna zaczynać się od słowa kluczowego.

// no keywords below, illegal.
illegal := 42

// `var` keyword makes this statement legal.
var legal = 42

func foo() {
  alsoLegal := 42
  // reason: it's in a func scope.
}

★ 2. reguła:

Nie możesz ich użyć dwa razy ( w tym samym zakresie ):

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

Ponieważ :=wprowadza „nową zmienną” , a zatem dwukrotne użycie jej nie powoduje ponownego uzgodnienia drugiej zmiennej, więc jest to nielegalne.

★ trzecia reguła:

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

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

★ Czwarta reguła (Deklaracja):

Możesz użyć ich dwa razy w deklaracjach „wielu zmiennych” , 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 deklarujesz wszystkich zmiennych, po prostu przypisujesz nowe wartości do istniejących zmiennych i deklarujesz nowe zmienne w tym samym czasie. Nazywa się to deklaracją .

★ 5 reguła:

Możesz użyć krótkiej deklaracji, aby zadeklarować zmienną w nowszym zakresie, nawet jeśli ta zmienna była już wcześniej zadeklarowana pod tą samą nazwą:

var foo int = 34

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

Tutaj foo := 42jest legalne, ponieważ deklaruje foow zakresie some()func. foo = 314jest legalne, ponieważ po prostu przypisuje nową wartość do foo.

★ 6. reguła:

Możesz zadeklarować tę samą nazwę w krótkich blokach instrukcji, takich jak: if , for , przełącz :

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

Ponieważ foow if foo := ...należy tylko do tej ifklauzuli i ma inny zakres.

Zatem ogólna zasada: jeśli chcesz łatwo zadeklarować zmienną, której możesz użyć :=, lub, jeśli chcesz tylko zastąpić istniejącą zmienną, możesz jej użyć =.

Bibliografia:

• Zasady krótkiej deklaracji zmiennej

• Wizualny przewodnik po zmiennych Go

:= jest skrótem do deklaracji.

a := 10
b := "gopher"

azostanie zadeklarowany jako inti zainicjowany wartością, 10gdzie as bzostanie zadeklarowany jako ciąg i zainicjowany wartością gopher.

Ich odpowiednikami =byłyby

var a = 10
var b = "gopher"

=jest operatorem przypisania. Jest używany w taki sam sposób, jak w innym języku.

Możesz pominąć ten typ, kiedy deklarujesz zmienną i obecny jest inicjalizator ( http://tour.golang.org/#11 ).

: = Oznacza deklarowanie i przypisywanie, podczas gdy = oznacza po prostu przypisywanie.

:=deklaruje i przypisuje, =po prostu przypisuje

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

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

z dokumentu referencyjnego: ( tour.golang.org )

Wewnątrz funkcji The :=krótkie oświadczenie przypisanie może być stosowany w miejsce deklaracji var z niejawnego typu.

Poza funkcją każdy konstrukt zaczyna się słowem kluczowym (var, func itd.), A konstrukcja: = nie jest dostępna.

„: =” Służy do wykonania deklaracji i inicjalizacji w tym samym czasie, poniżej podano przykład.

Zastosowanie „=”

var i int

i = 10

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

Zastosowanie „: =”

i: = 10

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

Oba są różnymi technikami deklaracji zmiennych w języku Go.

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

I

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

Deklaracja krótkiej zmiennej jest skrótem dla deklaracji zmiennej regularnej z wyrażeniami inicjalizującymi, ale bez typów.

Szczegóły poniżej:

Deklaracje zmienne

Krótkie deklaracje zmiennych