Les Variables

Introduction

In this article, we will see how to handle variables in go and some interesting functionalities of go that allow an easy manipulation of variables.

Qu'est ce que c'est une variable?

Une variable est le nom donné à un emplacement mémoire pour stocker une valeur de type précis. Il existe une variété de syntaxes pour déclarer les variables en go.

Déclaration d'une variable

var nom type est le le syntaxe pour declarer une variable.

package main

import "fmt"

func main() {  
    var age int // déclaration de la variable 
    fmt.Println("mon age est", age)
}

Exécution en playround

var age int est la déclaration d'une variable appelée age de type int. On n' a attribué aucune valeur à la variable. Si aucune valeur n'est attribuée à la variable, go initialise automatiquement celle-ci à la valeur zéro du type de variable. Dans ce cas, on a assigné à la variable age la valeur zéro. Si vous exécutez le programme, vous verrez ceci:

mon age est 0

Une variable peut être attribuée à n'importe quelle valeur de son type. dans le programme suivant, on peut attribuer à âge n'importe quelle valeur de type entier.

package main

import "fmt"

func main() {  
    var age int //  declaration de la variable
    fmt.Println("mon age est ", age)
    age = 19 //attribution
    fmt.Println("mon age est", age)
    age = 23 //attribution
    fmt.Println("mon nouveau age est", age)
}

Exécution en playground

Après l'exécution du programme, on aura la sortie suivante.

mon age is  0  
mon age is 19  
mon nouveau age est 23 

Déclaration d'une variable avec une valeur initiale

Lors de la déclaration d'une variable, on peut l'initialiser.

var nom type = valeurinitiale est le syntaxe pour déclarer une variable avec une valeur initiale.

package main

import "fmt"

func main() {  
    var age int = 19 //  declaration de la variable avec une  valeur initiale

    fmt.Println("mon age est", age)
}

Execution en playground

Dans le programme ci-dessus, age est une variable de type int et a comme valeur initiale 19. Si vous exécutez le programme ci-dessus, vous aurez la sortie suivante. Cela montre que la variable age a été initialisé à 19.

mon age est 19

l'inférence de types

Si une variable est initialisée à une valeur, Go peut automatiquement déduire le type de cette variable en utilisant uniquement la valeur initiale attribuée à cette variable. Par conséquent, si on initialise une variable, il n'est pas nécessaire de préciser son type.

Si on déclare une variable en utilisant le syntaxe var nom = valeurinitiale, Go va automatiquement déduire le type de la variable.

Dans l'exemple suivant, vous pouvez remarquer que le type int de la variable age est retiré vu que la variable est initialisée à la valeur 19.

package main

import "fmt"

func main() {  
    var age = 19 // déduction du type de la variable

    fmt.Println("mon age est", age)
}

Exécution en playground

Déclaration de plusieurs variables

Plusieurs variables peuvent être déclarées en une seule déclaration.

var nom1, nom2 type = valeurinitiale1, valeurinitiale2 est la déclaration pour déclarer plusieurs variables.

package main

import "fmt"

func main() {  
    var largeur, longueur int = 30, 20 //déclaration de plusieurs variables

    fmt.Println("largeur est", largeur, "longueur est", longueur)
}

Exécution en playground

Dans le cas des variables initialisées à des valeurs, on peut se passer de l'indication du type des variables.

Exemple:

package main

import "fmt"

func main() {  
    var largeur, longueur  = 30, 20 //"int" est abandonné

    fmt.Println("largeur est", largeur, "longueur est", longueur)
}

Exécution en playground

Le programme ci-dessus va afficher largeur est 30 longueur 20 comme sortie.

Comme vous l'avez constaté, si les valeurs initiales de largeur et longueur sont ignorées, elles seront automatiquement initialisées à 0.

package main

import "fmt"

