Tutoriel pour apprendre le langage Go par l'exemple

Notre premier programme va afficher le classique « hello world »

Voici le code source complet.

package main

import "fmt"

func main() {
    fmt.Println("hello world")
}

Pour exécuter le programme, mettez le code dans le fichier hello-world.go et lancez go run.

$ go run hello-world.go
hello world

Parfois on veut compiler pour obtenir un exécutable. Nous pouvons faire cela avec go build.

$ go build hello-world.go
$ ls
hello-world    hello-world.go

On peut ensuite exécuter le fichier binaire

$ ./hello-world
hello world

Maintenant que l'on sait exécuter et compiler des programmes en Go, apprenons-en plus sur le langage.

Go a plusieurs types de valeurs, incluant les chaînes de caractères, les entiers, les nombres flottants, les booléens, etc. Voici quelques exemples basiques.

Les chaînes de caractères, que l'on peut concaténer avec +.

    fmt.Println("go" + "lang")

Les entiers et les flottants.

    fmt.Println("1+1 =", 1+1)
    fmt.Println("7.0/3.0 =", 7.0/3.0)

Les booléens, avec les opérateurs booléens tels qu'on les attend.

    fmt.Println(true && false)
    fmt.Println(true || false)
    fmt.Println(!true)
}

package main

import "fmt"

func main() {

    fmt.Println("go" + "lang")

    fmt.Println("1+1 =", 1+1)
    fmt.Println("7.0/3.0 =", 7.0/3.0)

    fmt.Println(true && false)
    fmt.Println(true || false)
    fmt.Println(!true)
}

$ go run values.go
golang
1+1 = 2
7.0/3.0 = 2.3333333333333335
false
true
false

En Go, les variables sont déclarées explicitement et utilisées par le compilateur, par exemple pour vérifier que le type de retour des appels de fonction est correct.

var déclare une ou plusieurs variables.

    var a string = "initial"
    fmt.Println(a)

On peut déclarer plusieurs variables à la fois

    var b, c int = 1, 2
    fmt.Println(b, c)

Go déduira le type des variables non initialisées

    var d = true
    fmt.Println(d)

Les variables déclarées sans être initialisées ont une valeur nulle. Par exemple, la valeur nulle d'un int est 0.

    var e int
    fmt.Println(e)

La syntaxe := est un raccourci pour déclarer et initialiser une variable, par exemple pour var f string = "short" ici.

    f := "short"
    fmt.Println(f)
}

package main

import "fmt"

func main() {

    var a string = "initial"
    fmt.Println(a)

    var b, c int = 1, 2
    fmt.Println(b, c)

    var d = true
    fmt.Println(d)

    var e int
    fmt.Println(e)

    f := "short"
    fmt.Println(f)
}

$ go run variables.go
initial
1 2
true
0
short

Go supporte les constantes de caractères, chaînes de caractères, booléens et valeurs numériques

const déclare une valeur constante.

const s string = "constant"

func main() {
    fmt.Println(s)

Le mot-clé const peut apparaître à chaque endroit où l'on peut mettre le mot-clé var

    const n = 500000000

Les expressions constantes réalisent les opérations arithmétiques avec une précision arbitraire.

    const d = 3e20 / n
    fmt.Println(d)

Une constante numérique n'a pas de type jusqu'à ce qu'on lui en donne un, par exemple via un cast explicite

    fmt.Println(int64(d))

On peut donner un type à un nombre en l'utilisant dans un contexte qui en requiert un, tel qu'une affectation ou un appel de fonction. Par exemple ici, math.Sin attend un float64.

    fmt.Println(math.Sin(n))
}

package main

import "fmt"
import "math"

const s string = "constant"

func main() {
    fmt.Println(s)

    const n = 500000000

    const d = 3e20 / n
    fmt.Println(d)

    fmt.Println(int64(d))

    fmt.Println(math.Sin(n))
}

$ go run constant.go 
constant
6e+11
600000000000
-0.28470407323754404

x := val est la version courte pour var x type = val.

func main() {
    x := "Hello var"
    fmt.Println(x)
}

package main

import "fmt"

func main() {

    x := "Hello var"
    fmt.Println(x)
}

$ go run short-declarations.go
Hello var

for est la seule manière de faire une boucle en Go. Voici trois types basiques de boucles for.

La plus simple, avec une unique condition.

    i := 1
    for i <= 3 {
        fmt.Println(i)
        i = i + 1
    }

La boucle for classique, en trois étapes : initialisation/condition/incrémentation.

    for j := 7; j <= 9; j++ {
        fmt.Println(j)
    }

for sans condition va boucler indéfiniment, jusqu'à ce qu'on break pour en sortir, ou qu'un return fasse sortir de la fonction correspondante.

    for {
        fmt.Println("loop")
        break
    }
}

package main

import "fmt"

func main() {

    i := 1
    for i <= 3 {
        fmt.Println(i)
        i = i + 1
    }

    for j := 7; j <= 9; j++ {
        fmt.Println(j)
    }

    for {
        fmt.Println("loop")
        break
    }
}

$ go run for.go
1
2
3
7
8
9
loop

Nous verrons d'autres formes de boucles for plus tard lorsque nous verrons le mot-clé range, les canaux et d'autres structures de données.

Les conditions avec if et else sont simples en Go

Voici un exemple simple.

    if 7%2 == 0 {
        fmt.Println("7 is even")
    } else {
        fmt.Println("7 is odd")
    }

On peut avoir un if sans else.

    if 8%4 == 0 {
        fmt.Println("8 is divisible by 4")
    }

Une déclaration peut précéder la condition. Toute variable déclarée là est disponible dans toutes les branches.

    if num := 9; num < 0 {
        fmt.Println(num, "is negative")
    } else if num < 10 {
        fmt.Println(num, "has 1 digit")
    } else {
        fmt.Println(num, "has multiple digits")
    }
}

À noter qu'il n'y a pas besoin de parenthèses autour des conditions en Go, mais que les accolades sont requises.

package main

import "fmt"

func main() {

    if 7%2 == 0 {
        fmt.Println("7 is even")
    } else {
        fmt.Println("7 is odd")
    }

    if 8%4 == 0 {
        fmt.Println("8 is divisible by 4")
    }

    if num := 9; num < 0 {
        fmt.Println(num, "is negative")
    } else if num < 10 {
        fmt.Println(num, "has 1 digit")
    } else {
        fmt.Println(num, "has multiple digits")
    }
}

$ go run if-else.go 
7 is odd
8 is divisible by 4
9 has 1 digit

Il n'y a pas de if ternaire en Go, donc il faut utiliser le if complet même pour des conditions basiques.

Les expressions Switch réalisent des conditions à travers plusieurs branches.

Voici un switch basique.

    i := 2
    fmt.Print("write ", i, " as ")
    switch i {
    case 1:
        fmt.Println("one")
    case 2:
        fmt.Println("two")
    case 3:
        fmt.Println("three")
    }

On peut utiliser des virgules pour séparer plusieurs expressions dans un même case. Nous utilisons également le cas default optionnel dans cet exemple.

    switch time.Now().Weekday() {
    case time.Saturday, time.Sunday:
        fmt.Println("it's the weekend")
    default:
        fmt.Println("it's a weekday")
    }

switch sans expression est une autre manière de faire un if/else. Vous pouvez aussi voir que les expressions dans case peuvent être non constantes.

    t := time.Now()
    switch {
    case t.Hour() < 12:
        fmt.Println("it's before noon")
    default:
        fmt.Println("it's after noon")
    }

