Opérateur de déclaration de variable courte Go (:=

L'opérateur de déclaration de variable courte （:=） de Golang est utilisé pour créer des variables avec des noms appropriés et des valeurs initiales. L'objectif principal de cet opérateur est de déclarer et d'initialiser des variables locales à l'intérieur des fonctions, et de restreindre la portée des variables. Le type de la variable est déterminé par le type de l'expression. Le mot-clé var est également utilisé pour créer des variables de types spécifiques. Donc, vous pouvez dire qu'il y a deux méthodes pour créer des variables en Golang, comme indiqué ci-dessous:

• Utiliser le mot-clé var

• Utiliser l'opérateur de déclaration de variable courte （:=）

Dans cet article, nous ne discuterons que de l'opérateur de déclaration de variable courte. Pour comprendre le mot-clé var, vous pouvezEn Goréférencemot-clé var。

La syntaxe d'utilisation de l'opérateur de déclaration de variable courte :

variable_name　:=　expression　ou　valeur

Ici, il est nécessaire d'initialiser immédiatement les variables après la déclaration, sans mentionner le type de la variable, l'expression ou la valeur de la droite est utilisée pour évaluer le type de la variable. En utilisant le mot-clé var, vous pouvez éviter l'initialisation lors de la déclaration

Exemple :}}ici, nous déclarons des variables en utilisant l'opérateur de déclaration courte (:=) sans spécifier le type de la variable. Le type de la variable est déterminé par:=le type de l'expression de droite de l'opérateur déterminé.

package main
import "fmt"
func main() {
　　　　//déclarer et initialiser une variable
　　　　a :=　30
　　　　//accepter une variable de chaîne
　　　　Language := "Go 语言基础教程"
　　　　fmt.Println("la valeur de a : ", a)
　　　　fmt.Println("La valeur de Language : ", Language)
}

Sortie :

la valeur de a :　　30
La valeur de Language :教程 de base du langage Go

déclarer plusieurs variables en utilisant l'opérateur de déclaration courte (:=)

l'opérateur de déclaration courte (:=) peut également être utilisé pour déclarer plusieurs variables dans une seule déclarationdu même type ou de types différentsmultiples variables. Les types de ces variables sont déterminés par:=l'évaluation de l'expression de droite de l'opérateur.

package main
import "fmt"
func main() {
　　　　//multiples variables du même type (int)
　　　　w3codebox1, w3codebox2, w3codebox3　:=　117,　7834,　5685
　　　　//différents types de variables multiples
　　　　w3codebox4, w3codebox5, w3codebox6　:= "GFG",　859.24,　1234
　　　　//afficher la valeur et le type de la variable
　　　　fmt.Printf("w3codebox1　la valeur est : %d\n", w3codebox1)
　　　　fmt.Printf("w3codebox1　le type est : %T\n", w3codebox1)
　　　　fmt.Printf("\nw3codebox2　la valeur est : %d\n", w3codebox2)
　　　　fmt.Printf("w3codebox2　le type est : %T\n", w3codebox2)
　　　　fmt.Printf("\nw3codebox3　la valeur est : %d\n", w3codebox3)
　　　　fmt.Printf("w3codebox3　le type est : %T\n", w3codebox3)
　　　　fmt.Printf("\nw3codebox4　la valeur est : %s\n", w3codebox4)
　　　　fmt.Printf("w3codebox4　le type est : %T\n", w3codebox4)
　　　　fmt.Printf("\nw3codebox5　la valeur est : %f\n", w3codebox5)
　　　　fmt.Printf("w3codebox5　le type est : %T\n", w3codebox5)
　　　　fmt.Printf("\nw3codebox6　la valeur est : %d\n", w3codebox6)
　　　　fmt.Printf("w3codebox6　le type est : %T\n", w3codebox6)
}

Sortie :

w3codebox1　la valeur est :　117
w3codebox1　le type est : int
w3codebox2　la valeur est :　7834
w3codebox2　le type est : int
w3codebox3　la valeur est :　5685
w3codebox3　le type est : int
w3codebox4　la valeur est : GFG
w3codebox4　le type est : string
w3codebox5　la valeur est :　859.240000
w3codebox5　le type est : float64
w3codebox6　la valeur est :　1234
w3codebox6　le type est : int

:= déclare-t-il une variable locale ou globale ?

en utilisant l'opérateur de déclaration courte (:=),vous ne pouvez déclarerne possède qu'une portée de blocdes variables locales.Généralement, les variables locales sont déclarées à l'intérieur des blocs fonctionnels. Si vous essayez de déclarer une variable globale en utilisant l'opérateur de déclaration courte (:=), un message d'erreur sera généré.

package main　　
　　　　
import "fmt"
　　　　
//utiliser le mot-clé var pour la déclaration
//et initialiser la variable
//elle est une variable du paquet, ou vous pouvez dire que c'est une portée globale
var w3codebox1　:=　900　　
　　　　
//utiliser des déclarations de variables courtes
//elle va lever une erreur
w3codebox2　:=　200　　
　　　　
func main() {　　
　　　　
//dans la fonction interne d'accès à w3codebox1
fmt.Println(w3codebox1)　　
　　　
//　dans la fonction interne d'accès à w3codebox2
fmt.Println(w3codebox2)　　
　　　　　　　　
}

erreur de sortie :

.\test.go:12:1:erreur de syntaxe : non-déclaration statement outside function body
#.\test.go:12:1:erreur de syntaxe : instruction non déclarée en dehors du corps de la fonction

package main
import "fmt"
//déclarer une variable globale en utilisant var
var w3codebox1　:=　900
func main() {
　　　　//utiliser des déclarations de variables courtes
　　　　//dans la fonction principale
　　　　//elle a une portée locale, c'est-à-dire qu'elle ne peut pas
　　　　//dans la fonction principale en dehors
　　　　w3codebox2　:=　200
　　　　//dans la fonction interne d'accès à w3codebox1
　　　　fmt.Println(w3codebox1)
　　　　//dans la fonction interne d'accès à w3codebox2
　　　　fmt.Println(w3codebox2)
}

Sortie :

900
200