Introduction
En Go, map est un type de données intégré qui associe des clés à des valeurs.
Dans d'autres langages de programmation, tu connais peut-être le concept de map sous les noms de dictionnaire, table de hachage, magasin clé/valeur ou tableau associatif.
Syntaxiquement, map ressemble à ceci :
map[KeyType]ElementType
Il est aussi important de savoir que chaque clé est unique, ce qui signifie qu'affecter deux fois la même clé écrase la valeur de la clé correspondante.
Pour créer une map, tu peux faire :
// With map literal
foo := map[string]int{}
ou
// or with make function
foo := make(map[string]int)
Voici quelques opérations que tu peux effectuer sur une map :
// Add a value in a map with the `=` operator:
foo["bar"] = 42
// Here we update the element of `bar`
foo["bar"] = 73
// To retrieve a map value, you can use
baz := foo["bar"]
// To delete an item from a map, you can use
delete(foo, "bar")
Si tu essaies de récupérer la valeur d'une clé qui n'existe pas dans la map, cela renvoie la valeur zéro du type de valeur.
Cela peut prêter à confusion, surtout si la valeur par défaut de ton ElementType (par exemple, 0 pour un int) est une valeur valide.
Pour vérifier si une clé existe dans ta map, tu peux utiliser
value, exists := foo["baz"]
// If the key "baz" does not exist,
// value: 0; exists: false
Instructions
Un de tes amis tient un vieux magasin de gros appelé Gross Store.
Ce nom vient de la quantité d'articles que le magasin vend : tout se compte en grosse.
Ton ami t'a demandé de développer un système de point de vente (POS) pour son magasin.
Pour commencer, tu veux en construire un prototype.
Dans ton prototype, ton système se contentera d'enregistrer la quantité.
Ton ami t'a donné une liste de mesures pour t'aider :
| Unité |
Valeur |
| quarter_of_a_dozen |
3 |
| half_of_a_dozen |
6 |
| dozen |
12 |
| small_gross |
120 |
| gross |
144 |
| great_gross |
1728 |
1. Stocke l'unité de mesure dans ton programme
Pour pouvoir utiliser ces mesures, tu dois les stocker dans ton programme.
units := Units()
fmt.Println(units)
// Output: map[...] with entries like ("dozen": 12)
2. Crée une nouvelle facture client
Tu dois implémenter une fonction qui crée une nouvelle facture (vide) pour le client.
bill := NewBill()
fmt.Println(bill)
// Output: map[]
3. Ajoute un article à la facture du client
Pour cela, tu vas devoir :
- Renvoyer
false si la valeur de unit fournie ne figure pas dans la map units.
- Sinon, ajouter l'article à la
bill du client en l'indexant par le nom de l'article, puis renvoyer true.
- Si l'article est déjà présent dans la facture, augmenter sa quantité de la valeur associée à
unit.
bill := NewBill()
units := Units()
ok := AddItem(bill, units, "carrot", "dozen")
fmt.Println(ok)
// Output: true (since dozen is a valid unit)
Note que la valeur renvoyée est de type bool.
4. Retire un article de la facture du client
Pour cela, tu vas devoir :
- Renvoyer
false si l'article donné n'est pas dans la facture
- Renvoyer
false si la valeur de unit fournie ne figure pas dans la map units.
- Renvoyer
false si la nouvelle quantité serait inférieure à 0.
- Si la nouvelle quantité vaut 0, supprimer complètement l'article de la
bill, puis renvoyer true.
- Sinon, réduire la quantité de l'article et renvoyer
true.
bill := NewBill()
units := Units()
ok := RemoveItem(bill, units, "carrot", "dozen")
fmt.Println(ok)
// Output: false (because there are no carrots in the bill)
Note que la valeur renvoyée est de type bool.
5. Renvoie la quantité d'un article précis présent dans la facture du client
Pour cela, tu vas devoir :
- Renvoyer
0 et false si item n'est pas présent dans la facture.
- Sinon, renvoyer la quantité de l'article dans la
bill ainsi que true.
bill := map[string]int{"carrot": 12, "grapes": 3}
qty, ok := GetItem(bill, "carrot")
fmt.Println(qty)
// Output: 12
fmt.Println(ok)
// Output: true
Note que les valeurs renvoyées sont de type int et bool.
Exercice d'apprentissage
