Tester les Maps Nil

Fait partie de la section Logique & Flux du Journey GO de Coddy. Leçon 28 sur 68.

En Go, une map peut avoir un état spécial appelé nil. Une map nil est essentiellement une map non initialisée qui ne pointe vers rien en mémoire. Comprendre ce concept est crucial, car tenter d’ajouter des clés à une map nil provoquera un panic et fera planter votre programme.

Voici comment une nil map apparaît et à quoi elle ressemble :

var myMap map[string]int
// myMap est nil à ce stade

Lorsque vous déclarez une variable de type map sans l’initialiser, Go lui attribue automatiquement la valeur nil. Bien que vous puissiez lire sans risque dans une nil map (elle renverra la valeur zéro), essayer d’y écrire provoquera une panique :

// Ceci est sûr - retourne 0
value := myMap["key"]

// Ceci va paniquer !
myMap["key"] = 42

Pour éviter ce problème, vous devez toujours vérifier si une map est nil avant d’essayer d’y ajouter des clés. La vérification est simple :

if myMap == nil {
    myMap = make(map[string]int)
}
myMap["key"] = 42 // Maintenant c'est sûr

Cette vérification simple garantit que votre programme ne plantera pas lorsqu’il travaille avec des maps potentiellement non initialisées, ce qui rend votre code plus robuste et fiable.

Défi

Facile

Créez un système sécurisé d’initialisation des maps qui empêche les erreurs de panique en vérifiant les maps nil avant de tenter des opérations d’écriture. Ce défi démontre l’importance critique de valider l’état d’une map avant d’effectuer des opérations susceptibles de faire planter votre programme.

Vous recevrez deux entrées :

Une chaîne représentant le nombre d’opérations (par exemple, "5")
Une chaîne contenant des opérations séparées par des virgules. Chaque opération indique la map sur laquelle elle agit :
- "check:[map_name]"
- "init:[map_name]"
- "add:[map_name]:[key]:[value]"
Par exemple "check:scores,init:scores,add:scores:Alice:95,add:scores:Bob:87,check:grades"

Votre tâche consiste à :

Créer deux variables de map de type map[string]int nommées scores et grades sans les initialiser (elles seront nil)
Traiter chaque opération de la chaîne d’entrée séquentiellement :
Pour les opérations "check" :
- Vérifier si la map spécifiée est nil
- Afficher "Map [map_name] is nil" si la map est nil
- Afficher "Map [map_name] is initialized" si la map n’est pas nil
Pour les opérations "init" :
- Initialiser la map spécifiée à l’aide de make(map[string]int)
- Afficher "Initialized map [map_name]"
Pour les opérations "add" :
- Vérifier d’abord si la map est nil
- Si la map est nil, afficher "Cannot add to nil map [map_name]"
- Si la map n’est pas nil, ajouter la paire clé-valeur et afficher "Added [key]:[value] to [map_name]"
Analyser les opérations en divisant la chaîne d’entrée :
- La diviser par des virgules pour obtenir les opérations individuelles
- Pour chaque opération, la diviser par des deux-points afin d’obtenir le type d’opération et les paramètres
- Convertir la chaîne représentant la valeur en entier pour les opérations d’ajout
Après avoir traité toutes les opérations, afficher l’état final des deux maps :
- Pour chaque map, si elle est nil : "Final state - [map_name]: nil"
- Pour chaque map, si elle est initialisée : "Final state - [map_name]: [count] entries", où count est le nombre de paires clé-valeur
- Afficher scores en premier et grades en second, quel que soit l’ordre dans lequel les opérations les ont utilisées

Utilisez le package strconv pour convertir les chaînes représentant les valeurs en entiers pour les opérations d’ajout. Ce défi montre comment la vérification des maps nil avant les opérations d’écriture empêche les paniques à l’exécution et rend votre code robuste et fiable.

Essayez vous-même

package main

import (
	"fmt"
	"strconv"
	"strings"
)

func main() {
	// Lire l'entrée
	var numOpsStr string
	var operationsStr string
	fmt.Scanln(&numOpsStr)
	fmt.Scanln(&operationsStr)
	
	// Déclarer les maps sans initialisation (elles seront nil)
	var scores map[string]int
	var grades map[string]int
	
	// Diviser les opérations par une virgule
	operations := strings.Split(operationsStr, ",")
	
	// TODO: Écrivez votre code ci-dessous
	// Traiter chaque opération séquentiellement
	// Gérer les opérations "check", "init" et "add"
	// Pour les opérations add, utiliser strconv.Atoi() pour convertir la chaîne de valeur en entier
	
	// Afficher l'état final des deux maps
	// Vérifier si les maps sont nil ou initialisées et afficher en conséquence
}