func main() {  
    var largeur, longueru int
    fmt.Println("largeur est", largeur, "longueur est", longueur)
    largeur = 30
    longueur = 20
    fmt.Println("nouvelle largeur est", largeur, "nouvelle longueur est ", longueur)
}

Exécution en playground

le programme ci-dessus va afficher :

largeur est 0 longueur est 0
nouvelle largeur est 30 nouvelle longueur est 20

Il pourrait y'avoir des cas où on voudra déclarer des variables de types différents dans une seule déclaration. Le syntaxe pour faire cela est comme suivant:

var (  
      nom1 = valeurinitiale1,
      nom2 = valeurinitiale2
)

Le programme suivant utilise le syntaxe ci-dessus pour déclarer des variables de types différents.

package main

import "fmt"

func main() {  
    var (
        nom   = "émilie"
        age    = 23
        longueur int
    )
    fmt.Println("mon nom is", nom, ", age est", age, "et longuer est", longueur)
}

Exécution en playground

Ici on déclare une variable nom de type string, age et longueur de type int. l'exécution du programme ci-dessus donnerait: mon nom est émilie, age est 23 et longueur est 0

Une déclaration abrégée

Pour abréger une déclaration, on a recours à l'opérateur :=.

nom := valeurinitiale est le syntaxe abrégé pour déclarer une variable.

package main

import "fmt"

func main() {  
    name, age := "émilie", 23 // declaration concise

    fmt.Println("mon nom est", nom, "age est", age)
}

Exécution en playground

Si vous exécutez le programme ci-dessus, vous aurez le résultat suivant:

mon nom est émilie age est 23

Les déclarations abrégées exigent l'initialisation des variables. Le programme suivant va signaler une erreur cannot assign 1 values to 2 variables car la variable age n'est pas initialisée.

package main

import "fmt"

func main() {  
    nom, age := "émilie" //error

    fmt.Println("mon nom est", nom, "age est", age)
}

Exécution en playground

Les déclarations abrégées ne peuvent être utilisées que si au moins l'un des variables qui se trouvent à gauche de := est nouvellement déclarée.

Exemple:

package main

import "fmt"

func main() {  
    a, b := 10, 20 // déclaration des variables a et b
    fmt.Println("a est", a, "b est", b)
    b, c := 30, 40 // b déjà déclaré  mais  c est nouvelle
    fmt.Println("b est", b, "c est", c)
    b, c = 87, 60 // attribuer de nouvelles valeurs aux variables  b et c qui ont été déjà déclarées 
    fmt.Println(" b  changée est ", b, "c est", c)
}

Exécution en playground

le résultat est comme suivant:

a est 10 b est 20  
b est 30 c est 40 
b changée est 87 c est 60  

Alors que si on exécute le programme suivant:

package main

import "fmt"

func main() {  
    a, b := 10, 20 //a et b declarées
    fmt.Println("a est", a, "b est", b)
    a, b := 30, 40 //erreur , pas de nouvelles variables
}

Exécution en playground

Une erreur va être signalée no new variables on left side of := car les deux variables a et b sont déjà déclarées et qu'il n'y a pas de nouvelles variables à gauche de :=

Ont peut faire des attributions aux variables lors de l'exécution du programme.

Exemple

package main

import (  
    "fmt"
    "math"
)

func main() {  
    a, b := 48.2, 92.9
    c := math.Min(a, b)
    fmt.Println("la valeur minimale est ", c)
}

Exécution en playground

le résultat de l'exécution est:

la valeur minimale est 48.2

Puisque Go est un langage fortement typé, on ne peut pas attribuer une valeur d'un certain type à une variable d'un type différent, une erreur sera signalée cannot use "naveen" (type string) as type int in assignment.

Exemple:

package main

func main() {  
    age := 23      // age est int
    age = "émilie" // error car on est entrain d'essayer d'attribuer un string à unev ariable de type int
}

Exécution en playground

---

Posted on Utopian.io - Rewarding Open Source Contributors

---