web-dev-qa-db-fra.com

Pourquoi il existe deux façons de déclarer des variables dans Go, quelle est la différence et laquelle utiliser?

Selon la référence Go, il existe deux façons de déclarer une variable

Déclarations_variables (au format var count = 0 ou var count int)
et
Short_variable_declarations (au format count := 0)

J'ai trouvé que c'était très déroutant de décider lequel utiliser.

Les différences que je connais (jusqu'à présent) sont les suivantes:

  • Je ne peux utiliser qu'un count := 0 format lorsque dans le domaine d'une fonction.
  • count := 0 peut être redéclaré dans une déclaration courte à plusieurs variables.

Mais ils se comportent de la même manière pour autant que je sache. Et dans la référence cela aussi dit :

Il (le count:=0way) est un raccourci pour une déclaration de variable régulière avec des expressions d'initialisation mais pas de types

Mes confusions sont:

  • Si l'un n'est que le raccourci de l'autre, pourquoi se comportent-ils différemment?
  • Dans quel souci l'auteur de Go fait-il deux manières de déclarer une variable (pourquoi ne sont-elles pas fusionnées en une seule)? Juste pour nous confondre?
  • Y a-t-il un autre aspect sur lequel je devrais garder les yeux ouverts lorsque je les utilise, au cas où je tomberais dans une fosse?
variablesgovar
29
armnotstrong

Les déclarations de variables indiquent clairement que les variables sont déclarées. Le mot clé var est obligatoire, il est court et exprime ce qui est fait (au niveau du fichier, tout sauf les commentaires doit commencer par un mot clé, par exemple package, import, const, type, var, func). Comme tout autre bloc, les déclarations de variables peuvent être regroupées comme suit:

var (
    count int
    sum   float64
)

Vous ne pouvez pas faire cela avec déclarations de variables courtes . Vous pouvez également utiliser des déclarations de variables sans spécifier la valeur initiale, auquel cas chaque variable aura la valeur zéro de son type. La déclaration de variable courte ne le permet pas, vous devez spécifier la valeur initiale.

L'un des principes directeurs de Go était de rendre la syntaxe propre. De nombreuses instructions nécessitent ou il est pratique qu'elles permettent de déclarer des variables locales qui ne seront disponibles que dans le corps de l'instruction telles que for, if, switch etc. la syntaxe plus propre et plus courte, la déclaration de variable courte est justifiée dans ces cas et ce qu'ils font est sans ambiguïté.

for idx, value := range array {
    // Do something with index and value
}

if num := runtime.NumCPU(); num > 1 {
    fmt.Println("Multicore CPU, cores:", num)
}

Autre différence: redéclaration

Citant de la spécification de langue:

Contrairement aux déclarations de variables régulières, une déclaration de variable courte peut redéclarer des variables à condition qu'elles aient été déclarées à l'origine plus tôt dans le même bloc avec le même type, et qu'au moins une des variables non vides soit nouvelle. Par conséquent, la redéclaration ne peut apparaître que dans une déclaration courte multi-variables. La redéclaration n'introduit pas de nouvelle variable; il affecte simplement une nouvelle valeur à l'original.

Celui-ci est également pratique. Supposons que vous souhaitiez gérer correctement les erreurs, vous pouvez réutiliser une variable err car il est fort probable que vous n'en ayez besoin que pour vérifier s'il y a eu des erreurs lors du dernier appel de fonction:

var name = "myfile.txt"

fi, err := os.Stat(name) // fi and err both first declared
if err != nil {
    log.Fatal(err)
}
fmt.Println(name, fi.Size(), "bytes")

data, err := ioutil.ReadFile(name) // data is new but err already exists
                                   // so just a new value is assigned to err
if err != nil {
    log.Fatal(err)
}

// Do something with data
46
icza