Différence entre: = et = opérateurs dans Go

Quelle est la différence entre les =et les :=opérateurs, et quels sont les cas d'utilisation pour eux? Ils semblent tous les deux être pour une mission?

Seul =l'opérateur d'affectation.

:=fait partie de la syntaxe de la clause de déclaration de variable courte .

👉 Il y a cependant quelques règles. Voir cette autre réponse pour plus de détails.

Dans Go, :=est pour la déclaration + affectation, tandis que =pour l'affectation uniquement.

Par exemple, var foo int = 10 est identique à foo := 10.

Comme d'autres l'ont déjà expliqué, :=c'est à la fois pour la déclaration, la cession et aussi pour la redéclaration; et il devine ( infère ) le type de la variable automatiquement.

Par exemple, foo := 32est une forme abrégée de:

var foo int
foo = 32

// OR:
var foo int = 32

// OR:
var foo = 32

/ * Il y a quelques règles: * /

★ 1ère règle:

Vous ne pouvez pas utiliser :=hors de funcs. C'est parce que, de toute fonction, une déclaration doit commencer par un mot-clé.

// 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.
}

★ 2e règle:

Vous ne pouvez pas les utiliser deux fois ( dans la même portée ):

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

Parce que, :=introduit "une nouvelle variable" , donc l'utiliser deux fois ne redéclarera pas une deuxième variable, donc c'est illégal.

★ 3e règle:

Vous pouvez les utiliser pour des déclarations et des affectations à variables multiples:

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

★ 4ème règle (redéclaration):

Vous pouvez les utiliser deux fois dans des déclarations "multi-variables" , si l'une des variables est nouvelle :

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

C'est légal, car vous ne déclarez pas toutes les variables, vous réaffectez simplement de nouvelles valeurs aux variables existantes et déclarez de nouvelles variables en même temps. C'est ce qu'on appelle la redéclaration .

★ 5ème règle:

Vous pouvez utiliser la déclaration courte pour déclarer une variable dans une portée plus récente même si cette variable est déjà déclarée avec le même nom avant:

var foo int = 34

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

Ici, foo := 42c'est légal, car, il déclare foodans some()la portée de func. foo = 314est légal, car il attribue simplement une nouvelle valeur à foo.

★ 6e règle:

Vous pouvez déclarer le même nom dans des blocs d'instructions courts comme: if , for , switch :

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

Parce que, foodans if foo := ..., n'appartient qu'à cette ifclause et est dans une portée différente.

Donc, en règle générale: si vous voulez déclarer facilement une variable que vous pouvez utiliser :=, ou, si vous voulez seulement écraser une variable existante, vous pouvez utiliser =.

Références:

• Règles de déclaration de variable courte

• Un guide visuel pour aller les variables

:= est un raccourci pour la déclaration.

a := 10
b := "gopher"

asera déclaré comme intet initialisé avec une valeur 10où as bsera déclaré comme une chaîne et initialisé avec une valeur gopher.

Leurs équivalents utilisant =seraient

var a = 10
var b = "gopher"

=est opérateur d'affectation. Il est utilisé de la même manière que vous l'utiliseriez dans n'importe quelle autre langue.

Vous pouvez omettre le type lorsque vous déclarez la variable et qu'un initialiseur est présent ( http://tour.golang.org/#11 ).

Le: = signifie déclarer et assigner tandis que le = signifie simplement assigner.

:=déclare et attribue, =attribue simplement

C'est utile lorsque vous ne voulez pas remplir votre code avec des déclarations de type ou de structure.

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

du document de référence: ( tour.golang.org )

À l'intérieur d'une fonction , la :=courte instruction d'affectation peut être utilisée à la place d'une déclaration var de type implicite.

En dehors d'une fonction , chaque construction commence par un mot clé (var, func, etc.) et la construction: = n'est pas disponible.

«: =» Utiliser pour faire la déclaration et l'initiation en même temps, voici un exemple.

Utilisation de «=»

var i int

i = 10

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

Utilisation de «: =»

i: = 10

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

Les deux sont les différentes techniques de déclaration de variables en langage Go.

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

ET

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

Une déclaration de variable courte est un raccourci pour une déclaration de variable régulière avec des expressions d'initialisation mais pas de types.

Lisez ci-dessous pour plus de détails:

Déclarations variables

Déclarations de variables courtes