Variables du langage Go

Un programme typique utilise diverses valeurs qui peuvent changer pendant l'exécution.

Par exemple, programme qui effectue certaines opérations sur les valeurs saisies par l'utilisateur. Une valeur saisie par un utilisateur peut être différente de celle saisie par un autre utilisateur. Par conséquent, il est nécessaire d'utiliser des variables, car d'autres utilisateurs peuvent ne pas utiliser la même valeur. Lorsqu'un utilisateur saisit une nouvelle valeur qui sera utilisée pendant le processus d'opération, ces valeurs peuvent être temporairement stockées dans la mémoire à accès direct du ordinateur, ces valeurs étant différentes selon les parties de la mémoire où elles sont exécutées, donc ce terme est également appeléVariable. Une variable est un marqueur pour des informations qui peuvent être modifiées au cours de l'exécution. De plus, la variable permet de rechercher et de traiter les informations stockées.

VariableRègles de nommage :

Le nom de la variable doit commencer par une lettre ou un trait de soulignement (_). Et le nom peut contenir les lettres "a".-z" ou " A-Z" ou le nombre 0-9et le caractère " _".

Geeks, geeks, _geeks23　　//Variable valide
123Geeks,　23geeks　　　　　　//　Variable non valide

Les noms de variables ne devraient pas commencer par un chiffre.

234geeks　　//Variable non valide

Les noms de variables sont sensibles à la casse.

geeks et Geeks sont deux variables différentes

Les mots-clés ne peuvent pas être utilisés comme noms de variables.

La longueur du nom de la variable n'est pas limitée, mais il est recommandé d'utiliser4à15La longueur optimale d'un nom de variable est

Déclaration de variable

Dans le langage Go, les variables sont créées de deux manières différentes :

(Première partie) Utilisation du mot-clé var :Dans le langage Go, les variables sont déclarées en utilisant un type spécifiquevarLe mot-clé créé, associé au nom de la variable et assigné sa valeur initiale.

Syntaxe :

var variable_name type = expression

Points importants :

Dans la syntaxe ci-dessus,Type (type) ou=L'expression peut être supprimée, mais les deux ne peuvent pas être supprimées simultanément dans la déclaration de variable.

Si vous supprimez le type, le type de la variable est déterminé par l'initialisation de la valeur de l'expression.

//Le concept de variable
package main
import "fmt"
func main() {
　　　　//Déclaration et initialisation des variables
　　　　//Type explicite
　　　　var myvariable1　=　20
　　　　var myvariable2　="w3codebox"
　　　　var myvariable3　=　34.80
　　　　//　Afficher la valeur et le
　　　　//　Le type des variables
　　　　fmt.Printf("myvariable1la valeur est : %d\n", myvariable1)
　　　　fmt.Printf("myvariable1le type est : %T\n", myvariable1)
　　　　fmt.Printf("myvariable2la valeur est : %s\n", myvariable2)
　　　　fmt.Printf("myvariable2le type est : %T\n", myvariable2)
　　　　fmt.Printf("myvariable3la valeur est : %f\n", myvariable3)
　　　　fmt.Printf("myvariable3le type est : %T\n", myvariable3)
}

Sortie :

myvariable1la valeur est :　20
myvariable1le type est : int
myvariable2la valeur est : w3codebox
myvariable2le type est : string
myvariable3la valeur est :　34.800000
myvariable3est de type : float64

Si vous supprimez l'expression, le type de la variable est zéro, le nombre est zéro, la valeur booléenne est false, et la chaîne est""、interface et les types de référence sont nil. Par conséquent,Dans le langage Go, il n'existe pas le concept de variable non initialisée.

package main
import "fmt"
func main() {
　　　　//La déclaration et l'initialisation des variables ne utilisent pas l'expression
　　　　var myvariable1　int
　　　　var myvariable2　string
　　　　var myvariable3　float64
　　　　//Afficher la variable de valeur 0
　　　　fmt.Printf("myvariable1la valeur est : %d\n", myvariable1)
　　　　fmt.Printf("myvariable2la valeur est : %d\n", myvariable2)
　　　　fmt.Printf("myvariable3la valeur est : %d\n", myvariable3)
}

