Les constantes

Introduction

in this article, we will see string contants, boolean constants, numeric constants and numeric expressions, we will also see how Go handle these constants.

Definition

Le terme constante est utilisée en Go pour désigner des valeurs fixes comme 4,-56, "le langage Go" etc.

Regardez le code suivant:

var a int = 47  
var b string = "le langage Go"

Dans le code ci-dessus, on a affecté aux variables a et b respectivement les constantes 47 et "le langage Go". Le mot-clé const désigne les constantes comme 47 et "le langage Go", toutefois, on n'a pas utilisé const explicitement dans le code ci-dessus car implicitement, ce sont des constantes en Go.

Une constante comme son nom l'indique ne peut être réattribué à une autre valeur, par conséquent, le programme suivant ne va pas marcher et va afficher une erreur de compilation cannot assign to a.

package main

func main() {  
    const a = 47 //permise
    a = 89 //affectation interdite
}

La valeur de la constante doit être connue au moment de la compilation. Par conséquent, elle ne peut être réattribuée à une valeur retournée par un appel de fonction vu que l'appel de la fonction a lieu au moment de l'exécution.

package main

import (  
    "fmt"
    "math"
)

func main() {  
    fmt.Println("Hey, playground")
    var a = math.Sqrt(16)//permsie
    const b = math.Sqrt(16)//interdite
}

Dans le programme ci-dessus, a est une variable, par conséquent, elle peut être attribuée au résultat de la fonction math.sqrt(16).

b est une constante et la valeur de b doit être connue au moment de la compilation. La fonction math.sqrt(16) va être évaluée au moment de l'exécution, par conséquent, const b = math.sqrt(16)engendre l'erreur:error main.go:11: const initializer math.Sqrt(4) is not a constant.

Les constantes String

Toute valeur limitée par des guillemets doubles est une constante string en Go.

Une constante string comme "Bonjour le monde" n'a aucun type.

const bonjour = "Bonjour le monde"

Go est un langage de typage fort. Toutes les variables exigent un type explicite. Alors comment le programme suivant qui attribue la variable name a une constante non typé jack marche?

package main

import (  
    "fmt"
)

func main() {  
    var name = "jack"
    fmt.Printf("type %T value %v", name, name)

}

La réponse est que les constantes non typées ont un type associé par défaut qui le fournissent si seulement et si la ligne de commande le demande. Dans la déclaration var name = "jack", name a besoin d'un type qui l'obtient du type par défaut "jack" qui est un string.

Le code suivant permet la création d'une constante typée.

const hellotype string = "Hello World" 

hellotype dans le code ci-dessus est une constante de type string

Go est un langage de typage fort. Mélanger les types durant l'affectation n'est pas permis.

Exemple:

package main

func main() {  
        var NomParDefaut = "jack" //permise
        type monString string
        var customNom monString = "jack" //permise
        customNom = NomParDefaut //interdite
}

Dans le code ci-dessus, on crée d'abord une variable NomParDefaut et on l'attribue à la constante jack.

Dans la ligne suivante, on crée un nouveau type monString qui est un alias de string.

Puis on crée une variable customNom de type monString et on lui attribue la constante jack. Puisque la constante jack est non typée, elle peut être attribuée à n'importe quelle variable de type string. Par conséquent, cette affectation est permise et customNom reçoit le type monString.

Maintenant on a une variable NomParDefaut de type string et une autre variable customNom de type monString. Bien qu'on sait que monString est un alias de string, la politique du typage fort de go interdit l'attribution des variables d'un seul type à d'autres variables. **Par conséquent, l'affectation customNom = NomParDefaut n'est pas permise et le compilateur lance une erreur: ** main.go:7:20: cannot use defaultName (type string) as type myString in assignment.

Les constantes booléennes

Les constantes booléennes ne sont pas différentes des constantes string. Il existe deux constantes non typées true et false . Les mêmes règles des constantes string s'appliquent aux constantes booléennes.

Exemple:

package main

func main() {  
    const trueConst = true
    type monBool bool
    var BoolParDefaut = trueConst //permise
    var customBool monBool = trueConst //permise
    BoolParDefaut = customBool //interdite
}

Les constantes numériques

Les constantes numériques incluent les entiers, les réels et les constantes complexes. Il faut faire attention aux subtilités concernant les constantes numériques.

Exemple:

package main

import (  
    "fmt"
)

func main() {  
    const b = 5
    var intVar int = b
    var int32Var int32 = b
    var float64Var float64 = b
    var complex64Var complex64 = b
    fmt.Println("intVar",intVar, "\nint32Var", int32Var, "\nfloat64Var", float64Var, "\ncomplex64Var",complex64Var)
}

Dans le programme ci-dessus, la constante b est non typée, elle est de valeur 5. Vous vous êtes sûrement demandés quel est le type par défaut de b et s'il existe vraiment, comment on l'attribue à des variables de types différents. La réponse se trouve dans le syntaxe de b. Le programme suivant va rendre les choses plus claires.

package main

import (  
    "fmt"
)

func main() {  
    var j = 4
    var f = 7.8
    var c = 9 + 6i
    fmt.Printf("le type de j %T, le type de f %T, le type de c %T", j, f, c)

}

Dans le programme ci-dessus, le type de chaque variable est déterminé par le syntaxe numérique constant. 4 est un entier par syntaxe, 7.8 est un réel et 9 + 6i est un complexe. Quand on exécute le programme, on obtient: le type de j int, le type de f float64, le type de c complex128

Exemple:

package main

import (  
    "fmt"
)

func main() {  
    const b = 5
    var intVar int = b
    var int32Var int32 = b
    var float64Var float64 = b
    var complex64Var complex64 = b
    fmt.Println("intVar",intVar, "\nint32Var", int32Var, "\nfloat64Var", float64Var, "\ncomplex64Var",complex64Var)
}

Les expressions numériques

Les constantes numériques peuvent être mélangées dans les expressions, le type est exigé uniquement quand elles sont attribuées à des variables ou utilisées dans une partie de code qui exige le type.

package main

import (  
    "fmt"
)

func main() {  
    var b =  8,2/2 
    fmt.Printf("le type de b  %T valeur %v",b, b)
}

L'opération 8,2/2 est permise malgré que 8.2 est un float et 2 est un entier. Le résultat est un float, par conséquent, le type de b est float. la sortie du programme est: le type de b float64 valeur 4,1.

---

Posted on Utopian.io - Rewarding Open Source Contributors

---