TOC

Comment utiliser les variables et les constantes dans Go

LesVariables sont un concept de programmation important à maîtriser. Ce sont des symboles qui représentent une valeur que vous utilisez dans un programme.

Ce didacticiel couvrira quelques notions de base variables et les meilleures pratiques pour les utiliser dans les programmes Go que vous créez.

Comprendre les variables

En termes techniques, une variable affecte un emplacement de stockage à une valeur liée à un nom ou à un identifiant symbolique. Nous utilisons le nom de variable pour référencer cette valeur stockée dans un programme informatique.

Nous pouvons considérer une variable comme une étiquette portant un nom, que vous associez à une valeur.

Variables in Go

Disons que nous avons un entier,1032049348, et que nous voulons le stocker dans une variable plutôt que de retaper continuellement le nombre long encore et encore. Pour ce faire, nous pouvons utiliser un nom facile à retenir, comme la variablei. Pour stocker une valeur dans une variable, nous utilisons la syntaxe suivante: 

i := 1032049348

Nous pouvons considérer cette variable comme une étiquette liée à la valeur.

Go Variable Example

L'étiquette a le nom de variablei écrit dessus, et est liée à la valeur entière1032049348.

La phrasei := 1032049348 est une déclaration et une instruction d'affectation qui se compose de quelques parties:

  • le nom de la variable (i)

  • l'affectation de déclaration de variable courte (:=)

  • la valeur qui est liée au nom de la variable (1032049348)

  • le type de données déduit par Go (int)

Nous verrons plus tard comment définir explicitement le type dans la section suivante.

Ensemble, ces parties constituent l'instruction qui définit la variablei égale à la valeur de l'entier1032049348.

Dès que nous définissons une variable égale à une valeur, nousinitialize ou créons cette variable. Une fois que nous avons fait cela, nous sommes prêts à utiliser la variable au lieu de la valeur.

Une fois que nous avons définii égal à la valeur de1032049348, nous pouvons utiliseri à la place de l'entier, donc imprimons-le: 

package main

import "fmt"

func main() {
    i := 1032049348
    fmt.Println(i)
}
Output1032049348

Nous pouvons aussi faire des maths rapidement et facilement en utilisant des variables. Aveci := 1032049348, nous pouvons soustraire la valeur entière813 avec la syntaxe suivante: 

fmt.Println(i - 813)
Output1032048535

Dans cet exemple, Go fait le calcul pour nous, en soustrayant 813 de la variablei pour renvoyer la somme1032048535.

En parlant de mathématiques, les variables peuvent être égales au résultat d’une équation mathématique. Vous pouvez également additionner deux nombres ensemble et stocker la valeur de la somme dans la variablex: 

x := 76 + 145

Vous avez peut-être remarqué que cet exemple ressemble à l'algèbre. De la même manière que nous utilisons des lettres et d'autres symboles pour représenter des nombres et des quantités dans des formules et des équations, les variables sont des noms symboliques qui représentent la valeur d'un type de données. Pour que la syntaxe Go soit correcte, vous devez vous assurer que votre variable est à gauche des équations.

Allons-y et imprimonsx: 

package main

import "fmt"

func main() {
    x := 76 + 145
    fmt.Println(x)
}
Output221

Go a renvoyé la valeur221 car la variablex a été définie égale à la somme de76 et145.

Les variables peuvent représenter n’importe quel type de données, pas seulement des entiers: 

s := "Hello, World!"
f := 45.06
b := 5 > 9 // A Boolean value will return either true or false
array := [4]string{"item_1", "item_2", "item_3", "item_4"}
slice := []string{"one", "two", "three"}
m := map[string]string{"letter": "g", "number": "seven", "symbol": "&"}

Si vous imprimez l'une de ces variables, Go renverra ce à quoi cette variable est équivalente. Travaillons avec l'instruction d'affectation pour le type de données chaîneslice: 

package main

import "fmt"

func main() {
    slice := []string{"one", "two", "three"}
    fmt.Println(slice)
}
Output[one two three]

Nous avons attribué la valeur de tranche de[]string{"one", "two", "three"} à la variableslice, puis utilisé la fonctionfmt.Println pour imprimer cette valeur en appelantslice.

