Comment les différents types de variables sont définis dans Golang

La façon de définir différents types de variables dans Golang nécessite des exemples de code spécifiques

Dans Golang, nous pouvons utiliser différentes manières pour définir différents types de variables. Cet article expliquera comment définir plusieurs types de variables courants dans Golang et fournira des exemples de code correspondants.

1. Variable entière (int)
Les variables entières en Golang peuvent être utilisées pour stocker des valeurs entières. Elles sont définies comme suit :

var num int // Déclarez une variable entière nommée num
num = 10 //Assignment
fmt. .Println(num) //Sortie : 10

2. Variable à virgule flottante (float)
Les variables à virgule flottante dans Golang peuvent être utilisées pour stocker des valeurs réelles, et leur définition est la suivante :

var num float64 // Déclarer un variable à virgule flottante nommée num
num = 3.14 // Attribuer une valeur
fmt.Println(num) // Sortie : 3.14

3 Variable booléenne (bool)
Les variables booléennes dans le type Golang sont utilisées pour stocker les valeurs vraies et fausses, et sont définis comme suit :

var flag bool // Déclarez une variable booléenne nommée flag
flag = true // Attribuez une valeur
fmt.Println(flag) // Sortie : true

4. les variables en Golang sont utilisées pour stocker des séquences de caractères. Elles sont définies comme suit :

var str string // Déclarez une variable de chaîne nommée str

str = "Hello World" // Assignation
fmt.Println(str) // Sortie : Hello World

5. Variable de tableau (array)

Un tableau en Golang est une séquence d'éléments de même type de longueur fixe et est défini comme suit :

var arr [5]int // Déclare un tableau entier nommé arr avec une longueur de 5

arr = [5]int{1, 2, 3, 4, 5} // Attribue une valeur
fmt(arr) // Sortie : [1 2 3 4 5]

. 6. Variable Slice (slice)

Une tranche en Golang est une référence à un tableau et peut croître dynamiquement. Elle est définie comme suit :

var sli []int // Déclarez une tranche entière nommée sli

sli = []int. {1, 2, 3} // Attribuer une valeur
fmt.Println(sli) // Sortie : [1 2 3]

7 .Variable de dictionnaire (carte)

Un dictionnaire en Golang est une collection non ordonnée de paires clé-valeur , qui est défini comme suit :

var m map[string]int // Déclare une chaîne nommée m en int Dictionnaire

m = map[string]int{"a": 1, "b": 2} // Assignation
fmt.Println(m) // Sortie : map[a:1 b:2]

8. Variable de structure (struct)

La structure dans Golang est un type de données personnalisé qui peut combiner différents champs. Elle est définie comme suit. :

type Person struct {

Name string
Age  int

}

var p Person // Déclarez une variable de structure Personne nommée p

p = Person{Name: "Tom", Age: 20} // Assignment
fmt.Println(p) // Sortie : {Tom 20}

9. Variable pointeur (pointeur)

Les variables pointeur dans Golang sont utilisées pour stocker des adresses mémoire pointant vers d'autres variables. Elles sont définies comme suit :

var ptr *int // Déclare un entier. variable de pointeur nommée ptr

num := 10
ptr = &num // Affectation
fmt.Println(ptr) // Sortie : 0xc000014088

Ce qui précède sont les méthodes de définition de certains types courants de variables dans Golang et les exemples de code correspondants. Grâce à ces exemples, nous pouvons mieux comprendre et utiliser différents types de variables dans Golang. J'espère que cet article pourra vous être utile.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!