Sortie :

myvariable1La valeur est : 0
myvariable2La valeur est : %!d(string=)
myvariable3La valeur est : %!d(float64=0)

Si vous utilisez le type, vous pouvez déclarer plusieurs variables du même type dans une seule déclaration.

package main
import "fmt"
func main() {
　　　　//　Déclarer et initialiser plusieurs variables du même type sur une ligne
　　　　var myvariable1, myvariable2, myvariable3　int =　2,　454,　67
　　　　//　Afficher la valeur de la variable
　　　　fmt.Printf("myvariable1la valeur est : %d\n", myvariable1)
　　　　fmt.Printf("myvariable2la valeur est : %d\n", myvariable2)
　　　　fmt.Printf("myvariable3la valeur est : %d\n", myvariable3)
}

Sortie :

myvariable1la valeur est :　2
myvariable2la valeur est :　454
myvariable3la valeur est :　67

Si vous supprimez le type, vous pouvez déclarer plusieurs variables de types différents dans une seule déclaration. Le type de la variable est déterminé par la valeur d'initialisation.

package main
import "fmt"
func main() {
　　　　//Plusieurs variables de types différents
　　　　//Déclaration et initialisation en une seule ligne
　　　　var myvariable1, myvariable2, myvariable3　=　2, "GFG",　67.56
　　　　//　Imprimer la valeur et le type de la variable
　　　　fmt.Printf("myvariable1la valeur est : %d\n", myvariable1)
　　　　fmt.Printf("myvariable1le type est : %T\n", myvariable1)
　　　　fmt.Printf("\nmyvariable2la valeur est : %s\n", myvariable2)
　　　　fmt.Printf("myvariable2le type est : %T\n", myvariable2)
　　　　fmt.Printf("\nmyvariable3la valeur est : %f\n", myvariable3)
　　　　fmt.Printf("myvariable3le type est : %T\n", myvariable3)
}

Sortie :

myvariable1la valeur est :　2
myvariable1le type est : int
myvariable2La valeur est : GFG
myvariable2le type est : string
myvariable3la valeur est :　67.560000
myvariable3est de type : float64

L'appel de fonction permettant de renvoyer plusieurs valeurs vous permet d'initialiser un ensemble de variables.

Par exemple :

//Ici, la fonction os.Open retourne
//la variable i du fichier et une erreur
//dans la variable j
var i, j = os.Open(name)

(Deuxième partie) Utilisation de la déclaration de variable courte : Utiliser la déclaration de variable courtepour déclarer et initialiser les variables locales dans la fonction.

Syntaxe :

variable_name:=expression

Remarque :Ne pas utiliser dans:=et=sont confondus, car:= est la déclaration, et = est l'affectation.

Points importants :

Dans l'expression ci-dessus, le type de la variable est déterminé par le type de l'expression.

package main
import "fmt"
func main() {
　　　　//　Utilisation de la déclaration de variables courtes
　　　　myvariable1　:=　39
　　　　myvariable2　:= "oldtoolbag.com"
　　　　myvariable3　:=　34.67
　　　　//　Imprimer la valeur et le type de la variable
　　　　fmt.Printf("myvariable1la valeur est : %d\n", myvariable1)
　　　　fmt.Printf("myvariable1le type est : %T\n", myvariable1)
　　　　fmt.Printf("\nmyvariable2la valeur est : %s\n", myvariable2)
　　　　fmt.Printf("myvariable2le type est : %T\n", myvariable2)
　　　　fmt.Printf("\nmyvariable3la valeur est : %f\n", myvariable3)
　　　　fmt.Printf("myvariable3le type est : %T\n", myvariable3)
}

Sortie :

myvariable1la valeur est :　39
myvariable1le type est : int
myvariable2la valeur est : oldtoolbag.com
myvariable2le type est : string
myvariable3la valeur est :　34.670000
myvariable3est de type : float64

En raison de leur concision et de leur flexibilité, la plupart des variables locales sont déclarées et initialisées en utilisant la déclaration de variables courtes.

La déclaration var des variables est utilisée pour les variables locales nécessitant un type explicite différent de l'expression de l'affectation initiale, ou pour celles dont la valeur est affectée plus tard et pour lesquelles l'affectation initiale n'est pas importante.

