Réponse.

En Go, il existe deux types de constantes : les non typées (untyped) et les typées (typed). Historiquement, cela découle du désir du langage de rendre les systèmes de types flexibles et sûrs, permettant au compilateur de détecter les erreurs dès la compilation, et garantissant la conversion des types uniquement lorsque cela est permis.

Le problème surgit lorsque le programmeur ne distingue pas ces deux catégories et se fie au comportement de la constante sans tenir compte des exigences de type dans les déclarations de fonctions et d'interfaces. Cela peut entraîner des erreurs de conversion entre types, des erreurs de compilation inattendues ou une compatibilité « sautante » inattendue lors de l'appel de fonctions.

La solution repose sur une compréhension claire :

En dehors de l'attribution à un type spécifique, une constante n'a pas de type fixe et peut « s'adapter » au type attendu lors du passage à une fonction.
Une fois le type spécifié (par exemple, const x int = 42), les opérations ultérieures avec cette constante sont limitées au type indiqué.

Exemple de code :

const Pi = 3.14 // non typée
const Answer int64 = 42 // typée

func printInt(a int) {
    fmt.Println(a)
}

func main() {
    printInt(Pi) // Erreur : Pi n'est pas un int (mais peut être converti explicitement)
    printInt(int(Pi)) // Ok
    printInt(Answer) // Ok, car Answer est déjà int64, et int64 vers int — conversion explicite
}

Caractéristiques clés :

Les constantes non typées permettent une conversion de type flexible.
Les constantes typées sont strictement liées au type spécifié.
De nombreuses opérations avec des constantes diffèrent de celles avec des variables — à la compilation, une optimisation accrue et une vérification de débordement sont possibles.

Questions pièges.

Peut-on assigner une constante non typée de valeur à un flottant à une variable de type int sans conversion ?

Non. Bien qu'une constante non typée puisse être utilisée dans une expression de type différent, essayer d'assigner une constante flottante à une variable de type int entraînera une erreur de compilation. Une conversion explicite est nécessaire :

const Pi = 3.14
var x int = Pi // le compilateur renvoie une erreur
var y int = int(Pi) // Ok

Le type d'une constante non typée passe-t-il à son type lors de la première opération d'assignation ?

Non, une constante ne reçoit pas de type tant qu'elle n'est pas insérée dans un contexte où un type spécifique est attendu, ou n'est pas explicitement déclarée. Dans tous les autres cas, elle reste non typée.

Peut-on utiliser de grandes constantes numériques de type non typé pour initialiser des variables de plus petite taille, si les valeurs tiennent ?

Oui, si la valeur en valeur absolue est comprise dans la plage du type cible. Sinon, le compilateur renverra une erreur de débordement.

Exemple :

const Big = 1 << 62
var x int32 = Big // Erreur : Big ne tient pas dans int32
var y int64 = Big // Ok

Erreurs typiques et anti-patterns

Ignorer la distinction entre les constantes non typées et typées
Essayer d'assigner ou d'utiliser les valeurs des constantes en dehors de la plage de types acceptables
Utilisation imprudente des littéraux numériques sans définir le type attendu

Exemple du monde réel

Cas négatif

Dans un projet financier complexe, les développeurs ont déclaré un certain nombre de constantes (pourcentages, coefficients) comme non typées. Un jour, certaines fonctions ont commencé à nécessiter des float32 au lieu de float64. Le passage automatique de type a entraîné une perte de précision dans les calculs, ce qui n'a pas été remarqué immédiatement.

Avantages :

Flexibilité et simplicité de déclaration de constantes

Inconvénients :

Les pertes de précision ne sont pas évidentes
Des erreurs surviennent si le type attendu n'est pas suivi

Cas positif

Dans une autre partie du système, toutes les constantes sont déclarées avec une déclaration de type explicite, et les conversions sont faites de manière explicite :

const Discount float64 = 0.05