Slices et maps

Array contre slice

Go propose deux façons de stocker une liste de valeurs. L'array a une taille fixée à la déclaration et qui ne bouge plus jamais :

var nombres [3]int    // un array de 3 entiers, taille figée
nombres[0] = 10

En pratique, vous utiliserez le slice 99 % du temps. C'est la version dynamique : il grandit et rétrécit à volonté. On le reconnaît aux crochets vides [] devant le type :

scores := []int{10, 20, 30}   // slice littéral
vide := []int{}               // slice vide
autre := make([]int, 0)       // même chose avec make

La différence clé : [3]int est un array (taille fixe), []int est un slice (taille dynamique). Quand vous hésitez, prenez le slice.

append, len et le slicing

Pour ajouter un élément, on utilise append. Il renvoie un nouveau slice qu'on réaffecte à la variable. len donne la taille :

scores := []int{10, 20, 30}
scores = append(scores, 40)   // [10 20 30 40]
fmt.Println(len(scores))      // 4

Le slicing s[debut:fin] extrait une portion. La borne de début est incluse, celle de fin est exclue :

scores := []int{10, 20, 30, 40}
milieu := scores[1:3]   // [20 30] : index 1 et 2, pas 3

[10 20 30 40]
4
[20 30]

À vous d'essayer :

package main

import "fmt"

func main() {
    scores := []int{10, 20, 30}
    scores = append(scores, 40)
    fmt.Println(scores)
    fmt.Println(len(scores))
    fmt.Println(scores[1:3])
}

Parcourir avec range

Pour parcourir un slice, la boucle for ... range vous donne à chaque tour l'index et la valeur :

fruits := []string{"pomme", "banane", "cerise"}
for i, v := range fruits {
    fmt.Println(i, v)
}

Si l'index ne vous intéresse pas, remplacez-le par _ (le blank identifier). Go vous oblige à le faire, sinon il râle sur la variable inutilisée.

0 pomme
1 banane
2 cerise

À vous d'essayer :

package main

import "fmt"

func main() {
    fruits := []string{"pomme", "banane", "cerise"}
    for i, v := range fruits {
        fmt.Println(i, v)
    }
}

Les maps : clé / valeur

Une map associe des clés à des valeurs, comme un dictionnaire en Python ou un objet en JavaScript. Le type s'écrit map[TypeCle]TypeValeur :

ages := map[string]int{
    "Alice": 30,
    "Bob":   25,
}
ages["Charlie"] = 42      // écrire
fmt.Println(ages["Alice"]) // lire : 30

Problème : que renvoie ages["Inconnu"] ? Pas une erreur, mais la valeur zéro du type (ici 0). Impossible alors de distinguer "la clé vaut 0" de "la clé n'existe pas". La solution est l'idiome comma-ok :

v, ok := ages["Inconnu"]
if ok {
    fmt.Println("trouvé :", v)
} else {
    fmt.Println("clé absente")
}

Le second retour ok est un booléen : true si la clé existe, false sinon. Pour supprimer une clé, on utilise delete, et on parcourt une map avec range :

delete(ages, "Bob")        // supprime la clé "Bob"
for nom, age := range ages {
    fmt.Println(nom, age)
}

30
clé absente
Alice 30
Charlie 42

À vous d'essayer :

package main

import "fmt"

func main() {
    ages := map[string]int{"Alice": 30, "Bob": 25}
    ages["Charlie"] = 42
    fmt.Println(ages["Alice"])

    if _, ok := ages["Inconnu"]; !ok {
        fmt.Println("clé absente")
    }

    delete(ages, "Bob")
    for nom, age := range ages {
        fmt.Println(nom, age)
    }
}