L'utilisation de la déclaration de variables courtes permet de déclarer plusieurs variables dans une seule déclaration.

package main
import "fmt"
func main() {
　　　　//Déclaration et initialisation des variables en une seule ligne
　　　　//Déclaration de variables courtes
　　　　//Plusieurs variables du même type
　　　　myvariable1, myvariable2, myvariable3　:=　800,　34.7,　56.9
　　　　//　Imprimer la valeur et le type de la variable
　　　　fmt.Printf("myvariable1la valeur est : %d\n", myvariable1)
　　　　fmt.Printf("myvariable1le type est : %T\n", myvariable1)
　　　　fmt.Printf("\nmyvariable2la valeur est : %f\n", myvariable2)
　　　　fmt.Printf("myvariable2le type est : %T\n", myvariable2)
　　　　fmt.Printf("\nmyvariable3la valeur est : %f\n", myvariable3)
　　　　fmt.Printf("myvariable3le type est : %T\n", myvariable3)
}

Sortie :

myvariable1la valeur est :　800
myvariable1le type est : int
myvariable2la valeur est :　34.700000
myvariable2est de type : float64
myvariable3la valeur est :　56.900000
myvariable3est de type : float64

Dans la déclaration de variables courtes, il est permis de retourner plusieurs valeurs pour initialiser un ensemble de variables.

//Ici, la fonction os.Open retourne
//la variable i du fichier et une erreur
//dans la variable j
i, j := os.Open(name)

La déclaration de variables courtes ne s'applique qu'aux variables déjà déclarées dans le même bloc syntaxique et agit comme une affectation. Les variables déclarées à l'extérieur du bloc sont ignorées. Comme dans l'exemple suivant, au moins l'une de ces variables est une nouvelle variable.

package main
import "fmt"
func main() {
　　　　//Déclaration de variables courtes
　　　　//Ici, l'action de la déclaration de variables courtes
　　　　//comme myvar2Affectation des variables
　　　　//parce que le même variable existe dans le même bloc
　　　　//Par conséquent, myvar2la valeur de45Changez en100
　　　　myvar1, myvar2　:=　39,　45
　　　　myvar3, myvar2　:=　45,　100
　　　　//Si vous essayez d'exécuter une ligne de commentaire
　　　　//Ensuite, le compilateur donnera une erreur, car
　　　　//Ces variables sont déjà définies, par exemple
　　　　//　myvar1, myvar2:=　43,47
　　　　//　myvar2:=　200
　　　　//　Imprimer la valeur de la variable
　　　　fmt.Printf("myvar1　et myvar2　la valeur : %d %d\n", myvar1, myvar2)
　　　　fmt.Printf("myvar3　et myvar2　la valeur : %d %d\n", myvar3, myvar2)
}

Sortie :

myvar1　et myvar2　la valeur :　39　100
myvar3　et myvar2　la valeur :　45　100

L'utilisation de la déclaration de variables courtes permet de déclarer plusieurs variables de types différents dans une seule déclaration. Le type des variables est déterminé par l'expression.

package main
import "fmt"
func main() {
　　　　//Déclaration et initialisation en une seule ligne
　　　　//Déclaration de variables courtes
　　　　//Plusieurs variables de types différents
　　　　myvariable1, myvariable2, myvariable3　:=　800, "w3codebox　47.56
　　　　//　Imprimer la valeur et le type de la variable
　　　　fmt.Printf("myvariable1la valeur est : %d\n", myvariable1)
　　　　fmt.Printf("myvariable1le type est : %T\n", myvariable1)
　　　　fmt.Printf("\nmyvariable2la valeur est : %s\n", myvariable2)
　　　　fmt.Printf("myvariable2le type est : %T\n", myvariable2)
　　　　fmt.Printf("\nmyvariable3la valeur est : %f\n", myvariable3)
　　　　fmt.Printf("myvariable3le type est : %T\n", myvariable3)
}

Sortie :

myvariable1la valeur est :　800
myvariable1le type est : int
myvariable2la valeur est : w3codebox
myvariable2le type est : string
myvariable3la valeur est :　47.560000
myvariable3est de type : float64