Go
Les variables

Syntaxe

• var x int // déclare la variable x avec le type int
• var s string // déclare la variable s avec le type string
• x = 4 // définir la valeur x
• s = "foo" // Définit la valeur s
• y: = 5 // déclare et définit y inférant son type à int
• f: = 4.5 // déclare et définit f en inférant son type à float64
• b: = "bar" // déclare et définit b en inférant son type sur string

Déclaration de base des variables

Go est un langage de type statique, ce qui signifie que vous devez généralement déclarer le type des variables que vous utilisez.

// Basic variable declaration. Declares a variable of type specified on the right.
// The variable is initialized to the zero value of the respective type.
var x int
var s string
var p Person // Assuming type Person struct {}

// Assignment of a value to a variable
x = 3

// Short declaration using := infers the type
y := 4

u := int64(100)    // declare variable of type int64 and init with 100 
var u2 int64 = 100 // declare variable of type int64 and init with 100

Affectation de variables multiples

Dans Go, vous pouvez déclarer plusieurs variables en même temps.

// You can declare multiple variables of the same type in one line
var a, b, c string

var d, e string = "Hello", "world!"

// You can also use short declaration to assign multiple variables
x, y, z := 1, 2, 3

foo, bar := 4, "stack" // `foo` is type `int`, `bar` is type `string`

Si une fonction renvoie plusieurs valeurs, vous pouvez également affecter des valeurs aux variables en fonction des valeurs de retour de la fonction.

func multipleReturn() (int, int) {
    return 1, 2
}

x, y := multipleReturn() // x = 1, y = 2

func multipleReturn2() (a int, b int) {
    a = 3
    b = 4
    return
}

w, z := multipleReturn2() // w = 3, z = 4

Identifiant vide

Go va générer une erreur quand il y a une variable non utilisée, afin de vous encourager à écrire un meilleur code. Cependant, il existe des situations où vous n'avez pas besoin d'utiliser une valeur stockée dans une variable. Dans ces cas, vous utilisez un "identifiant vide" _ pour affecter et ignorer la valeur attribuée.

Un identificateur vide peut recevoir une valeur de n'importe quel type et est le plus souvent utilisé dans des fonctions renvoyant plusieurs valeurs.

Valeurs de retour multiples

func SumProduct(a, b int) (int, int) {
    return a+b, a*b
}

func main() {
    // I only want the sum, but not the product
    sum, _ := SumProduct(1,2) // the product gets discarded
    fmt.Println(sum) // prints 3
}

Utiliser la range

func main() {

    pets := []string{"dog", "cat", "fish"}

    // Range returns both the current index and value
    // but sometimes you may only want to use the value
    for _, pet := range pets {
        fmt.Println(pet)
    }

}

Vérification du type d'une variable

Il existe des situations où vous ne savez pas quel type est une variable lorsqu'elle est renvoyée par une fonction. Vous pouvez toujours vérifier le type d'une variable en utilisant var.(type) si vous n'êtes pas sûr du type:

x := someFunction() // Some value of an unknown type is stored in x now

switch x := x.(type) {
    case bool:
        fmt.Printf("boolean %t\n", x)             // x has type bool
    case int:
        fmt.Printf("integer %d\n", x)             // x has type int
    case string:
        fmt.Printf("pointer to boolean %s\n", x) // x has type string
    default:
        fmt.Printf("unexpected type %T\n", x)     // %T prints whatever type x is
}