Un switch sur les types switch compare des types et non des valeurs. Vous pouvez utiliser cela pour découvrir le type correspondant à la valeur d'une interface. Dans cet exemple, la variable t aura comme valeur le type de la variable i.

    whatAmI := func(i interface{}) string {
        switch t := i.(type) {
        case bool:
            return "I am a bool"
        case int:
            return "I am an int"
        default:
            return fmt.Sprintf("Can't handle type %T", t)
        }
    }
    fmt.Println(whatAmI(1))
    fmt.Println(whatAmI(true))
    fmt.Println(whatAmI("hey"))
}

package main

import "fmt"
import "time"

func main() {

    i := 2
    fmt.Print("write ", i, " as ")
    switch i {
    case 1:
        fmt.Println("one")
    case 2:
        fmt.Println("two")
    case 3:
        fmt.Println("three")
    }

    switch time.Now().Weekday() {
    case time.Saturday, time.Sunday:
        fmt.Println("it's the weekend")
    default:
        fmt.Println("it's a weekday")
    }

    t := time.Now()
    switch {
    case t.Hour() < 12:
        fmt.Println("it's before noon")
    default:
        fmt.Println("it's after noon")
    }

    whatAmI := func(i interface{}) string {
        switch t := i.(type) {
        case bool:
            return "I am a bool"
        case int:
            return "I am an int"
        default:
            return fmt.Sprintf("Can't handle type %T", t)
        }
    }
    fmt.Println(whatAmI(1))
    fmt.Println(whatAmI(true))
    fmt.Println(whatAmI("hey"))
}

$ go run switch.go 
write 2 as two
it's the weekend
it's before noon
I am an int
I am a bool
Can't handle type string

En Go, un tableau est une séquence numérotée d'éléments d'une longueur donnée.

Ici, nous créons un tableau a qui contiendra exactement cinq int. Le type des éléments et la longueur font tous les deux partie du type du tableau. Par défaut, les valeurs des éléments du tableau sont nulles, c'est-à-dire 0 chez les int.

    var a [5]int
    fmt.Println("emp:", a)

On peut affecter la valeur à un indice particulier avec la syntaxe array[index] = value. On obtient sa valeur avec array[index].

    a[4] = 100
    fmt.Println("set:", a)
    fmt.Println("get:", a[4])

La fonction len, intégrée au langage, renvoie la longueur du tableau.

    fmt.Println("len:", len(a))

On peut utiliser cette syntaxe pour déclarer et initialiser un tableau en une ligne.

    b := [5]int{1, 2, 3, 4, 5}
    fmt.Println("dcl:", b)