Les variables fonctionnent en découpant une petite zone de mémoire dans votre ordinateur qui accepte les valeurs spécifiées qui sont ensuite associées à cet espace.

Déclaration de variables

Dans Go, il existe plusieurs façons de déclarer une variable et, dans certains cas, plusieurs façons de déclarer exactement la même variable et la même valeur.

Nous pouvons déclarer une variable appeléei de type de donnéesint sans initialisation. Cela signifie que nous allons déclarer un espace pour mettre une valeur, mais pas lui donner une valeur initiale: 

var i int

Cela crée une variable déclarée commei de type de donnéesint.

Nous pouvons initialiser la valeur en utilisant l'opérateur equal (=), comme dans l'exemple suivant: 

var i int = 1

Dans Go, ces deux formes de déclaration sont appeléeslong variable declarations.

On peut aussi utilisershort variable declaration: 

i := 1

Dans ce cas, nous avons une variable appeléei, et un type de donnéesint. Lorsque nous ne spécifions aucun type de données, Go déduira le type de données.

Avec les trois façons de déclarer des variables, la communauté Go a adopté les idiomes suivants:

  • N'utilisez la forme longue,var i int, que lorsque vous n'initialisez pas la variable.

  • Utilisez la forme courte,i := 1, lors de la déclaration et de l'initialisation.

  • Si vous ne souhaitez pas aller déduire votre type de données, mais que vous souhaitez toujours utiliser une déclaration de variable courte, vous pouvez envelopper votre valeur dans le type souhaité, avec la syntaxe suivante: 

i := int64(1)

Dans Go, l’utilisation du formulaire de déclaration de variable longue lorsqu’on initialise la valeur n’est pas considérée comme idiomatique: 

var i int = 1

Il est judicieux de suivre la façon dont la communauté Go déclare généralement les variables afin que les autres puissent lire vos programmes en toute transparence.

Zéro Valeurs

Tous les types intégrés ont une valeur zéro. Toute variable allouée est utilisable même si aucune valeur n’a jamais été affectée. Nous pouvons voir les valeurs zéro pour les types suivants: 

package main

import "fmt"

func main() {
    var a int
    var b string
    var c float64
    var d bool

    fmt.Printf("var a %T = %+v\n", a, a)
    fmt.Printf("var b %T = %q\n", b, b)
    fmt.Printf("var c %T = %+v\n", c, c)
    fmt.Printf("var d %T = %+v\n\n", d, d)
}
Outputvar a int =  0
var b string = ""
var c float64 = 0
var d bool = false

Nous avons utilisé le verbe%T dans l'instructionfmt.Printf. Cela indique à la fonction d'imprimer lesdata type pour la variable.

Dans Go, comme toutes les valeurs ont une valeurzero, nous ne pouvons pas avoir de valeursundefined comme certaines autres langues. Par exemple, unboolean dans certaines langues peut êtreundefined,true oufalse, ce qui autorise les étatsthree à la variable. Dans Go, nous ne pouvons pas avoir plus detwo états pour une valeur booléenne.

Variables de nommage: règles et style

La dénomination des variables est assez flexible, mais il y a quelques règles à garder à l'esprit:

  • Les noms de variables ne doivent être qu'un mot (comme dans aucun espace).

  • Les noms de variable doivent être composés uniquement de lettres, de chiffres et de traits de soulignement (_).

  • Les noms de variables ne peuvent pas commencer par un nombre.

En suivant ces règles, examinons les noms de variables valides et non valides:

Valide Invalide Pourquoi invalide

userName

user-name

Les traits d'union ne sont pas autorisés

name4

4name

Ne peut pas commencer par un nombre

user

$user

Impossible d'utiliser les symboles

userName

user name

Il ne peut pas y avoir plus d'un mot

De plus, lors de la désignation des variables, n'oubliez pas qu'elles sont sensibles à la casse. Ces nomsuserName,USERNAME,UserName etuSERnAME sont tous des variables complètement différentes. Il est préférable d'éviter d'utiliser des noms de variables similaires dans un programme pour vous assurer que vous et vos collaborateurs, actuels et futurs, pouvez garder vos variables droites.

