Types, Valeurs, variables et constantes en golang

Après avoir compris comment écrire un premier programme et comment le compiler, il faut maintenant maîtriser comment stocker et manipuler les données élémentaires en golang :

• les types
• les valeurs
• les variables
• les constantes

Les types

Go dispose de différents types de valeur, comme les chaînes de caractères (string), les entiers (int), les nombres à virgule flottante (float), les booléens (bool), etc. Vous les découvrirez dans cet article et au fil de votre découverte de golang. Vous pourrez, par exemple, décrire votre propre type de variable complexe avec une structure (struct).

Go est un langage fortement typé. Il y a des débats au sein de la communauté des développeurs sur ce que veut dire typage fort, aussi plutôt que de participer à ce débat, je vais plutôt vous donner une explication pragmatique :

• Le compilateur go détecte et interdit les erreurs de typage, par exemple :

  a := 1 //Déclare une variable et initialise une variable de type int

  puis

  a = "toto" //Tente d'utiliser une variable de type int en y écrivant une chaîne de caractères

• Le compilateur go détecte et interdit les conversions implicites de type, par exemple :

  var a string //Déclare une variable de type chaîne de caractères

  puis

  a = 1 //Tente de convertir implicitement un entier en chaîne de caractères

  il faudrait mieux écrire

  a = fmt.Sprintf("%d", 1)

Cela pourrait paraître comme une entrave, mais cela augmentera votre productivité parce qu'il est plus long de détecter et de corriger un défaut causé par l'abus du typage faible que de satisfaire les exigences du compilateur. En PHP, par exemple, les lignes de programmation ci-dessus sont légales et si vous ne vérifiez pas la nature des variables reçues dans les fonctions (ce qui est en soi très coûteux en lignes de code et en temps d'exécution), cela peut provoquer des bugs parfois très longs à analyser et à résoudre.

Les valeurs

À partir du moment où vous respectez les règles du typage fort décrites dans le paragraphe précédent, vous pouvez faire des opérations sur des valeurs de même type sans les convertir au préalable. Par exemple, dans ce programme :

• On additionne des valeurs de type chaîne de caractères, des entiers et des nombres à virgule flottante.
• On effectue des opérations logiques sur des valeurs booléennes (ET, OU, NON logique).

 Executer   Format

Ce programme retournera les valeurs suivantes :

golang
1+1 = 2
7.0/3.0 = 2.3333333333333335
false
true
false

Les variables

À cause de ce que nous avons vu dans l'introduction, les variables sont explicitement déclarées avant d'être utilisées. Et il est interdit de déclarer une variable qui ne sera pas utilisée. Cette règle permet de maintenir un code propre et de réduire la taille de l'exécutable compilé. Le typage fort permet également au compilateur de vérifier si vous n'avez pas fait d'erreurs de passage de paramètres à une fonction (par exemple, le passage d'une variable d'un mauvais type).

Le mot-clé pour déclarer une variable est var. On peut l'utiliser pour déclarer une ou plusieurs variables. On peut, optionnellement, initialiser une variable en même temps que sa déclaration. comme dans les exemples ci-dessous :

var a string
var b string = "toto"
var c, d  string = "toto", "tata"
var i1, i2, i3 int = 1, 2, 3

Le compilateur go est capable de déduire le type de certaines variables par la valeur utilisée pour l'initialisation. Comme ici où le compilateur déduit que commutateur est un booléen :

var commutateur = true

Il existe un raccourci qui permet de déclarer et d'initialiser une variable tout en laissant le compilateur golang déduire le type de la variable :

chaine := "essai"

Les constantes

Go permet de définir des constantes comme illustré dans cet exemple de code :

 Executer   Format

Les spécifications du langage fixent les règles suivantes pour l'utilisation des constantes :

• On peut déclarer des constantes aux mêmes endroits que les variables. Cependant, les mêmes règles de portée s'appliquent. Dans ce code, la fonction affichage ne pourrait accéder à la constante n qui est locale à la fonction main.
• On peut initialiser une constante à l'aide d'une expression qui sera évaluée au moment de la déclaration.
• Les constantes peuvent ne pas avoir de type au moment de leur déclaration. Le compilateur go est capable de déterminer le type d'après le contexte. Ici, la fonction math.Sin attend une variable de type float64, le compilateur go transforme donc l'appel à la fonction en effectuant un transtypage (c.-à-d. fmt.Println(math.Sin(float64(n))))