Les tableaux sont à une dimension, mais on peut les composer pour obtenir des structures de données multidimensionnelles.

    var twoD [2][3]int
    for i := 0; i < 2; i++ {
        for j := 0; j < 3; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

package main

import "fmt"

func main() {

    var a [5]int
    fmt.Println("emp:", a)

    a[4] = 100
    fmt.Println("set:", a)
    fmt.Println("get:", a[4])

    fmt.Println("len:", len(a))

    b := [5]int{1, 2, 3, 4, 5}
    fmt.Println("dcl:", b)

    var twoD [2][3]int
    for i := 0; i < 2; i++ {
        for j := 0; j < 3; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

À noter que les tableaux apparaissent sous la forme [v1 v2 v3 ...] lorsqu'on les affiche avec fmt.Println.

$ go run arrays.go
emp: [0 0 0 0 0]
set: [0 0 0 0 100]
get: 100
len: 5
dcl: [1 2 3 4 5]
2d:  [[0 1 2] [1 2 3]]

En Go, on utilise les slices bien plus souvent que les tableaux. C'est ce que nous allons voir maintenant.

Les slices sont un type de données clé en Go. Ils sont bien plus puissants que les tableaux pour manipuler les séquences de données.

Contrairement aux tableaux, les slices sont typées uniquement par les éléments qu'elles contiennent (pas par le nombre d'éléments). Pour créer une slice vide de longueur non nulle, on utilise la méthode intégrée make. Ici, on crée une slice de string de longueur 3 (initialement de valeurs nulles).

func main() {

    s := make([]string, 3)
    fmt.Println("emp:", s)

On peut affecter et retrouver les valeurs comme avec les tableaux.

    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("set:", s)
    fmt.Println("get:", s[2])

len renvoie la longueur de la slice comme prévu.

    fmt.Println("len:", len(s))

En plus de ces opérations basiques, les slices en supportent plusieurs qui les rendent plus riches que les tableaux. L'une d'elles est la méthode prédéfinie append, qui renvoie une slice avec une ou plusieurs nouvelles valeurs. À noter que la nouvelle slice est renvoyée par append : la slice originale, passée en paramètre, n'est pas modifiée.

    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println("apd:", s)

On peut également copier les slices. Ici, on crée une slice c vide, de même longueur que s et on copie les valeurs de s dans c.

    c := make([]string, len(s))
    copy(c, s)
    fmt.Println("cpy:", c)

Les slices possèdent un opérateur « slice » avec la syntaxe slice[debut:fin]. Par exemple, l'exemple suivant crée une slice avec les éléments s[2], s[3] et s[4].

    l := s[2:5]
    fmt.Println("sl1:", l)

Ceci crée une slice jusqu'à (mais sans) s[5].

    l = s[:5]
    fmt.Println("sl2:", l)

Et ceci crée une slice à partir de (et incluant) s[2].

    l = s[2:]
    fmt.Println("sl3:", l)

On peut déclarer et initialiser une variable pour une slice en une ligne également. À la différence des tableaux, on ne précise pas la longueur dans [].

    t := []string{"g", "h", "i"}
    fmt.Println("dcl:", t)

Les slices peuvent être composées en structures de données multidimensionnelles. La longueur des slices internes peut varier, contrairement aux tableaux multidimensionnels.

    twoD := make([][]int, 3)
    for i := 0; i < 3; i++ {
        innerLen := i + 1
        twoD[i] = make([]int, innerLen)
        for j := 0; j < innerLen; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

package main

import "fmt"

func main() {

    s := make([]string, 3)
    fmt.Println("emp:", s)

    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("set:", s)
    fmt.Println("get:", s[2])

    fmt.Println("len:", len(s))

    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println("apd:", s)

    c := make([]string, len(s))
    copy(c, s)
    fmt.Println("cpy:", c)

    l := s[2:5]
    fmt.Println("sl1:", l)

    l = s[:5]
    fmt.Println("sl2:", l)

    l = s[2:]
    fmt.Println("sl3:", l)

    t := []string{"g", "h", "i"}
    fmt.Println("dcl:", t)

    twoD := make([][]int, 3)
    for i := 0; i < 3; i++ {
        innerLen := i + 1
        twoD[i] = make([]int, innerLen)
        for j := 0; j < innerLen; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

À noter que, bien que les slices soient un type différent des tableaux, elles s'affichent de la même manière avec fmt.Println.

$ go run slices.go
emp: [  ]
set: [a b c]
get: c
len: 3
apd: [a b c d e f]
cpy: [a b c d e f]
sl1: [c d e]
sl2: [a b c d e]
sl3: [c d e f]
dcl: [g h i]
2d:  [[0] [1 2] [2 3 4]]

Vous pouvez lire ce bon article de l'équipe Go pour plus de détails sur le design et l'implémentation des slices en Go.

Maintenant que nous avons vu les tableaux et les slices, nous allons regarder une autre structure de données clé : les maps.

Les maps sont un type de données associatif (parfois appelé hashes ou dicts dans d'autres langages).

Pour créer une map vide, on utilise la méthode intégrée make : make(map[key-type]val-type).

    m := make(map[string]int)

On affecte les paires clé/valeur avec la syntaxe name[key] = val :

    m["k1"] = 7
    m["k2"] = 13

Afficher une map via Println affichera toutes les paires clé/valeur.

    fmt.Println("map:", m)

On récupère une valeur avec name[key].

    v1 := m["k1"]
    fmt.Println("v1: ", v1)

La méthode intégrée len renvoie le nombre de paires clé/valeur lorsqu'on l'appelle sur une map :

    fmt.Println("len:", len(m))

La méthode prédéfinie delete supprime d'une map une paire clé/valeur :

    delete(m, "k2")
    fmt.Println("map:", m)

La seconde valeur de retour optionnelle lorsque l'on récupère une valeur dans une map indique si la clé était présente. Cela peut être utilisé pour lever l'ambiguïté entre des clés manquantes et des clés de valeur nulle, comme 0 ou "". Ici, nous n'avions pas besoin de la valeur en elle-même, donc nous l'avions ignorée avec l'identifieur vide _.

    _, prs := m["k2"]
    fmt.Println("prs:", prs)

On peut aussi déclarer et initialiser une nouvelle map sur la même ligne avec cette syntaxe.

    n := map[string]int{"foo": 1, "bar": 2}
    fmt.Println("map:", n)
}

package main

import "fmt"

func main() {

    m := make(map[string]int)

    m["k1"] = 7
    m["k2"] = 13

    fmt.Println("map:", m)

    v1 := m["k1"]
    fmt.Println("v1: ", v1)

    fmt.Println("len:", len(m))

    delete(m, "k2")
    fmt.Println("map:", m)

    _, prs := m["k2"]
    fmt.Println("prs:", prs)

    n := map[string]int{"foo": 1, "bar": 2}
    fmt.Println("map:", n)
}

À noter que les maps apparaissent sous la forme map[k:v k:v] lorsqu'on les affiche avec fmt.Println :

$ go run maps.go
map: map[k1:7 k2:13]
v1:  7
len: 2
map: map[k1:7]
prs: false
map: map[foo:1 bar:2]

range itère sur les éléments de différents types de structures de données. Voyons comment utiliser range avec certaines structures de données que nous avons déjà rencontrées.

Ici on utilise range pour additionner les nombres d'une slice. Cela fonctionne de la même manière avec un tableau.

func main() {
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    fmt.Println("sum:", sum)

range sur les tableaux et les slices fournit à la fois la clé et la valeur pour chaque entrée. Au-dessus, nous n'avions pas besoin de la clé, donc nous l'avions ignorée avec l'identifieur blanc _. On a cependant parfois besoin de la récupérer.

    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }

range sur une map itère sur les paires clé/valeur.

    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }

range sur une chaîne itère sur les points de code Unicode. La première valeur est l'index de l'octet de départ de la rune, et le second la rune elle-même.

    for i, c := range "go" {
        fmt.Println(i, c)
    }
}

package main

import "fmt"

func main() {

    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    fmt.Println("sum:", sum)

    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }

    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }

    for i, c := range "go" {
        fmt.Println(i, c)
    }
}

$ go run range.go 
sum: 9
index: 1
a -> apple
b -> banana
0 103
1 111

Les fonctions sont centrales en Go. Nous allons les découvrir à travers quelques exemples différents.

Voici une fonction qui prend deux int en paramètres et renvoie leur somme, un int.

func plus(a int, b int) int {

Go a besoin de retours explicites : il ne renverra pas automatiquement la valeur de la dernière expression.

    return a + b
}

Quand vous avez plusieurs paramètres consécutifs du même type, vous pouvez vous passer des déclarations de type jusqu'au dernier, qui le déclare.

func plusPlus(a, b, c int) int {
    return a + b + c
}

On appelle une fonction comme on s'y attend, avec nom(arguments)

func main() {

    res := plus(1, 2)
    fmt.Println("1+2 =", res)
    res = plusPlus(1, 2, 3)
    fmt.Println("1+2+3 =", res)
}

package main

import "fmt"

func plus(a int, b int) int {

    return a + b
}

func plusPlus(a, b, c int) int {
    return a + b + c
}

func main() {

    res := plus(1, 2)
    fmt.Println("1+2 =", res)

    res = plusPlus(1, 2, 3)
    fmt.Println("1+2+3 =", res)
}

$ go run functions.go 
1+2 = 3
1+2+3 = 6

Les fonctions ont plusieurs autres fonctionnalités particulières. L'une d'entre elles, c'est les valeurs de retour multiples, que nous allons maintenant aborder.

Go supporte de base les valeurs de retour multiples. On s'en sert souvent en Go, par exemple pour renvoyer le résultat et la valeur d'erreur d'une fonction.

Le (int, int) dans cette signature de fonction montre que la fonction renvoie deux int.

func vals() (int, int) {
    return 3, 7
}

Les valeurs de retour peuvent également être nommées. Cela peut être utile pour aider à documenter le rôle de chaque valeur de retour. Ces noms peuvent être référencés dans le corps de la fonction, comme n'importe quelle autre variable. Un retour nu avec un simple return utilisera les valeurs de ces variables comme résultat.

func splitPrice(price float32) (dollars, cents int) {
    dollars = int(price)
    cents = int((price - float32(dollars)) * 100.0)
    return
}

Un cas d'usage, c'est pour modifier une valeur de retour à l'intérieur d'une clause defer :

func getFileSize() (file_size int64, had_error bool) {
    f, err := os.Open("/tmp/dat")
    if err != nil {
        return 0, true
    }
    defer func() {
        if err := f.Close(); err != nil {
            had_error = true
        }
    }()

    fi, err := f.Stat()
    if err != nil {
        return 0, true
    }
    return fi.Size(), false
}

func main() {

Ici nous utilisons les deux valeurs de retour différentes de l'appel avec une affectation multiple.

    a, b := vals()
    fmt.Println(a)
    fmt.Println(b)

Si vous voulez seulement un sous-ensemble des valeurs de retour, vous pouvez utiliser l'identifieur blanc _.

    _, c := vals()
    fmt.Println(c)

    dollars, cents := splitPrice(12.42)
    fmt.Println(dollars, cents)
    file_size, had_error := getFileSize()
    fmt.Println(file_size, had_error)
}

package main

import "fmt"

func vals() (int, int) {
    return 3, 7
}

func splitPrice(price float32) (dollars, cents int) {
    dollars = int(price)
    cents = int((price - float32(dollars)) * 100.0)
    return
}

func getFileSize() (file_size int64, had_error bool) {
    f, err := os.Open("/tmp/dat")
    if err != nil {
        return 0, true
    }
    defer func() {
        if err := f.Close(); err != nil {
            had_error = true
        }
    }()

    fi, err := f.Stat()
    if err != nil {
        return 0, true
    }
    return fi.Size(), false
}

func main() {

    a, b := vals()
    fmt.Println(a)
    fmt.Println(b)

    _, c := vals()
    fmt.Println(c)

    dollars, cents := splitPrice(12.42)
    fmt.Println(dollars, cents)

    file_size, had_error := getFileSize()
    fmt.Println(file_size, had_error)
}

$ go run multiple-return-values.go
3
7
7
12 42
0 true

Accepter un nombre variable d'arguments est une autre possibilité sympa des fonctions en Go. Nous allons regarder cela maintenant.

Les fonctions variadiques peuvent être appelées avec n'importe quel nombre d'arguments. Par exemple fmt.Println est une fonction variadique courante.

Voici une fonction qui va prendre un nombre arbitraire d'int comme arguments.

func sum(nums ...int) {
    fmt.Print(nums, " ")
    total := 0
    for _, num := range nums {
        total += num
    }
    fmt.Println(total)
}

func main() {

Les fonctions variadiques peuvent être appelées de la manière habituelle, avec des arguments individuels.

    sum(1, 2)
    sum(1, 2, 3)

Si vous avez déjà plusieurs arguments dans une slice, vous pouvez les appliquer à la fonction variadique en utilisant func(slice...) comme ceci.

    nums := []int{1, 2, 3, 4}
    sum(nums...)
}

package main

import "fmt"

func sum(nums ...int) {
    fmt.Print(nums, " ")
    total := 0
    for _, num := range nums {
        total += num
    }
    fmt.Println(total)
}

func main() {

    sum(1, 2)
    sum(1, 2, 3)

    nums := []int{1, 2, 3, 4}
    sum(nums...)
}

$ go run variadic-functions.go 
[1 2] 3
[1 2 3] 6
[1 2 3 4] 10

Un autre aspect clé des fonctions en Go, c'est la possibilité d'en faire des fermetures, ce que nous allons regarder ensuite.

Go supporte les fonctions anonymes, qui peuvent former une closure (fermeture ou clôture en français.) Les fonctions anonymes sont utiles lorsque l'on veut définir des fonctions à la volée, sans avoir à les nommer.

Cette fonction intSeq renvoie une autre fonction, qui est définie anonymement dans le corps de intSeq. La fonction retournée embarque la variable i pour former une clôture.

func intSeq() func() int {
    i := 0
    return func() int {
        i += 1
        return i
    }
}

func main() {

On appelle intSeq, et assigne le résultat (une fonction) à nextInt. Cette fonction capture sa propre valeur de i, qui sera mise à jour à chaque fois que l'on appellera nextInt.

    nextInt := intSeq()

Voyez l'effet de la fermeture en appelant nextInt plusieurs fois.

    fmt.Println(nextInt())
    fmt.Println(nextInt())
    fmt.Println(nextInt())

Pour confirmer que l'état est unique à cette fonction particulière, créez et testez-en une nouvelle.

    newInts := intSeq()
    fmt.Println(newInts())
}

package main

import "fmt"

func intSeq() func() int {
    i := 0
    return func() int {
        i += 1
        return i
    }
}

func main() {

    nextInt := intSeq()

    fmt.Println(nextInt())
    fmt.Println(nextInt())
    fmt.Println(nextInt())

    newInts := intSeq()
    fmt.Println(newInts())
}

$ go run closures.go
1
2
3
1

La dernière fonctionnalité des fonctions que nous allons regarder pour le moment, c'est la récursivité.

Go supporte la récursivité. Voici l'exemple classique de la factorielle.

Cette fonction fact s'appelle elle-même jusqu'à ce qu'elle atteigne le cas de base, fact(0).

func fact(n int) int {
    if n == 0 {
        return 1
    }
    return n * fact(n-1)
}
func main() {
    fmt.Println(fact(7))
}

package main

import "fmt"

func fact(n int) int {
    if n == 0 {
        return 1
    }
    return n * fact(n-1)
}

func main() {
    fmt.Println(fact(7))
}

$ go run recursion.go 
5040

Go supporte les pointeurs, ce qui permet de passer des références vers des valeurs dans les programmes.

Nous allons voir comment fonctionnent les pointeurs, par opposition aux valeurs, dans deux fonctions : zeroval et zeroptr. zeroval a un paramètre, donc les arguments lui sont passés par valeur. zeroval aura une copie de ival distincte de celle de la fonction appelante.

func zeroval(ival int) {
    ival = 0
}

zeroptr a cette fois-ci un paramètre *int, c'est-à-dire un pointeur sur un int. Le *iptr dans le corps de la fonction permet de déréférencer le pointeur de son adresse mémoire pour obtenir la valeur à cette adresse. Assigner une valeur à un pointeur déréférencé change la valeur à l'adresse référencée.

func zeroptr(iptr *int) {
    *iptr = 0
}
func main() {
    i := 1
    fmt.Println("initial:", i)

    zeroval(i)
    fmt.Println("zeroval:", i)

La syntaxe &i donne l'adresse mémoire de i, c'est-à-dire un pointeur vers i.

    zeroptr(&i)
    fmt.Println("zeroptr:", i)

On peut afficher les pointeurs également.

    fmt.Println("pointer:", &i)
}

package main

import "fmt"

func zeroval(ival int) {
    ival = 0
}

func zeroptr(iptr *int) {
    *iptr = 0
}

func main() {
    i := 1
    fmt.Println("initial:", i)

    zeroval(i)
    fmt.Println("zeroval:", i)

    zeroptr(&i)
    fmt.Println("zeroptr:", i)

    fmt.Println("pointer:", &i)
}

zeroval ne change pas le i dans main, mais zeroptr le fait, car elle a une référence vers l'adresse mémoire de cette variable.

$ go run pointers.go
initial: 1
zeroval: 1
zeroptr: 0
pointer: 0x42131100

Les structures en Go sont des collections de champs typés. Elles sont utiles pour regrouper les données.

Cette structure person a des champs name et age.

type person struct {
    name string
    age  int
}

func main() {

Cette syntaxe crée une nouvelle structure.

    fmt.Println(person{"Bob", 20})

On peut nommer les champs lorsqu'on initialise une structure.

    fmt.Println(person{name: "Alice", age: 30})

Les champs non spécifiés seront de valeur nulle.

    fmt.Println(person{name: "Fred"})

Un préfixe & fournit un pointeur sur la structure.

    fmt.Println(&person{name: "Ann", age: 40})

On accède aux champs de la structure avec un point.

    s := person{name: "Sean", age: 50}
    fmt.Println(s.name)

On peut aussi utiliser le point avec des pointeurs de structure : les pointeurs sont automatiquement déréférencés.

    sp := &s
    fmt.Println(sp.age)

Les structures sont mutables.

    sp.age = 51
    fmt.Println(sp.age)
}

package main

import "fmt"

type person struct {
    name string
    age  int
}

func main() {

    fmt.Println(person{"Bob", 20})

    fmt.Println(person{name: "Alice", age: 30})

    fmt.Println(person{name: "Fred"})

    fmt.Println(&person{name: "Ann", age: 40})

    s := person{name: "Sean", age: 50}
    fmt.Println(s.name)

    sp := &s
    fmt.Println(sp.age)

    sp.age = 51
    fmt.Println(sp.age)
}

$ go run structs.go
{Bob 20}
{Alice 30}
{Fred 0}
&{Ann 40}
Sean
50
51

Go supporte des méthodes définies dans les structures.

Cette méthode area a un type receveur *rect.

func (r *rect) area() int {
    return r.width * r.height
}

Les méthodes peuvent être définies soit pour un pointeur, soit pour une valeur de type receveur. Voici un exemple avec une valeur.

func (r rect) perim() int {
    return 2*r.width + 2*r.height
}

func main() {
    r := rect{width: 10, height: 5}

Ici on appelle les deux méthodes définies dans notre structure.

    fmt.Println("area: ", r.area())
    fmt.Println("perim:", r.perim())

Go gère automatiquement la conversion entre valeur et pointeur pour les appels de méthode. On peut vouloir utiliser un type receveur pointeur pour éviter la copie lors des appels de méthode ou pour modifier l'objet fourni.

    rp := &r
    fmt.Println("area: ", rp.area())
    fmt.Println("perim:", rp.perim())
}

package main

import "fmt"

type rect struct {
    width, height int
}

func (r *rect) area() int {
    return r.width * r.height
}

func (r rect) perim() int {
    return 2*r.width + 2*r.height
}

func main() {
    r := rect{width: 10, height: 5}

    fmt.Println("area: ", r.area())
    fmt.Println("perim:", r.perim())

    rp := &r
    fmt.Println("area: ", rp.area())
    fmt.Println("perim:", rp.perim())
}

$ go run methods.go 
area:  50
perim: 30
area:  50
perim: 30

Nous allons ensuite aborder les mécanismes pour regrouper et nommer les ensembles de méthodes liés : les interfaces.

Les interfaces sont des collections nommées de signatures de méthodes.

Voici une interface simple pour une forme géométrique.

type geometry interface {
    area() float64
    perim() float64
}

Pour notre exemple, nous allons implémenter cette interface sur les types rect et circle.

type rect struct {
    width, height float64
}
type circle struct {
    radius float64
}

Pour implémenter une interface en Go, il suffit d'en implémenter toutes les méthodes. Ici, nous implémentons geometry chez rect.

func (r rect) area() float64 {
    return r.width * r.height
}
func (r rect) perim() float64 {
    return 2*r.width + 2*r.height
}

Voici maintenant l'implémentation pour les circle.

func (c circle) area() float64 {
    return math.Pi * c.radius * c.radius
}
func (c circle) perim() float64 {
    return 2 * math.Pi * c.radius
}

Si une variable a une interface, alors on peut appeler les méthodes de l'interface. Voici une fonction générique qui utilise ceci pour travailler avec n'importe quelle geometry.

func measure(g geometry) {
    fmt.Println(g)
    fmt.Println(g.area())
    fmt.Println(g.perim())
}
func main() {
    r := rect{width: 3, height: 4}
    c := circle{radius: 5}

Mes structures circle et rect implémentent toutes deux les interfaces de geometry, on peut donc utiliser des instances de ces structures en argument de measure.

    measure(r)
    measure(c)
}

package main

import "fmt"
import "math"

type geometry interface {
    area() float64
    perim() float64
}

type rect struct {
    width, height float64
}
type circle struct {
    radius float64
}

func (r rect) area() float64 {
    return r.width * r.height
}
func (r rect) perim() float64 {
    return 2*r.width + 2*r.height
}

func (c circle) area() float64 {

    return math.Pi * c.radius * c.radius
}
func (c circle) perim() float64 {
    return 2 * math.Pi * c.radius
}

func measure(g geometry) {
    fmt.Println(g)
    fmt.Println(g.area())
    fmt.Println(g.perim())
}

func main() {
    r := rect{width: 3, height: 4}
    c := circle{radius: 5}

    measure(r)
    measure(c)
}

$ go run interfaces.go
{3 4}
12
14
{5}
78.53981633974483
31.41592653589793

Pour en apprendre plus sur les interfaces en Go, vous pouvez lire ce bon article.

En Go, il est idiomatique de communiquer les erreurs via une valeur de retour explicite et séparée. Cela contraste avec les exceptions utilisées dans des langages comme Java ou Ruby, et ce qu'on retrouve en C, où l'on renvoie une valeur parfaite, et parfois un code d'erreur. L'approche en Go fait qu'il est facile de voir quelles fonctions renvoient un code d'erreur et de les gérer en utilisant les mêmes constructions du langage utilisées pour n'importe quelle autre tâche sans erreur.

Par convention, les erreurs sont la dernière valeur de retour et ont pour type error, une interface du langage.

func f1(arg int) (int, error) {
    if arg == 42 {

errors.New construit une valeur d'erreur basique avec le message d'erreur donné.

        return -1, errors.New("can't work with 42")

    }

La valeur nil pour l'erreur indique qu'il n'y a pas eu d'erreur.

    return arg + 3, nil
}

Il est possible d'utiliser des types d'erreurs sur mesure en implémentant la méthode Error() sur ces types. Voici une variante de l'exemple ci-dessus qui utilise un type sur mesure pour représenter explicitement un argument d'erreur.

type argError struct {
    arg  int
    prob string
}
func (e *argError) Error() string {
    return fmt.Sprintf("%d - %s", e.arg, e.prob)
}

Dans ce cas, nous utilisons la syntaxe &argError pour construire l'objet et fournir les valeurs des deux champs arg et prob.

func f2(arg int) (int, error) {
    if arg == 42 {
        return -1, &argError{arg, "can't work with it"}
    }
    return arg + 3, nil
}

Les deux boucles ci-dessous testent chacune de nos fonctions qui renvoient des erreurs. Notez que l'utilisation d'un test d'erreur inline dans le if est idiomatique en code Go.

func main() {
    for _, i := range []int{7, 42} {
        if r, e := f1(i); e != nil {
            fmt.Println("f1 failed:", e)
        } else {
            fmt.Println("f1 worked:", r)
        }
    }
    for _, i := range []int{7, 42} {
        if r, e := f2(i); e != nil {
            fmt.Println("f2 failed:", e)
        } else {
            fmt.Println("f2 worked:", r)
        }
    }

Si vous voulez utiliser les données d'une erreur personnalisée, vous devrez récupérer l'erreur comme une instance du type d'erreur sur mesure en explicitant le type à utiliser.

    _, e := f2(42)
    if ae, ok := e.(*argError); ok {
        fmt.Println(ae.arg)
        fmt.Println(ae.prob)
    }
}

package main

import "errors"
import "fmt"

func f1(arg int) (int, error) {
    if arg == 42 {

        return -1, errors.New("can't work with 42")

    }

    return arg + 3, nil
}

type argError struct {
    arg  int
    prob string
}

func (e *argError) Error() string {
    return fmt.Sprintf("%d - %s", e.arg, e.prob)
}

func f2(arg int) (int, error) {
    if arg == 42 {

        return -1, &argError{arg, "can't work with it"}
    }
    return arg + 3, nil
}

func main() {

    for _, i := range []int{7, 42} {
        if r, e := f1(i); e != nil {
            fmt.Println("f1 failed:", e)
        } else {
            fmt.Println("f1 worked:", r)
        }
    }
    for _, i := range []int{7, 42} {
        if r, e := f2(i); e != nil {
            fmt.Println("f2 failed:", e)
        } else {
            fmt.Println("f2 worked:", r)
        }
    }

    _, e := f2(42)
    if ae, ok := e.(*argError); ok {
        fmt.Println(ae.arg)
        fmt.Println(ae.prob)
    }
}

$ go run errors.go
f1 worked: 10
f1 failed: can't work with 42
f2 worked: 10
f2 failed: 42 - can't work with it
42
can't work with it

Regardez ce bon article sur le blog de Go pour plus d'informations sur la gestion d'erreurs.

Une goroutine est un thread d'exécution léger.

Supposons que l'on ait un appel de fonction f(s). Normalement, on l'appellerait comme ceci, et son exécution serait synchrone.

    f("direct")

Pour appeler la fonction dans une goroutine, on utilise go f(s). Cette nouvelle goroutine va s'exécuter de manière concurrente avec la fonction appelée.

    go f("goroutine")

On peut aussi démarrer une goroutine pour un appel de fonction anonyme.

    go func(msg string) {
        fmt.Println(msg)
    }("going")

Nos deux appels de fonction s'exécutent de manière asynchrone dans des goroutines séparées, donc l'exécution échoue ici. Ce Scanln demande que l'on presse une touche pour sortir du programme.

    var input string
    fmt.Scanln(&input)
    fmt.Println("done")
}

package main

import "fmt"

func f(from string) {
    for i := 0; i < 3; i++ {
        fmt.Println(from, ":", i)
    }
}

func main() {

    f("direct")

    go f("goroutine")

    go func(msg string) {
        fmt.Println(msg)
    }("going")

    var input string
    fmt.Scanln(&input)
    fmt.Println("done")
}

Lorsque l'on lance ce programme, on voit la sortie de la fonction bloquante en premier, puis les exécutions croisées des deux goroutines. Cet entrelacement reflète le fait que les deux goroutines sont exécutées de manière concurrente.

$ go run goroutines.go
direct : 0
direct : 1
direct : 2
goroutine : 0
going
goroutine : 1
goroutine : 2
<enter>
done

Ensuite nous allons regarder un complément aux goroutines : les canaux.

Les canaux (channels) sont des tuyaux qui relient des goroutines concurrentes. On peut envoyer des valeurs d'une goroutine à une autre via un canal.

On crée un nouveau canal avec make(chan val-type). Les canaux sont typés avec les valeurs qu'ils transportent.

    messages := make(chan string)

On envoie une valeur dans un canal avec la syntaxe canal <-. Ici on envoie "ping" dans le canal messages que l'on a créé précédemment, depuis une nouvelle goroutine.

    go func() { messages <- "ping" }()

La syntaxe <-canal reçoit une valeur depuis un canal. Ici on affiche le message "ping" envoyé dans le précédent code.

    msg := <-messages
    fmt.Println(msg)
}