Alors que les variables sont sensibles à la casse, la casse de la première lettre d'une variable a une signification particulière dans Go. Si une variable commence par une lettre majuscule, alors cette variable est accessible en dehors du package dans lequel elle a été déclarée (ouexported). Si une variable commence par une lettre minuscule, elle n’est disponible que dans le package dans lequel elle est déclarée. 

var Email string
var password string

Email commence par une lettre majuscule et est accessible par d'autres packages. password commence par une lettre minuscule et n'est accessible qu'à l'intérieur du package dans lequel il est déclaré.

Il est courant dans Go d’utiliser des noms de variables très laconiques (ou courts). Étant donné le choix entre utiliseruserName etuser pour une variable, il serait idiomatique de choisiruser.

Scope joue également un rôle dans la concision du nom de la variable. La règle est que plus la portée de la variable est petite, plus le nom de la variable est petit: 

names := []string{"Mary", "John", "Bob", "Anna"}
for i, n := range names {
    fmt.Printf("index: %d = %q\n", i, n)
}

Nous utilisons la variablenames dans une portée plus large, il serait donc courant de lui donner un nom plus significatif pour aider à se souvenir de ce que cela signifie dans le programme. Cependant, nous utilisons les variablesi etn immédiatement dans la ligne de code suivante, puis ne les réutilisons plus. De ce fait, il n’est pas difficile de dérouter quelqu'un qui lit le code pour savoir où les variables sont utilisées ou ce qu’elles signifient.

Ensuite, couvrons quelques notes sur le style variable. Le style consiste à utiliserMixedCaps oumixedCaps plutôt que des traits de soulignement pour les noms de plusieurs mots.

Style conventionnel Style non conventionnel Pourquoi non conventionnel

userName

user_name

Les traits de soulignement ne sont pas conventionnels

i

index

préférezi àindex car il est plus court

serveHTTP

serveHttp

les acronymes doivent être en majuscules

La chose la plus importante à propos du style est d’être cohérent et que l’équipe sur laquelle vous travaillez accepte le style.

Réaffectation de variables

Comme le mot «variable» l’implique, nous pouvons modifier facilement les variables de type Go. Cela signifie que nous pouvons connecter une valeur différente à une variable précédemment assignée par réaffectation. Il est utile de pouvoir réaffecter des ressources car tout au long du programme, il peut être nécessaire d’accepter des valeurs générées par l’utilisateur dans des variables déjà initialisées. Nous devrons peut-être aussi changer l’affectation pour quelque chose de défini auparavant.

Savoir que nous pouvons facilement réaffecter une variable peut être utile lorsque vous travaillez sur un programme volumineux écrit par une autre personne. Les variables déjà définies ne sont pas claires.

Attribuons la valeur de76 à une variable appeléei de typeint, puis affectons-lui une nouvelle valeur de42: 

package main

import "fmt"

func main() {
    i := 76
    fmt.Println(i)

    i = 42
    fmt.Println(i)
}
Output76
42

Cet exemple montre que nous pouvons d'abord affecter la variablei avec la valeur d'un entier, puis réaffecter la variablei en lui attribuant cette fois la valeur de42.

[.note] #Note: Lorsque vous déclarezand initialiser une variable, vous pouvez utiliser:=, cependant, lorsque vous voulez simplement changer la valeur d'une variable déjà déclarée, il vous suffit pour utiliser l'opérateur égal (=).
#

Comme Go est un langage detyped, nous ne pouvons pas attribuer un type à un autre. Par exemple, nous ne pouvons pas affecter la valeur"Sammy" à une variable de typeint: 

i := 72
i = "Sammy"

Essayer d’assigner différents types les uns aux autres provoquera une erreur lors de la compilation: 

Outputcannot use "Sammy" (type string) as type int in assignment

Go ne nous permettra pas d'utiliser un nom de variable plus d'une fois: 

var s string
var s string
Outputs redeclared in this block

Si nous essayons d'utiliser la déclaration de variable courte plusieurs fois pour le même nom de variable, nous recevrons également une erreur de compilation. Cela peut arriver par erreur, il est donc utile de comprendre la signification du message d'erreur: 

