Constantes du langage Go

Une constante est un identifiant pour une valeur simple, une quantité qui ne sera pas modifiée pendant l'exécution du programme. Les types de données des constantes ne peuvent être que booléens, numériques (entier, virgule flottante et complexe) et de type chaîne.

Définitions de mots： constOuiconstantAbréviation de (constante), représentant une valeur immuable dans un programme.

Syntaxe de base et paramètres

Le format de définition des constantes :

const identifier [type] = value

Description de la syntaxe

identifierNom de la constante, suivant les règles de nommage des identifiants Go (lettres, chiffres, traits de soulignement, et ne peut pas commencer par un chiffre).
type(Facultatif) : nom du type ; s'il est omis, il est automatiquement déduit par le compilateur.
value: la valeur de la constante.

Méthodes de définition

Définition de type explicite：const b string = "abc"
Définition de type implicite：const b = "abc"
Définition groupée：const c_name1, c_name2 = value1, value2

Exemple

Exemple 1 : Définition de constante de base

Exemple

package main

import "fmt"

func main() {
const LENGTH int = 10
const WIDTH int = 5
var area int
const a, b, c = 1, false, "str" // Affectation multiple

area = LENGTH * WIDTH
fmt.Printf("L'aire est : %d", area)
println()
println(a, b, c)
}

Sortie attendue :

面积为 : 50
1 false str

Analyse du code :

const LENGTH int = 10Définit une constante entière LENGTH avec la valeur 10.
const WIDTH int = 5Définit une constante entière WIDTH avec la valeur 5.
const a, b, c = 1, false, "str"Utilise l'affectation multiple pour définir simultanément plusieurs constantes de types différents.
area = LENGTH * WIDTHCalcule l'aire et l'assigne à la variable area.

Groupes de constantes et énumérations

Go n'a pas de mot-clé enum ; il utilise généralement des groupes de constantes pour obtenir un comportement de type énumération :

Exemple

package main

import "fmt"

// Définir l'énumération de genre
const (
Unknown = 0
Female = 1
Male = 2
)

func main() {
fmt.Printf("Unknown=%d, Female=%d, Male=%d\n", Unknown, Female, Male)
}

Sortie attendue :

未知=0, 女性=1, 男性=2

Analyse du code :

En utilisant un groupe de constantes, vous pouvez définir un ensemble de valeurs constantes associées.
Les nombres 0, 1 et 2 représentent respectivement le genre inconnu, le féminin et le masculin.

Application des fonctions intégrées dans les constantes

Dans les expressions constantes, vous pouvez utiliserlen()、cap()、unsafe.Sizeof()et d'autres fonctions intégrées pour calculer la valeur de l'expression.

Remarque :Dans les expressions constantes, les fonctions doivent être des fonctions intégrées.

Exemple

package main

import (
"fmt"
"unsafe"
)

const (
a = "abc"
b = len(a)
c = unsafe.Sizeof(a)
)

func main() {
fmt.Printf("a=%s, b=%d, c=%d\n", a, b, c)
}

Sortie attendue :

a=abc, b=3, c=16

Analyse du code :

a = "abc": constante de chaîne.
b = len(a): Utilisez len() pour obtenir la longueur de la chaîne, le résultat est 3.
c = unsafe.Sizeof(a): Utilisez unsafe.Sizeof() pour obtenir l'utilisation mémoire de la variable, le résultat est 16 bytes (la structure de chaîne occupe 16 bytes sur un système 64-bit).

compteur de constantes iota

iotaEst une constante spéciale en Go, aussi appelée compteur de constantes. Elle peut générer automatiquement une séquence croissante de valeurs dans un bloc de déclaration const.

Fonctionnalités importantes：

iotaDansconstLe mot-clé sera réinitialisé à 0 lorsqu'il apparaît.
Dans const, chaque nouvelle ligne de déclaration de constante incrémente le compteur iota de 1.
Il peut être compris comme l'index de ligne dans le bloc d'instructions const (en partant de 0).

Exemple 1 : utilisation de base d'iota

Exemple

package main

import "fmt"

// iota commence à 0, s'incrémente de 1 à chaque ligne
const (
a = iota // 0
b // 1 (valeur omise, correspond par défaut à l'iota de la ligne précédente)
c // 2
)

func main() {
fmt.Printf("a=%d, b=%d, c=%d\n", a, b, c)
}

Sortie attendue :

a=0, b=1, c=2

Analyse du code :

Lorsque la valeur de la constante est omise, la valeur iota de la ligne précédente est utilisée par défaut.
Par conséquent, b=1, c=2.

Exemple 2 : Utilisation détaillée de iota

Exemple

package main

import "fmt"

func main() {
const (
a = iota // 0
b // 1
c // 2
d = "ha" // Valeur indépendante, iota += 1
e // "ha"，iota += 1
f = 100 // Valeur indépendante, iota += 1
g // 100，iota += 1
h = iota // 7, reprendre en utilisant la valeur iota
i // 8
)
fmt.Printf("a=%d, b=%d, c=%d, d=%s, e=%s, f=%d, g=%d, h=%d, i=%d\n", a, b, c, d, e, f, g, h, i)
}

Sortie attendue :

a=0, b=1, c=2, d=ha, e=ha, f=100, g=100, h=7, i=8

Analyse du code :

Lorsqu'une valeur est explicitement assignée, cette valeur est utilisée, mais iota s'incrémente quand même.
Lorsque l'assignation est omise, la valeur de la ligne précédente est utilisée.
Dansh = iotaPuis reprend en utilisant la valeur actuelle de iota (7).

Exemple 3 : iota et opérations de décalage de bits

Exemple

package main

import "fmt"

const (
i = 1 << iota // 1 << 0 = 1
j = 3 << iota // 3 << 1 = 6
k // 3 << 2 = 12
l // 3 << 3 = 24
)

func main() {
fmt.Printf("i=%d, j=%d, k=%d, l=%d\n", i, j, k, l)
}

Sortie attendue :

i=1, j=6, k=12, l=24

Analyse du code :

<<est l'opérateur de décalage à gauche,x << nÉquivalent àx * 2^n。
i = 1 << 0 = 1: 1 décalé vers la gauche de 0 bit, le résultat est 1.
j = 3 << 1 = 6: 3 décalé vers la gauche de 1 bit, le binaire 11 devient 110, ce qui donne 6.
k = 3 << 2 = 12: 3 décalé vers la gauche de 2 bits, le binaire 11 devient 1100, ce qui donne 12.
l = 3 << 3 = 24: 3 décalé vers la gauche de 3 bits, le binaire 11 devient 11000, ce qui donne 24.

Notes supplémentaires

1 << n = 1 * 2^n
3 << n = 3 * 2^n

autres extensions