package main

import "fmt"

func main() {

    messages := make(chan string)

    go func() { messages <- "ping" }()

    msg := <-messages
    fmt.Println(msg)
}

Lorsque l'on lance le programme, le message "ping" est correctement passé d'une goroutine à l'autre via notre canal.

$ go run channels.go 
ping

Par défaut, l'envoi et la réception de messages sont bloqués jusqu'à ce que l'envoyeur et le receveur soient prêts. Cette propriété nous a permis d'attendre le message "ping" à la fin de notre programme, sans utiliser une autre forme de synchronisation.

Par défaut les canaux n'ont pas de buffer, ce qui signifie qu'ils acceptent uniquement les envois (chan <-) s'il y a un receveur correspondant (<- chan) prêt à recevoir la valeur envoyée. Les canaux avec buffer acceptent un nombre limité de valeurs sans receveur correspondant pour ces valeurs.

Ici on crée avec make un canal avec buffer, qui accumule jusqu'à deux chaînes de caractères.

func main() {

    messages := make(chan string, 2)

Comme ce canal a un buffer, nous pouvons envoyer ces deux valeurs dans le canal sans une réception concurrente correspondante.

    messages <- "buffered"
    messages <- "channel"

Ensuite, on peut recevoir ces deux valeurs comme d'habitude.

    fmt.Println(<-messages)
    fmt.Println(<-messages)
}

