Unterschied zwischen: = und = Operatoren in Go

Was ist der Unterschied zwischen =und :=Operatoren und was sind die Anwendungsfälle für sie? Sie scheinen beide für einen Auftrag zu sein?

Nur =der Zuweisungsoperator.

:=ist Teil der Syntax der Short-Variablendeklarationsklausel .

👉 Es gibt jedoch einige Regeln. Weitere Informationen finden Sie in dieser anderen Antwort .

In Go :=ist für Deklaration + Zuweisung, während =nur für Zuweisung.

Zum Beispiel var foo int = 10 ist das gleiche wie foo := 10.

Wie andere bereits erklärt haben, :=gilt dies sowohl für die Erklärung als auch für die Abtretung und auch für die erneute Erklärung; und es errät ( schließt ) automatisch den Typ der Variablen.

Zum Beispiel foo := 32ist eine Kurzform von:

var foo int
foo = 32

// OR:
var foo int = 32

// OR:
var foo = 32

/ * Es gibt einige Regeln: * /

★ 1. Regel:

Sie können nicht :=aus verwenden funcs. Dies liegt daran, dass eine Anweisung aus irgendeinem Grund mit einem Schlüsselwort beginnen sollte.

// 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. Regel:

Sie können sie nicht zweimal verwenden ( im selben Bereich ):

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

Denn :=einleitet „eine neue Variable“ , indem es daher nicht zweimal eine zweite Variable ist neu deklarieren, so dass es illegal ist.

★ 3. Regel:

Sie können sie für Deklarationen und Zuweisungen mit mehreren Variablen verwenden:

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

★ 4. Regel (Neuerklärung):

Sie können sie zweimal in Deklarationen mit mehreren Variablen verwenden , wenn eine der Variablen neu ist :

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

Dies ist legal, da Sie nicht alle Variablen deklarieren, sondern lediglich den vorhandenen Variablen neue Werte zuweisen und gleichzeitig neue Variablen deklarieren. Dies wird als Neuerklärung bezeichnet .

★ 5. Regel:

Mit der kurzen Deklaration können Sie eine Variable in einem neueren Bereich deklarieren, auch wenn diese Variable bereits zuvor mit demselben Namen deklariert wurde:

var foo int = 34

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

Hier foo := 42ist legal, denn es erklärt fooin some()func Anwendungsbereich. foo = 314ist legal, weil es nur einen neuen Wert zuweist foo.

★ 6. Regel:

Sie können denselben Namen in kurzen Anweisungsblöcken deklarieren wie: if , for , switch :

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

Weil fooin if foo := ...nur zu dieser ifKlausel gehört und sich in einem anderen Bereich befindet.

Grundsätzlich gilt: Wenn Sie eine Variable einfach deklarieren möchten, können Sie sie verwenden :=, oder wenn Sie nur eine vorhandene Variable überschreiben möchten, können Sie sie verwenden =.

Verweise:

• Kurze Regeln für die Deklaration von Variablen

• Ein visueller Leitfaden für Go-Variablen

:= ist eine Abkürzung für die Erklärung.

a := 10
b := "gopher"

awird als deklariert intund mit value initialisiert, 10wobei as bals String deklariert und mit value initialisiert wird gopher.

Ihre Entsprechungen =wären

var a = 10
var b = "gopher"

=ist Zuweisungsoperator. Es wird genauso verwendet, wie Sie es in jeder anderen Sprache verwenden würden.

Sie können den Typ weglassen, wenn Sie die Variable deklarieren und ein Initialisierer vorhanden ist ( http://tour.golang.org/#11 ).

Das: = bedeutet deklarieren und zuweisen, während das = bedeutet, einfach zuzuweisen.

:=deklariert und weist zu, =weist nur zu

Dies ist nützlich, wenn Sie Ihren Code nicht mit Typ- oder Strukturdeklarationen füllen möchten.

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

aus dem Referenzdokument: ( tour.golang.org )

Innerhalb einer Funktion kann die :=kurze Zuweisungsanweisung anstelle einer var-Deklaration mit implizitem Typ verwendet werden.

Außerhalb einer Funktion beginnt jedes Konstrukt mit einem Schlüsselwort (var, func usw.) und das Konstrukt: = ist nicht verfügbar.

": =" Wird verwendet, um Deklaration und Initilisierung gleichzeitig durchzuführen. Das folgende Beispiel zeigt dies.

Verwendung von "="

var i int

i = 10

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

Verwendung von ": ="

i: = 10

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

Beides ist die unterschiedliche Technik der Variablendeklaration in der Go-Sprache.

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

UND

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

Eine kurze Variablendeklaration ist eine Abkürzung für eine reguläre Variablendeklaration mit Initialisiererausdrücken, aber ohne Typen.

Lesen Sie unten für Details:

Variablendeklarationen

Kurze Variablendeklarationen