web-dev-qa-db-fra.com

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

Dans Go, quelle est la différence entre l'opérateur = et :=? Ils semblent tous les deux être pour la cession? Cela peut paraître évident, mais je n'arrive pas à le trouver dans la documentation.

gocolon-equals
188
Chris

Seul = est l'opérateur d'affectation.

:= n'est en fait pas un opérateur du tout. Cela fait partie de la syntaxe de la clause Short variable declarations .

150
zzzz

En Go, := est pour déclaration + affectation, alors que = est uniquement pour assignation.

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

192
Chaos

Comme d'autres l'ont déjà expliqué, := sert à la fois à la déclaration, à l'affectation et à la redéclaration; et il devine (infer) le type de la variable automatiquement.

C'est une forme abrégée de:

var foo int
foo = 32

// OR:
var foo int = 32

// OR:
var foo = 32

Certaines règles

Vous ne pouvez pas utiliser := sur funcs. C'est parce que, de toute façon, une déclaration devrait commencer par un mot clé.

illegal := 42

func foo() {
  legal := 42
}

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" , son utilisation deux fois ne redéclare pas une seconde variable, elle est donc illégale.

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

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

Cela est légal, car vous ne déclarez pas toutes les variables, vous réaffectez simplement de nouvelles valeurs aux variables existantes et vous déclarez de nouvelles variables en même temps.

Vous pouvez utiliser la déclaration courte pour déclarer une variable dans une nouvelle portée, 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 := 42 est légal, car il déclare foo dans la portée de some() func. foo = 314 est légal, car il attribue simplement une nouvelle valeur à foo.

Vous pouvez les utiliser pour des déclarations et des affectations multi-variables:

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

Vous pouvez déclarer le même nom dans de courts blocs d'instructions tels que: if , pour , switch :

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

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

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

41
Inanc Gumus

:= est un raccourci pour la déclaration.

a := 10
b := "Gopher"

a sera déclaré en tant que int et initialisé avec la valeur 10 où en tant que b sera déclaré en tant que chaîne et initialisé avec la valeur Gopher.

Leurs équivalents utilisant = seraient

var a = 10
var b = "Gopher"

= est un opérateur d'affectation. Il est utilisé de la même manière que dans une 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 ).

18
ShuklaSannidhya

:= déclare et affecte, = attribue seulement

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)
9
Gustav

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

9
Ralph Caraveo

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

Dans une fonction, l'instruction d'assignation courte := peut être utilisée à la place d'une déclaration var avec un type implicite.

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

6
subhash kumar singh

“: =” Est utilisé pour faire la déclaration et l'initialisation 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

2
Nisal Edu

Les deux sont les différentes techniques de déclaration de variable 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.

Lire ci-dessous pour plus de détails:

Déclarations de variables

Déclarations de variables courtes

1
Pravin Mishra

Comme beaucoup l'ont déjà dit - Le: = signifie déclarer et assigner; le = signifie simplement assigner. Remarque importante ici est que si en fonction vous faites

foo := 2.5

alors Go décide si foo est float32 ou float64 en fonction de plusieurs choses, mais une fois décidé et compilé en float64, vous ne pouvez pas utiliser foo as float32 et vice versa. Par conséquent, il est parfois préférable d’utiliser la syntaxe complète.

0
Belial