package main

import "fmt"

func main() {

    messages := make(chan string, 2)

    messages <- "buffered"
    messages <- "channel"

    fmt.Println(<-messages)
    fmt.Println(<-messages)
}

$ go run channel-buffering.go 
buffered
channel

On peut utiliser les canaux pour synchroniser l'exécution à travers des goroutines. Voici un exemple qui utilise une réception bloquante pour attendre qu'une goroutine se termine.

Voici la fonction qui va tourner dans une goroutine. Le canal done sera utilisé pour notifier à une autre goroutine que le travail de cette fonction est terminé.

func worker(done chan bool) {
    fmt.Print("working...")
    time.Sleep(time.Second)
    fmt.Println("done")

on envoie une valeur pour notifier qu'on a terminé.

    done <- true
}

On démarre la goroutine, en lui fournissant le canal à notifier.

func main() {

    done := make(chan bool, 1)
    go worker(done)

On bloque jusqu'à ce qu'on ait reçu une notification sur ce canal.

    <-done
}

package main

import "fmt"
import "time"

func worker(done chan bool) {
    fmt.Print("working...")
    time.Sleep(time.Second)
    fmt.Println("done")

    done <- true
}

func main() {

    done := make(chan bool, 1)
    go worker(done)

    <-done
}

$ go run channel-synchronization.go      
working...done