i := 5
i := 10
Outputno new variables on left side of :=

De même que pour la déclaration de variable, prendre en compte la dénomination de vos variables améliorera la lisibilité de votre programme pour vous, et pour d’autres, lorsque vous le reverrez ultérieurement.

Affectation multiple

Go permet également d’attribuer plusieurs valeurs à plusieurs variables d’une même ligne. Chacune de ces valeurs peut être d'un type de données différent: 

j, k, l := "shark", 2.05, 15
fmt.Println(j)
fmt.Println(k)
fmt.Println(l)
Outputshark
2.05
15

Dans cet exemple, la variablej a été affectée à la chaîne"shark", la variablek a été affectée au float2.05 et la variablel a été affectée à l'entier15.

Cette approche permettant d'affecter plusieurs variables à plusieurs valeurs sur une seule ligne peut réduire le nombre de lignes de votre code. Cependant, il est important de ne pas compromettre la lisibilité pour moins de lignes de code.

Variables globales et locales

Lorsque vous utilisez des variables dans un programme, il est important de garder à l'espritvariable scope. La portée d’une variable fait référence aux endroits particuliers auxquels elle est accessible depuis le code d’un programme donné. Cela signifie que toutes les variables ne sont pas accessibles à partir de toutes les parties d'un programme donné - certaines variables seront globales et d'autres seront locales.

Les variables globales existent en dehors des fonctions. Les variables locales existent dans les fonctions.

Jetons un coup d’œil aux variables globales et locales en action: 

package main

import "fmt"


var g = "global"

func printLocal() {
    l := "local"
    fmt.Println(l)
}

func main() {
    printLocal()
    fmt.Println(g)
}
Outputlocal
global

Ici, nous utilisonsvar g = "global" pour créer une variable globale en dehors de la fonction. Ensuite, nous définissons la fonctionprintLocal(). À l'intérieur de la fonction, une variable locale appeléel est affectée puis imprimée. Le programme se termine en appelantprintLocal() puis en imprimant la variable globaleg.

Puisqueg est une variable globale, nous pouvons y faire référence dansprintLocal(). Modifions le programme précédent pour le faire: 

package main

import "fmt"


var g = "global"

func printLocal() {
    l := "local"
    fmt.Println(l)
    fmt.Println(g)
}

func main() {
    printLocal()
    fmt.Println(g)
}
Outputlocal
global
global

Nous commençons par déclarer une variable globaleg,var g = "global". Dans la fonctionmain, nous appelons la fonctionprintLocal, qui déclare une variable localel et l'affiche,fmt.Println(l). Ensuite,printLocal imprime la variable globaleg,fmt.Println(g). Même sig n’était pas défini dansprintLocal, il était toujours accessible car il était déclaré dans une portée globale. Enfin, la fonctionmain imprime égalementg.

Essayons maintenant d’appeler la variable locale en dehors de la fonction: 

package main

import "fmt"

var g = "global"

func printLocal() {
    l := "local"
    fmt.Println(l)
}

func main() {
    fmt.Println(l)
}
Outputundefined: l

Nous ne pouvons pas utiliser une variable locale en dehors de la fonction dans laquelle elle est assignée. Si vous essayez de le faire, vous recevrez une erreurundefined lors de la compilation.

Voyons un autre exemple où nous utilisons le même nom de variable pour une variable globale et une variable locale: 

package main

import "fmt"

var num1 = 5

func printNumbers() {
    num1 := 10
    num2 := 7

    fmt.Println(num1)
    fmt.Println(num2)
}

func main() {
    printNumbers()
    fmt.Println(num1)
}
Output10
7
5

Dans ce programme, nous avons déclaré la variablenum1 deux fois. Tout d'abord, nous avons déclarénum1 à la portée globale,var num1 = 5, et à nouveau dans la portée locale de la fonctionprintNumbers,num1 := 10. Lorsque nous imprimonsnum1 à partir du programmemain, nous voyons la valeur de5 imprimée. C'est parce quemain ne voit que la déclaration de variable globale. Cependant, lorsque nous imprimonsnum1 à partir de la fonctionprintNumbers, il voit la déclaration locale et affichera la valeur de10. Même siprintNumbers crée une nouvelle variable appeléenum1 et lui attribue une valeur de10, cela n'affecte pas l'instance globale denum1 avec la valeur de5.

