Constantes en Go

La valeur d'une constante ne peut pas être modifiée pendant l'exécution. Une fois assignée, elle ne peut plus être modifiée. Sa valeur ne peut provenir que de :

• Littéraux
• Autres identifiants constants
• Expressions constantes
• Conversions de type dont le résultat est une constante
• iota

Les constantes ne peuvent être que des types de données de base, pas :

• D'autres types que les types de base, tels que structures, interfaces, tranches, tableaux, etc.
• Valeurs de retour de fonctions

La valeur d'une constante ne peut pas être modifiée, sinon la compilation échouera.

Initialisation

La déclaration d'une constante nécessite le mot-clé const. Une constante doit être initialisée avec une valeur lors de sa déclaration, et le type de la constante peut être omis, par exemple :

const name string = "Jack" // Littéral

const msg = "hello world" // Littéral

const num = 1 // Littéral

const numExpression = (1+2+3) / 2 % 100 + num // Expression constante

Si vous déclarez simplement sans spécifier de valeur, la compilation échouera.

const name string

Le compilateur affichera une erreur :

missing init expr for name

Pour déclarer plusieurs constantes en lot, vous pouvez utiliser () pour améliorer la lisibilité. Plusieurs () peuvent exister pour obtenir un effet de regroupement.

const (
   Count = 1
   Name  = "Jack"
)

const (
   Size = 16
   Len  = 25
)

Dans le même groupe de constantes, les constantes qui suivent une constante déjà assignée n'ont pas besoin d'être assignées, leur valeur est par défaut la même que la précédente, par exemple :

const (
  A = 1
  B // 1
  C // 1
  D // 1
  E // 1
)

iota

iota est un identifiant constant intégré, généralement utilisé pour représenter un nombre entier non typé dans une déclaration de constante, et est généralement utilisé entre parenthèses.

const iota = 0

Voici quelques exemples d'utilisation :

const (
   Num = iota // 0
   Num1 // 1
   Num2 // 2
   Num3 // 3
   Num4 // 4
)

Vous pouvez également écrire ainsi :

const (
   Num = iota*2 // 0
   Num1 // 2
   Num2 // 4
   Num3 // 6
   Num4 // 8
)

Ou encore :

const (
   Num = iota << 2*3 + 1 // 1
   Num1 // 13
   Num2 // 25
   Num3 = iota // 3
   Num4 // 4
)

À travers les exemples ci-dessus, on peut constater qu'iota est incrémental. La première constante utilise l'expression de la valeur iota, et selon les changements de la valeur de séquence, les constantes suivantes seront automatiquement assignées jusqu'à ce qu'un nouveau const réinitialise. Ce numéro de séquence est en fait le numéro de ligne relatif du code, par rapport à la ligne de départ du groupe actuel, comme dans l'exemple ci-dessous :

const (
  Num  = iota<<2*3 + 1 // 1 première ligne
  Num2 = iota<<2*3 + 1 // 13 deuxième ligne
  _ // 25 troisième ligne
  Num3 //37 quatrième ligne
  Num4 = iota // 4 cinquième ligne
  _ // 5 sixième ligne
  Num5 // 6 septième ligne
)

Dans l'exemple, l'identifiant anonyme _ est utilisé pour occuper une ligne. On peut voir que la valeur d'iota est essentiellement la différence entre la ligne où se trouve iota et la première ligne du groupe const actuel. Les différents groupes const ne s'influencent pas mutuellement.

Énumération

Le langage Go n'a pas conçu de type de données séparé pour les énumérations, contrairement à d'autres langages qui ont généralement un enum pour les représenter. En général, en Go, les énumérations sont implémentées via un type personnalisé + const + iota. Voici un exemple simple :

type Season uint8

const (
  Spring Season = iota
  Summer
  Autumn
  Winter
)

Ces énumérations sont en fait des nombres. Go ne prend pas en charge leur conversion directe en chaînes de caractères, mais nous pouvons ajouter des méthodes au type personnalisé pour retourner leur représentation sous forme de chaîne, en implémentant l'interface Stringer.

func (s Season) String() string {
  switch s {
  case Spring:
    return "printemps"
  case Summer:
    return "été"
  case Autumn:
    return "automne"
  case Winter:
    return "hiver"
  }
  return ""
}

Ainsi, une énumération simple est implémentée. Vous pouvez également utiliser l'outil officiel Stringer pour générer automatiquement des énumérations.

Cependant, cela présente les inconvénients suivants :

• Sécurité de type insuffisante, car Season est un type personnalisé et peut être converti en ce type par conversion de type forcée avec d'autres nombres

  Season(6)

• Fastidieux, la représentation sous forme de chaîne doit être implémentée soi-même

• Capacité d'expression faible, car const ne prend en charge que les types de données de base, les valeurs d'énumération ne peuvent être représentées que par des chaînes et des nombres

Le fait que le langage ne prenne pas en charge les énumérations au niveau du langage est quelque chose que l'auteur ne comprend pas. Je pense que c'est absolument plus avantageux que désavantageux.