Si vous enlevez la ligne <- done, le programme se terminera avant que worker ait même commencé.

Lorsqu'on utilise des canaux comme paramètres de fonctions, on peut spécifier si un canal est censé uniquement envoyer ou recevoir des valeurs. Cette spécificité augmente la sécurité du typage du programme.

Cette fonction ping accepte seulement un canal qui envoie des valeurs. On aurait une erreur de compilation si on essayait de recevoir sur ce canal.

func ping(pings chan<- string, msg string) {
    pings <- msg
}

La fonction pong accepte un canal pour recevoir (pings) et un second pour les envois (pongs).

func pong(pings <-chan string, pongs chan<- string) {
    msg := <-pings
    pongs <- msg
}

func main() {
    pings := make(chan string, 1)
    pongs := make(chan string, 1)
    ping(pings, "passed message")
    pong(pings, pongs)
    fmt.Println(<-pongs)
}

package main

import "fmt"

func ping(pings chan<- string, msg string) {
    pings <- msg
}

func pong(pings <-chan string, pongs chan<- string) {
    msg := <-pings
    pongs <- msg
}

func main() {
    pings := make(chan string, 1)
    pongs := make(chan string, 1)
    ping(pings, "passed message")
    pong(pings, pongs)
    fmt.Println(<-pongs)
}

$ go run channel-directions.go
passed message

Le select de go permet d'attendre plusieurs opérations sur les canaux. Combiner les goroutines et les canaux est une fonctionnalité puissante de Go.

Pour notre exemple, nous ferons des select à travers deux canaux.

func main() {

    c1 := make(chan string)
    c2 := make(chan string)

Chaque canal va recevoir une valeur après un certain temps, pour simuler une opération bloquante (par ex. un appel RPC) qui s'exécute dans une goroutine concurrente.

    go func() {
        time.Sleep(time.Second * 1)
        c1 <- "one"
    }()
    go func() {
        time.Sleep(time.Second * 2)
        c2 <- "two"
    }()

Nous utilisons select pour attendre ces deux valeurs simultanément, en affichant chacune d'elles dès son arrivée.

    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-c1:
            fmt.Println("received", msg1)
        case msg2 := <-c2:
            fmt.Println("received", msg2)
        }
    }
}

package main

import "time"
import "fmt"

func main() {

    c1 := make(chan string)
    c2 := make(chan string)

    go func() {
        time.Sleep(time.Second * 1)
        c1 <- "one"
    }()
    go func() {
        time.Sleep(time.Second * 2)
        c2 <- "two"
    }()

    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-c1:
            fmt.Println("received", msg1)
        case msg2 := <-c2:
            fmt.Println("received", msg2)
        }
    }
}

Nous recevons les valeurs "one" puis "two" comme attendu.

$ time go run select.go 
received one
received two

À noter que le temps total d'exécution est seulement de ~2 secondes, car les deux Sleeps s'exécutent de manière concurrente.

real    0m2.245s