Lorsque vous travaillez avec des variables, vous devez également déterminer quelles parties de votre programme devront avoir accès à chaque variable. adopter une variable globale ou locale en conséquence. Parmi les programmes Go, vous constaterez que les variables locales sont généralement plus courantes.

Constantes

Les constantes sont comme des variables, sauf qu'elles ne peuvent pas être modifiées une fois qu'elles ont été déclarées. Les constantes sont utiles pour définir une valeur qui sera utilisée plusieurs fois dans votre programme, mais ne devrait pas pouvoir changer.

Par exemple, si nous voulions déclarer le taux de taxe pour un système de panier, nous pourrions utiliser une constante, puis calculer la taxe dans différents domaines de notre programme. À un moment donné, si le taux d'imposition change, nous n'aurons plus qu'à modifier cette valeur d'un seul coup dans notre programme. Si nous utilisions une variable, il est possible que nous modifiions accidentellement la valeur quelque part dans notre programme, ce qui entraînerait un calcul incorrect.

Pour déclarer une constante, nous pouvons utiliser la syntaxe suivante: 

const shark = "Sammy"
fmt.Println(shark)
OutputSammy

Si nous essayons de modifier une constante après sa déclaration, nous obtiendrons une erreur de compilation: 

Outputcannot assign to shark

Les constantes peuvent êtreuntyped. Cela peut être utile lorsque vous travaillez avec des nombres tels que des données de type entier. Si la constante estuntyped, elle est explicitement convertie, alors que les constantestyped ne le sont pas. Voyons comment utiliser des constantes: 

package main

import "fmt"

const (
    year     = 365
    leapYear = int32(366)
)

func main() {
    hours := 24
    minutes := int32(60)
    fmt.Println(hours * year)
    fmt.Println(minutes * year)
    fmt.Println(minutes * leapYear)
}
Output8760
21900
21960

Si vous déclarez une constante avec un type, ce sera ce type exact. Ici, lorsque nous déclarons la constanteleapYear, nous la définissons comme type de donnéesint32. Il s'agit donc d'une constantetyped, ce qui signifie qu'elle ne peut fonctionner qu'avec les types de donnéesint32. La constanteyear que nous déclarons sans type, elle est donc considérée commeuntyped. De ce fait, vous pouvez l'utiliser avec n'importe quel type de données entier.

Lorsquehours a été défini, ilinferred qu'il était de typeint car nous ne lui avons pas explicitement donné un type,hours := 24. Lorsque nous avons déclaréminutes, nous l'avons explicitement déclaré commeint32,minutes := int32(60).

Passons maintenant à chaque calcul et pourquoi cela fonctionne: 

hours * year

Dans ce cas,hours est unint etyears estuntyped. Lorsque le programme se compile, il convertit explicitementyears enint, ce qui permet à l'opération de multiplication de réussir. 

minutes * year

Dans ce cas,minutes est unint32 etyear estuntyped. Lorsque le programme se compile, il convertit explicitementyears enint32, ce qui permet à l'opération de multiplication de réussir. 

minutes * leapYear

Dans ce cas,minutes est unint32 etleapYear est une constantetyped deint32. Le compilateur n'a rien à faire cette fois-ci car les deux variables sont déjà du même type.

Si nous essayons de multiplier deux types qui sonttyped et non compatibles, le programme ne compilera pas: 

fmt.Println(hours * leapYear)
Outputinvalid operation: hours * leapYear (mismatched types int and int32)

Dans ce cas,hours a été déduit comme unint, etleapYear a été explicitement déclaré comme unint32. Comme Go est un langage typé, unint et unint32 ne sont pas compatibles pour les opérations mathématiques. Pour les multiplier, vous auriez besoin deto convert one to a int32 or an int.

Conclusion

Dans ce didacticiel, nous avons examiné quelques cas d'utilisation courants de variables dans Go. Les variables constituent un élément de base important de la programmation et servent de symboles qui représentent la valeur d'un type de données que nous utilisons dans un programme.

Related