Verificare le mappe nil

Fa parte della sezione Logica e flusso del percorso GO di Coddy. Lezione 28 di 68.

In Go, una mappa può avere uno stato speciale chiamato nil. Una mappa nil è essenzialmente una mappa non inizializzata che non punta a nulla in memoria. Comprendere questo concetto è fondamentale, perché tentare di aggiungere chiavi a una mappa nil farà sì che il programma generi un panic e si arresti in modo anomalo.

Ecco come si verifica una mappa nil e che aspetto ha:

var myMap map[string]int
// myMap è nil a questo punto

Quando dichiari una variabile di tipo mappa senza inizializzarla, Go la imposta automaticamente su nil. Anche se puoi leggere in sicurezza da una mappa nil (restituirà il valore zero), provare a scriverci causerà un panic:

// Questo è sicuro - restituisce 0
value := myMap["key"]

// Questo causerà un panic!
myMap["key"] = 42

Per evitare questo problema, dovresti sempre verificare se una mappa è nil prima di tentare di aggiungervi chiavi. Il controllo è semplice:

if myMap == nil {
    myMap = make(map[string]int)
}
myMap["key"] = 42 // Ora questo è sicuro

Questo semplice controllo assicura che il tuo programma non si blocchi quando lavora con mappe potenzialmente non inizializzate, rendendo il tuo codice più robusto e affidabile.

Sfida

Facile

Crea un sistema sicuro di inizializzazione delle mappe che prevenga gli errori di panic verificando che le mappe non siano nil prima di tentare operazioni di scrittura. Questa sfida dimostra l'importanza fondamentale di convalidare lo stato delle mappe prima di eseguire operazioni che potrebbero causare l'arresto anomalo del programma.

Riceverai due input:

Una stringa che rappresenta il numero di operazioni (ad esempio, "5")
Una stringa contenente operazioni separate da virgole. Ogni operazione specifica la mappa su cui agisce:
- "check:[map_name]"
- "init:[map_name]"
- "add:[map_name]:[key]:[value]"
Ad esempio, "check:scores,init:scores,add:scores:Alice:95,add:scores:Bob:87,check:grades"

Il tuo compito è:

Creare due variabili mappa di tipo map[string]int chiamate scores e grades senza inizializzarle (saranno nil)
Elaborare in sequenza ogni operazione dalla stringa di input:
Per le operazioni "check":
- Verificare se la mappa specificata è nil
- Stampare "Map [map_name] is nil" se la mappa è nil
- Stampare "Map [map_name] is initialized" se la mappa non è nil
Per le operazioni "init":
- Inizializzare la mappa specificata usando make(map[string]int)
- Stampare "Initialized map [map_name]"
Per le operazioni "add":
- Verificare prima se la mappa è nil
- Se la mappa è nil, stampare "Cannot add to nil map [map_name]"
- Se la mappa non è nil, aggiungere la coppia chiave-valore e stampare "Added [key]:[value] to [map_name]"
Analizzare le operazioni suddividendo la stringa di input:
- Suddividere in corrispondenza delle virgole per ottenere le singole operazioni
- Per ogni operazione, suddividere in corrispondenza dei due punti per ottenere il tipo di operazione e i parametri
- Convertire la stringa del valore in un intero per le operazioni di aggiunta
Dopo aver elaborato tutte le operazioni, visualizzare lo stato finale di entrambe le mappe:
- Per ogni mappa, se è nil: "Final state - [map_name]: nil"
- Per ogni mappa, se è inizializzata: "Final state - [map_name]: [count] entries" dove count è il numero di coppie chiave-valore
- Stampare prima scores e poi grades, indipendentemente dall'ordine in cui le operazioni le hanno utilizzate

Usa il pacchetto strconv per convertire le stringhe dei valori in interi nelle operazioni di aggiunta. Questa sfida dimostra come verificare che le mappe non siano nil prima delle operazioni di scrittura prevenga i panic a runtime e renda il tuo codice solido e affidabile.

Provalo tu

package main

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

func main() {
	// Leggi l'input
	var numOpsStr string
	var operationsStr string
	fmt.Scanln(&numOpsStr)
	fmt.Scanln(&operationsStr)
	
	// Dichiara le mappe senza inizializzarle (saranno nil)
	var scores map[string]int
	var grades map[string]int
	
	// Dividi le operazioni usando la virgola come separatore
	operations := strings.Split(operationsStr, ",")
	
	// TODO: Scrivi il tuo codice qui sotto
	// Elabora ogni operazione in sequenza
	// Gestisci le operazioni "check", "init" e "add"
	// Per le operazioni "add", usa strconv.Atoi() per convertire la stringa del valore in un numero intero
	
	// Stampa lo stato finale di entrambe le mappe
	// Controlla se le mappe sono nil o inizializzate e stampa il risultato di conseguenza
}