Les timemouts (dépassement du temps d'exécution alloué) sont importants pour des programmes qui se connectent à des ressources externes ou qui doivent limiter leur temps d'exécution. Implémenter des timeout en Go est facile et élégant grâce aux canaux et à select.

Pour notre exemple, supposons que l'on exécute un appel externe qui renvoie son résultat sur le canal c1 après 2 s.

    c1 := make(chan string, 1)
    go func() {
        time.Sleep(time.Second * 2)
        c1 <- "result 1"
    }()

Voici le select qui implémente le timeout. res := <-c1 attend le résultat et <-Time.After attend qu'une valeur soit envoyée après 1 s. Comme select traite la première réception, nous prenons le cas du timeout si l'opération prend plus de temps qu'il ne lui en est alloué.

    select {
    case res := <-c1:
        fmt.Println(res)
    case <-time.After(time.Second * 1):
        fmt.Println("timeout 1")
    }

Si nous permettons un plus grand timeout de 3 s, alors la réception depuis c2 va réussir et nous afficherons le résultat.

    c2 := make(chan string, 1)
    go func() {
        time.Sleep(time.Second * 2)
        c2 <- "result 2"
    }()
    select {
    case res := <-c2:
        fmt.Println(res)
    case <-time.After(time.Second * 3):
        fmt.Println("timeout 2")
    }
}

package main

import "time"
import "fmt"

func main() {

    c1 := make(chan string, 1)
    go func() {
        time.Sleep(time.Second * 2)
        c1 <- "result 1"
    }()

    select {
    case res := <-c1:
        fmt.Println(res)
    case <-time.After(time.Second * 1):
        fmt.Println("timeout 1")
    }

    c2 := make(chan string, 1)
    go func() {
        time.Sleep(time.Second * 2)
        c2 <- "result 2"
    }()
    select {
    case res := <-c2:
        fmt.Println(res)
    case <-time.After(time.Second * 3):
        fmt.Println("timeout 2")
    }
}

Ce programme montre que la première opération, trop longue, est arrêtée et que la seconde réussit.

$ go run timeouts.go 
timeout 1
result 2

Utiliser ce modèle de timeout avec select nécessite de communiquer les résultats à travers les canaux. C'est une bonne idée en général, car d'autres fonctionnalités importantes de Go sont basées sur les canaux et sur select. Nous allons aborder par la suite les timers et tickers.

Les envois et réceptions basiques sur les canaux sont bloquants. Cependant, on peut utiliser select avec une clause default pour implémenter des envois et réceptions non bloquants, et même des select non bloquants sur plusieurs canaux.

Voici une réception non bloquante. Si une valeur est disponible sur messages, alors select va prendre le cas <-messages avec cette valeur. Sinon, il prendra immédiatement le cas default.

    select {
    case msg := <-messages:
        fmt.Println("received message", msg)
    default:
        fmt.Println("no message received")
    }

Un envoi non bloquant marche de manière similaire.

    msg := "hi"
    select {
    case messages <- msg:
        fmt.Println("sent message", msg)
    default:
        fmt.Println("no message sent")
    }

On peut utiliser plusieurs case au-dessus de la clause default pour implémenter un select non bloquant multiple. Ici, on essaie de recevoir des messages de manière non bloquante sur les canaux messages et signals simultanément.

    select {
    case msg := <-messages:
        fmt.Println("received message", msg)
    case sig := <-signals:
        fmt.Println("received signal", sig)
    default:
        fmt.Println("no activity")
    }
}

package main

import "fmt"

func main() {
    messages := make(chan string)
    signals := make(chan bool)

    select {
    case msg := <-messages:
        fmt.Println("received message", msg)
    default:
        fmt.Println("no message received")
    }

    msg := "hi"
    select {
    case messages <- msg:
        fmt.Println("sent message", msg)
    default:
        fmt.Println("no message sent")
    }

    select {
    case msg := <-messages:
        fmt.Println("received message", msg)
    case sig := <-signals:
        fmt.Println("received signal", sig)
    default:
        fmt.Println("no activity")
    }
}

$ go run non-blocking-channel-operations.go 
no message received
no message sent
no activity

Fermer un canal indique que nous n'enverrons plus de valeurs dessus. Cela peut être utile pour indiquer au receveur qu'on a terminé.

Dans cet exemple, nous allons utiliser un canal jobs pour communiquer le travail à faire de main() à une autre goroutine. Quand nous n'aurons plus de travail à envoyer, nous fermerons le canal jobs avec close.

func main() {
    jobs := make(chan int, 5)
    done := make(chan bool)

Voici la goroutine qui traite les jobs. Elle reçoit de manière répétée dans j des valeurs de jobsavec j, more := <-jobs. Dans cette forme particulière de réception à deux valeurs, la valeur de more sera false si jobs a été fermée et que toutes les valeurs ont déjà été reçues. Nous utilisons cela pour notifier au canal done lorsque nous avons traité tous les jobs.

    go func() {
        for {
            j, more := <-jobs
            if more {
                fmt.Println("received job", j)
            } else {
                fmt.Println("received all jobs")
                done <- true
                return
            }
        }
    }()

Cela envoie trois jobs à travers le canal jobs, puis le ferme.

    for j := 1; j <= 3; j++ {
        jobs <- j
        fmt.Println("sent job", j)
    }
    close(jobs)
    fmt.Println("sent all jobs")

On attend le worker en utilisant l'approche de synchronisationSynchronisation des canaux vue plus tôt.

    <-done
}

package main

import "fmt"

func main() {
    jobs := make(chan int, 5)
    done := make(chan bool)

    go func() {
        for {
            j, more := <-jobs
            if more {
                fmt.Println("received job", j)
            } else {
                fmt.Println("received all jobs")
                done <- true
                return
            }
        }
    }()

    for j := 1; j <= 3; j++ {
        jobs <- j
        fmt.Println("sent job", j)
    }
    close(jobs)
    fmt.Println("sent all jobs")

    <-done
}

$ go run closing-channels.go 
sent job 1
received job 1
sent job 2
received job 2
sent job 3
received job 3
sent all jobs
received all jobs

L'idée des canaux fermés amène naturellement à notre exemple suivant : utiliser range sur des canaux.

Dans un exemple précédentRange, nous avons vu comment for et range permettent d'itérer sur des structures de données simples. On peut également utiliser cette syntaxe pour itérer sur des valeurs reçues depuis un canal.

Nous allons itérer sur deux valeurs dans le canal queue.

    queue := make(chan string, 2)
    queue <- "one"
    queue <- "two"
    close(queue)

Ce range itère sur chaque élément à mesure qu'il est reçu dans queue. Comme nous avons fermé le canal plus haut, l'itération se termine après réception des deux éléments. Si nous ne l'avions pas fermé, nous bloquerions sur la réception d'une troisième valeur dans la boucle.

    for elem := range queue {
        fmt.Println(elem)
    }
}

package main

import "fmt"

func main() {

    queue := make(chan string, 2)
    queue <- "one"
    queue <- "two"
    close(queue)

    for elem := range queue {
        fmt.Println(elem)
    }
}

$ go run range-over-channels.go
one
two

Cet exemple montre également comment il est possible de fermer un canal non vide tout en continuant à recevoir les valeurs restantes.

On veut souvent exécuter du code Go à un certain point du futur, ou de manière répétée selon un intervalle de temps. Les fonctionnalités intégrées timer et ticker rendent ces deux tâches faciles. Nous allons d'abord aborder les timers, et ensuite les tickersTickers.

Les timers représentent un événement unique dans le futur. On précise combien de temps on veut attendre, et il fournit un canal au quel sera notifié à ce moment-là. Ce timer attendra 2 secondes.

    timer1 := time.NewTimer(time.Second * 2)

Le <-timer1.C bloque sur le canal C du timer jusqu'à ce qu'il envoie une valeur indiquant que le timer a expiré.

    <-timer1.C
    fmt.Println("Timer 1 expired")

