Go
Les constantes

Remarques

Déclarer une constante

Les constantes sont déclarées comme des variables, mais en utilisant le mot-clé const :

const Greeting string = "Hello World"
const Years int = 10
const Truth bool = true

Comme pour les variables, les noms commençant par une majuscule sont exportés ( public ), les noms commençant par une minuscule ne le sont pas.

// not exported
const alpha string = "Alpha"
// exported
const Beta string = "Beta"

Les constantes peuvent être utilisées comme toute autre variable, sauf que la valeur ne peut pas être modifiée. Voici un exemple:

package main

import (
    "fmt"
    "math"
)

const s string = "constant"

func main() {
    fmt.Println(s) // constant

    // A `const` statement can appear anywhere a `var` statement can.
    const n = 10
    fmt.Println(n)                           // 10
    fmt.Printf("n=%d is of type %T\n", n, n) // n=10 is of type int

    const m float64 = 4.3
    fmt.Println(m) // 4.3

    // An untyped constant takes the type needed by its context.
    // For example, here `math.Sin` expects a `float64`.
    const x = 10
    fmt.Println(math.Sin(x)) // -0.5440211108893699
}

Cour de récréation

Déclaration de constantes multiples

Vous pouvez déclarer plusieurs constantes dans le même bloc const :

const (
    Alpha = "alpha"
    Beta  = "beta"
    Gamma = "gamma"
)

Et incrémenter automatiquement les constantes avec le mot-clé iota :

const (
    Zero = iota // Zero == 0
    One         // One  == 1
    Two         // Two  == 2
)

Pour plus d'exemples d'utilisation de iota pour déclarer des constantes, voir Iota .

Vous pouvez également déclarer plusieurs constantes à l'aide de l'affectation multiple. Cependant, cette syntaxe peut être plus difficile à lire et elle est généralement évitée.

const Foo, Bar = "foo", "bar"

Constantes typées et non typées

Les constantes dans Go peuvent être saisies ou non typées. Par exemple, compte tenu du littéral de chaîne suivant:

"bar"

on pourrait dire que le type du littéral est string , cependant, ceci n'est pas sémantiquement correct. Au lieu de cela, les littéraux sont des constantes de chaîne non typées . C'est une chaîne (plus correctement, son type par défaut est string ), mais ce n'est pas une valeur Go et n'a donc pas de type tant qu'elle n'est pas affectée ou utilisée dans un contexte tapé. C'est une distinction subtile, mais utile à comprendre.

De même, si nous affectons le littéral à une constante:

const foo = "bar"

Il reste non typé puisque, par défaut, les constantes ne sont pas typées. Il est possible de le déclarer comme une chaîne typée constante également:

const typedFoo string = "bar"

La différence entre en jeu lorsque nous tentons d’attribuer ces constantes dans un contexte de type. Par exemple, considérez les éléments suivants:

var s string
s = foo      // This works just fine
s = typedFoo // As does this

type MyString string
var mys MyString
mys = foo      // This works just fine
mys = typedFoo // cannot use typedFoo (type string) as type MyString in assignment