wikinotes

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
{{tag>dev go golang}}

Notes et transcriptions du cours "[[https://www.coursera.org/learn/golang-getting-started/home/welcome|Démarrer avec Go]]" proposée par 
[[https://uci.edu/|University of California, Irvine]] disponible sur la plateforme [[https://www.coursera.org/|coursera]].

====== Initialisation des variables ======


Nous avons abordé les variables et nous allons parler de la façon de les initialiser mais quelques mots à propos des types.

===== Alias sur le type =====

Chaque variable doit donc avoir un type mais vous pouvez définir un alias, un autre nom pour un type existant. Cela est donc parfois utile pour clarifier une application particulière du type.

Par exemple, disons que vous avez une d'application qui fonctionne sur les températures. Vous manipulez ces températures sous la forme de décimaux ( virgule flottante de 64 bits).

Vous pouvez donc définir un nouveau type, un alias :

<code go>
type Celsius float64
</code>

Dans ce cas, ''Celsius'' est exactement le même que le ''float64''. Vous pouvez toujours déclarer que vos variables sont float64, mais ''Celsius'' peut avoir du sens dans le contexte de votre application : le code est ainsi plus clair pour vous en tant que programmeur.

Autre exexemple :

<code go>
type IDnum int
</code>

Si je crée du code qui implémente une base de données d'utilisateurs et que chaque utilisateur possède un numéro d'identification. On a en tête le concept d'UID, d'identifiant utilisateur unique. Je sais que c'est un entier, mais je veux le nommer plus clairement. Je veux lui donner le nom ''IDNum'', afin de savoir que chaque variable déclarée ''IDNum'' est un identifiant utilisateur. Je donne un sens au code en me basant uniquement sur le nom du type.

vous pouvez désormais déclarer des variables en utilisant vos alias. Je peux donc écrire :

<code go>
var temp Celsius
</code>
La variable ''temp'' va avoir le type ''float64'' car ''Celsius'' est un alias de''float64''. De la même manière

<code go>
var pid idNum
</code>
La variable ''pid'' est en fait un entier. Mais nous l'appelons ''IDnum'' et cela clarifie son usage dans notre code.

===== Initialisation des variables =====

Chaque variable doit être initialisée d'une manière ou d'une autre avant de l'utiliser.

Une façon de l'initialiser est dans la déclaration elle-même. Vous pouvez donc écrire :
<code go>
var x int = 100
</code>

On déclare ici une variable nommée ''x'' de type entier, et on définit aussi sa valeur comme égal à 100.

Vous pouvez simplement écrire
<code go>
var x = 100
</code>

Ci-dessus vous ne dites pas explicitement que ''x'' est un entier. Mais compilateur déduira le type grâce au type de la valeur à droite de l'affectation. Le nombre 100 est un entier, donc ''x'' doit être un entier, il fera de ''x'' un entier.

Retenez cependant que parfois ça peut poser problème car le compilateur peut déduire quelque chose que vous ne vouliez pas.

Si par exemple on écrit :

<code go>
x = 100
</code>

J'affecte ici la valeur 100 parce que c'est ma température initiale, mais en fait je veux que ce soit géré par nombre à virgule flottante car plus tard je pourrais avoir des valeurs de température avec décimales. Si je ne le précise pas, comme 100 est un entier, il en déduira que x est de type entier. Si par la suite j'essaie d'affecter la valeur "100,1" à ''x'', j'aurai un problème.


Il est donc préférable de spécifier le type, mais vous n'êtes pas obligé de le faire.


L' initialisation peut être faite après la déclaration. Vous pouvez donc simplement écrire :
<code go>
# declaration
var x int
</code>

Puis vous pouvez écrire plus loin dans le code :
<code go>
# initialisation / affectation
x = 100
</code>
C'est une autre façon de faire.

Si vous n'initialisez pas explicitement une variable, elle obtiendra toujours une valeur. Elle obtiendra la valeur zéro correspondant à son type. 

Si on reprend
<code go>
var x int
</code>

La valeur 0 pour son type entier est 0, ''x'' ce verra automatiquement assigné la valeur 0.

Si on écrit :
<code go>
var x string
</code>

La valeur zéro d'une chaîne est une chaîne vide. Dans ce cas, ''x'' serait initialisé avec une chaîne vide.

===== Déclarations courtes =====

Une autre méthode d'initialisation des variables consiste à utiliser une déclaration de variable courte.

Dans ce cas, vous effectuez la déclaration et l'initialisation ensemble à l'aide de l'opérateur '':=''.

<code go>
x : = 100
</code>

Dans ce cas, ''x'' n'a pas encore été déclaré. Cette instruction déclare donc réellement ''x'' et l'initialise. La spécificité de l'opérateur '':='' c'est qu'il déduit le type à partir de l'opérande de droite. Donc 100 dans ce cas, le compilateur définira ''x'' comme 100de type entier.

Notez que ce type de **déclaration courte** (déclaration et l'affectation en une seule ligne avec cet opérateur spécial) **ne peut se faire que dans une fonction**. Vous ne pouvez donc pas faire une déclaration courte en dehors d'une fonction, cela provoquera une erreur de compilation.

[[140_variables|◁ Précédent]] |
[[000_start|⌂ Retour au sommaire ]] |
[[205_vue_ensemble_partie2|Suivant ▷ ]]
wikinotes

Outils pour utilisateurs

Outils du site

Outils de la page