Pour simplement attendre, on peut utiliser time.Sleep. Mais les timers peuvent être utiles, car on peut les stopper avant qu'ils expirent. Voici un exemple :

    timer2 := time.NewTimer(time.Second)
    go func() {
        <-timer2.C
        fmt.Println("Timer 2 expired")
    }()
    stop2 := timer2.Stop()
    if stop2 {
        fmt.Println("Timer 2 stopped")
    }
}

package main

import "time"
import "fmt"

func main() {

    timer1 := time.NewTimer(time.Second * 2)

    <-timer1.C
    fmt.Println("Timer 1 expired")

    timer2 := time.NewTimer(time.Second)
    go func() {
        <-timer2.C
        fmt.Println("Timer 2 expired")
    }()
    stop2 := timer2.Stop()
    if stop2 {
        fmt.Println("Timer 2 stopped")
    }
}

Le premier timer va expirer ~2 s après que l'on démarre le programme, mais le second devrait être stoppé avant qu'il ait pu expirer.

$ go run timers.go
Timer 1 expired
Timer 2 stopped

Les timersTimers servent quand on veut faire quelque chose dans le futur. Les tickers servent à faire quelque chose de manière répétée à intervalles réguliers. Voici un exemple d'un ticker qui se répète jusqu'à ce qu'on l'arrête.

Les tickers utilisent un mécanisme similaire à celui des timers : un canal pour envoyer des valeurs. Ici, nous utilisons la méthode intégrée range sur le canal pour itérer sur les valeurs lorsqu'elles arrivent, toutes les 500 ms.

    ticker := time.NewTicker(time.Millisecond * 500)
    go func() {
        for t := range ticker.C {
            fmt.Println("Tick at", t)
        }
    }()

Les tickers peuvent être arrêtés comme les timers. Lorsqu'un ticker est arrêté, il ne recevra plus de valeurs sur son canal. Nous arrêterons le nôtre après 1600 ms.

    time.Sleep(time.Millisecond * 1600)
    ticker.Stop()
    fmt.Println("Ticker stopped")
}

package main

import "time"
import "fmt"

func main() {

    ticker := time.NewTicker(time.Millisecond * 500)
    go func() {
        for t := range ticker.C {
            fmt.Println("Tick at", t)
        }
    }()

    time.Sleep(time.Millisecond * 1600)
    ticker.Stop()
    fmt.Println("Ticker stopped")
}

Quand on lance ce programme, le ticker devrait envoyer trois notifications avant qu'on ne l'arrête.

$ go run tickers.go
Tick at 2012-09-23 11:29:56.487625 -0700 PDT
Tick at 2012-09-23 11:29:56.988063 -0700 PDT
Tick at 2012-09-23 11:29:57.488076 -0700 PDT
Ticker stopped

Dans cet exemple, nous allons regarder comment implémenter un worker pool en utilisant des goroutines et des canaux.

Voici notre worker, dont nous allons lancer plusieurs instances concurrentes. Ces workers recevront du travail dans le canal jobs et enverront le résultat correspondant dans results. Nous ferons une pause d'une seconde par tâche pour simuler une opération complexe.

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("worker", id, "processing job", j)
        time.Sleep(time.Second)
        results <- j * 2
    }
}

func main() {

Afin d'utiliser notre pool de workers, nous devons leur envoyer du travail et collecter leurs résultats. On crée deux canaux pour cela.

    jobs := make(chan int, 100)
    results := make(chan int, 100)

On démarre trois workers, initialement bloqués, car ils n'ont pas de jobs pour le moment.

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

Ici on envoie neuf travaux, puis fermons ce canal pour indiquer que c'est tout le travail que nous avons.

    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)

Finalement, nous collectons les résultats du travail.

    for a := 1; a <= 9; a++ {
        <-results
    }
}

package main

import "fmt"
import "time"

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("worker", id, "processing job", j)
        time.Sleep(time.Second)
        results <- j * 2
    }
}

func main() {

    jobs := make(chan int, 100)
    results := make(chan int, 100)

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= 9; a++ {
        <-results
    }
}

Notre programme montre, au cours de son exécution, les neuf jobs qui s'exécutent, traités par les différents workers. Le programme prend seulement environ 3 secondes à s'exécuter, bien qu'il traite environ 9 secondes de travail, car il y a trois workers qui travaillent de manière concurrente.

$ time go run worker-pools.go 
worker 1 processing job 1
worker 2 processing job 2
worker 3 processing job 3
worker 1 processing job 4
worker 2 processing job 5
worker 3 processing job 6
worker 1 processing job 7
worker 2 processing job 8
worker 3 processing job 9

real    0m3.149s

Limiter le débit est un important mécanisme pour contrôler l'utilisation des ressources et maintenir la qualité de service. Go supporte élégamment la limitation de débit avec les goroutines, les canaux et les tickersTickers.

Nous allons d'abord regarder une limitation de débit simple. Supposons que l'on veuille limiter notre gestion des requêtes entrantes. Nous allons servir ces requêtes depuis un canal du même nom.

    requests := make(chan int, 5)
    for i := 1; i <= 5; i++ {
        requests <- i
    }
    close(requests)

Ce canal limiter va recevoir une valeur toutes les 200 millisecondes. C'est le régulateur de notre système de limitation du débit.

    limiter := time.Tick(time.Millisecond * 200)

En bloquant sur une réception du canal limiter avant de servir chaque requête, on se limite à une requête toutes les 200 ms.

    for req := range requests {
        <-limiter
        fmt.Println("request", req, time.Now())
    }

On pourrait vouloir permettre de courtes augmentations du nombre de requêtes, tout en préservant la limitation globale. On peut pour cela mettre un buffer sur le canal limitant. Ce canal burstyLimiter va permettre de recevoir jusqu'à trois événements.

    burstyLimiter := make(chan time.Time, 3)

On remplit le canal pour représenter l'augmentation considérée.

    for i := 0; i < 3; i++ {
        burstyLimiter <- time.Now()
    }

Toutes les 200 ms nous essaierons d'ajouter une nouvelle valeur dans burstyLimiter, jusqu'à sa limite de trois.

    go func() {
        for t := range time.Tick(time.Millisecond * 200) {
            burstyLimiter <- t
        }
    }()

Maintenant on simule cinq nouvelles requêtes entrantes. Les trois premières bénéficieront des possibilités de sur-traitement de burstyLimiter.

    burstyRequests := make(chan int, 5)
    for i := 1; i <= 5; i++ {
        burstyRequests <- i
    }
    close(burstyRequests)
    for req := range burstyRequests {
        <-burstyLimiter
        fmt.Println("request", req, time.Now())
    }
}

package main

import "time"
import "fmt"

func main() {

    requests := make(chan int, 5)
    for i := 1; i <= 5; i++ {
        requests <- i
    }
    close(requests)

    limiter := time.Tick(time.Millisecond * 200)

    for req := range requests {
        <-limiter
        fmt.Println("request", req, time.Now())
    }

    burstyLimiter := make(chan time.Time, 3)

    for i := 0; i < 3; i++ {
        burstyLimiter <- time.Now()
    }

    go func() {
        for t := range time.Tick(time.Millisecond * 200) {
            burstyLimiter <- t
        }
    }()

    burstyRequests := make(chan int, 5)
    for i := 1; i <= 5; i++ {
        burstyRequests <- i
    }
    close(burstyRequests)
    for req := range burstyRequests {
        <-burstyLimiter
        fmt.Println("request", req, time.Now())
    }
}