Prüfen auf Nil-Maps

Teil des Abschnitts Logik & Ablauf der GO-Journey von Coddy. Lektion 28 von 68.

In Go kann eine Map einen speziellen Zustand namens nil haben. Eine nil-Map ist im Wesentlichen eine nicht initialisierte Map, die auf nichts im Speicher verweist. Das Verständnis dieses Konzepts ist entscheidend, da der Versuch, Schlüssel zu einer nil-Map hinzuzufügen, dazu führt, dass dein Programm einen Panic auslöst und abstürzt.

So entsteht eine nil-Map, und so sieht sie aus:

var myMap map[string]int
// myMap ist nil an diesem Punkt

Wenn du eine Map-Variable deklarierst, ohne sie zu initialisieren, setzt Go sie automatisch auf nil. Du kannst zwar sicher aus einer nil-Map lesen (sie gibt den Nullwert zurück), aber der Versuch, in sie zu schreiben, führt zu einer Panic:

// Das ist sicher - gibt 0 zurück
value := myMap["key"]

// Das wird einen Panic auslösen!
myMap["key"] = 42

Um dieses Problem zu vermeiden, solltest du immer prüfen, ob eine Map nil ist, bevor du versuchst, Schlüssel hinzuzufügen. Die Prüfung ist unkompliziert:

if myMap == nil {
    myMap = make(map[string]int)
}
myMap["key"] = 42 // Jetzt ist das sicher

Diese einfache Prüfung stellt sicher, dass dein Programm beim Arbeiten mit möglicherweise nicht initialisierten Maps nicht abstürzt, wodurch dein Code robuster und zuverlässiger wird.

Aufgabe

Einfach

Erstelle ein sicheres System zur Initialisierung von Maps, das Panic-Fehler verhindert, indem es vor Schreiboperationen prüft, ob Maps nil sind. Diese Aufgabe veranschaulicht die entscheidende Bedeutung der Validierung des Map-Zustands, bevor Operationen ausgeführt werden, die dein Programm zum Absturz bringen könnten.

Du erhältst zwei Eingaben:

Eine Zeichenkette, die die Anzahl der Operationen darstellt (z. B. "5")
Eine Zeichenkette mit durch Kommas getrennten Operationen. Jede Operation nennt die Map, auf der sie arbeitet:
- "check:[map_name]"
- "init:[map_name]"
- "add:[map_name]:[key]:[value]"
Zum Beispiel "check:scores,init:scores,add:scores:Alice:95,add:scores:Bob:87,check:grades"

Deine Aufgabe ist es:

Erstelle zwei Map-Variablen vom Typ map[string]int mit den Namen scores und grades, ohne sie zu initialisieren (sie werden nil sein)
Verarbeite jede Operation aus der Eingabezeichenkette nacheinander:
Für "check"-Operationen:
- Prüfe, ob die angegebene Map nil ist
- Gib "Map [map_name] is nil" aus, wenn die Map nil ist
- Gib "Map [map_name] is initialized" aus, wenn die Map nicht nil ist
Für "init"-Operationen:
- Initialisiere die angegebene Map mit make(map[string]int)
- Gib "Initialized map [map_name]" aus
Für "add"-Operationen:
- Prüfe zuerst, ob die Map nil ist
- Wenn die Map nil ist, gib "Cannot add to nil map [map_name]" aus
- Wenn die Map nicht nil ist, füge das Schlüssel-Wert-Paar hinzu und gib "Added [key]:[value] to [map_name]" aus
Analysiere die Operationen, indem du die Eingabezeichenkette aufteilst:
- Teile an Kommas, um einzelne Operationen zu erhalten
- Teile jede Operation an Doppelpunkten, um den Operationstyp und die Parameter zu erhalten
- Wandle die Wertzeichenkette bei add-Operationen in eine Ganzzahl um
Zeige nach der Verarbeitung aller Operationen den endgültigen Zustand beider Maps an:
- Für jede Map, wenn sie nil ist: "Final state - [map_name]: nil"
- Für jede Map, wenn sie initialisiert ist: "Final state - [map_name]: [count] entries", wobei count die Anzahl der Schlüssel-Wert-Paare ist
- Gib unabhängig von der Reihenfolge, in der die Operationen sie verwendet haben, zuerst scores und danach grades aus

Verwende das Paket strconv, um Wertzeichenketten bei add-Operationen in Ganzzahlen umzuwandeln. Diese Aufgabe veranschaulicht, wie die Prüfung auf nil Maps vor Schreiboperationen Laufzeit-Panics verhindert und deinen Code robust und zuverlässig macht.

Probier es selbst

package main

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

func main() {
	// Eingabe lesen
	var numOpsStr string
	var operationsStr string
	fmt.Scanln(&numOpsStr)
	fmt.Scanln(&operationsStr)
	
	// Maps ohne Initialisierung deklarieren (sie werden nil sein)
	var scores map[string]int
	var grades map[string]int
	
	// Operationen am Komma aufteilen
	operations := strings.Split(operationsStr, ",")
	
	// TODO: Schreibe deinen Code darunter
	// Jede Operation der Reihe nach verarbeiten
	// Die Operationen "check", "init" und "add" behandeln
	// Für add-Operationen strconv.Atoi() verwenden, um den Werte-String in eine Ganzzahl umzuwandeln
	
	// Endgültigen Zustand beider Maps ausgeben
	// Prüfen, ob die Maps nil oder initialisiert sind, und entsprechend ausgeben
}