Const en Golang : les constantes typées et non typées expliquées

Une constante est une valeur fixée à la compilation. Déclarez-la avec const, et Go refuse toute tentative de la modifier.

package main

import (
	"fmt"
	"time"
)

const AppName = "inventory"
const MaxRetries = 3
const Timeout = 2 * time.Second

const (
	KB = 1024
	MB = 1024 * KB
	GB = 1024 * MB
)

func main() {
	fmt.Println(AppName, MaxRetries, Timeout)
	fmt.Println("1 GB =", GB, "bytes")
	fmt.Printf("upload limit: %.1f MB\n", 15_000_000.0/MB)
}

Les constantes peuvent être déclarées au niveau du package ou dans une fonction, une par ligne ou regroupées dans un bloc const ( ... ). MB et GB sont calculées à partir d'autres constantes, et le compilateur fait ce calcul une seule fois, à la compilation.

Affecter une valeur à une constante, comme MaxRetries = 5, est une erreur de compilation :

./main.go:8:2: cannot assign to MaxRetries (neither addressable nor a map index expression)

Ce qui peut être une constante

Seulement trois sortes de valeurs : les booléens, les nombres (entiers, flottants, nombres complexes et runes) et les chaînes. La valeur doit pouvoir être calculée par le compilateur, c'est-à-dire des littéraux, d'autres constantes, de l'arithmétique sur celles-ci, et quelques fonctions intégrées comme len d'une chaîne constante.

Tout ce qui exige d'exécuter du code ou d'allouer de la mémoire est exclu :

const Colors = []string{"red", "green"} // slice
const Started = time.Now()              // function call

./main.go:9:16: []string{…} (value of type []string) is not constant
./main.go:10:13: time.Now() (value of struct type time.Time) is not constant

Pourquoi Go n'a pas de slices ni de maps constantes

Les slices, les maps et les structs qui en contiennent sont des références vers de la mémoire qui existe à l'exécution, donc le compilateur ne peut pas les intégrer au programme comme valeurs fixes, et Go n'a pas de modificateur readonly ou final pour les variables. Les contournements courants :

package main

import (
	"fmt"
	"slices"
)

// A package-level var: fine when your own code is the only writer.
var weekdays = []string{"Mon", "Tue", "Wed", "Thu", "Fri"}

// A function returning a fresh copy: callers cannot change the original.
func Weekdays() []string {
	return slices.Clone(weekdays)
}

// An array has a fixed length, but it is still a var, not a const.
var primes = [5]int{2, 3, 5, 7, 11}

func main() {
	days := Weekdays()
	days[0] = "Monday" // changes the copy only

	fmt.Println(days)
	fmt.Println(weekdays)
	fmt.Println(primes, len(primes))
}

La copie coûte une allocation par appel, ce qui convient pour des données de la taille d'une configuration. Pour une recherche par clé, un switch dans une fonction est une autre option qui se comporte comme une constante : func statusText(code int) string { switch code { ... } }.

Constantes non typées

Une constante déclarée sans type est non typée. Elle a une catégorie (entier, flottant, rune, chaîne, bool) mais pas de type Go précis tant qu'elle n'est pas utilisée, et elle s'adapte au contexte :

package main

import "fmt"

const Ratio = 2 // untyped integer constant

func main() {
	var a int = Ratio
	var b float64 = Ratio
	var c uint8 = Ratio
	var d float32 = Ratio * 1.5

	fmt.Println(a, b, c, d)
	fmt.Printf("%T %T %T %T\n", a, b, c, d)

	// When nothing forces a type, the default type is used.
	x := Ratio
	y := Ratio * 1.5
	fmt.Printf("x is %T, y is %T\n", x, y)
}

Ratio fonctionne comme un int, un float64, un uint8 et un float32 sans conversion. C'est pour cela que time.Sleep(2 * time.Second) compile : 2 est non typé et devient un time.Duration.

Quand le contexte n'impose pas de type, comme avec x := Ratio, la constante prend son type par défaut :

Arithmétique exacte

Les constantes numériques non typées sont exactes. Le compilateur représente les entiers sur au moins 256 bits, donc les valeurs intermédiaires peuvent dépasser de loin n'importe quel type Go :

package main

import "fmt"

const Huge = 1 << 100
const Scaled = Huge >> 98 // 4: fits in an int

func main() {
	fmt.Println(Scaled)
	fmt.Println(Huge / (1 << 90)) // 1024
}

Huge lui-même ne peut pas être affiché comme entier, parce que le passer à fmt.Println le convertit en int, et le compilateur le détecte (float64(Huge) fonctionne, puisqu'un flottant peut contenir cet ordre de grandeur) :

cannot use Huge (untyped int constant 1267650600228229401496703205376) as int value in argument to fmt.Println (overflows)

La même vérification bloque de plus petites erreurs à la compilation, comme var b byte = 300 :

cannot use 300 (untyped int constant) as byte value in variable declaration (overflows)

Constantes typées

Donnez un type à une constante et elle se comporte partout comme une valeur de ce type, y compris le refus de Go de mélanger les types :

const Limit int = 10

var f float64 = 2
fmt.Println(Limit * f)

invalid operation: Limit * f (mismatched types int and float64)

Avec const Limit = 10 (non typée), Limit * f compile et donne 20. Laissez donc les constantes non typées, sauf si le type a un sens. C'est le cas quand vous déclarez des constantes de votre propre type nommé, ce qui est la façon dont Go construit les enums :

type Weekday int

const (
	Sunday Weekday = iota
	Monday
	Tuesday
)

Ici le type est tout l'intérêt : une fonction qui prend un Weekday documente ce qu'elle attend. iota et les motifs d'enum construits dessus sont traités sur la page enums et iota.

const ou var

Utilisez const pour tout ce qui est réellement fixe : limites, tailles, noms, codes de protocole, chaînes de format. Vous obtenez gratuitement la vérification des dépassements à la compilation et une arithmétique exacte.

Pièges

Les constantes typées ne s'adaptent pas. const Timeout int = 5 ne peut pas être passée là où un time.Duration est attendu sans conversion ; une constante non typée const Timeout = 5 peut être multipliée : Timeout * time.Second.

La division entière s'applique aux constantes entières. const Half = 1 / 2 vaut 0, parce que les deux opérandes sont des entiers non typés. Écrivez 1.0 / 2 pour obtenir 0.5.

Pas d'adresse. &MaxRetries ne compile pas. Si une API veut un *int, copiez d'abord la constante dans une variable.