Verificando Mapas Nil

Parte da seção Lógica & Fluxo do Journey de GO da Coddy. Lição 28 de 68.

Em Go, um map pode ter um estado especial chamado nil. Um map nil é essencialmente um map não inicializado que não aponta para nada na memória. Entender esse conceito é crucial, pois tentar add chaves a um map nil fará com que seu programa entre em panic e trave.

Veja como um mapa nil ocorre e qual é a sua aparência:

var myMap map[string]int
// myMap é nil neste ponto

Quando você declara uma variável de mapa sem inicializá-la, Go a define automaticamente como nil. Embora seja seguro ler de um mapa nil (ele retornará o valor zero), tentar escrever nele causará um panic:

// Isso é seguro - retorna 0
value := myMap["key"]

// Isso vai causar panic!
myMap["key"] = 42

Para evitar esse problema, você deve sempre verificar se um map é nil antes de tentar add chaves a ele. A verificação é simples:

if myMap == nil {
    myMap = make(map[string]int)
}
myMap["key"] = 42 // Agora isso é seguro

Essa verificação simples garante que seu programa não falhe ao trabalhar com maps potencialmente não inicializados, tornando seu código mais robusto e confiável.

Desafio

Fácil

Crie um sistema seguro de inicialização de mapas que evite erros de panic verificando se os mapas são nil antes de tentar realizar operações de escrita. Este desafio demonstra a importância crítica de validar o estado do mapa antes de executar operações que poderiam fazer seu programa travar.

Você receberá duas entradas:

Uma string que representa o número de operações (por exemplo, "5")
Uma string contendo operações separadas por vírgulas. Cada operação especifica o mapa no qual trabalha:
- "check:[map_name]"
- "init:[map_name]"
- "add:[map_name]:[key]:[value]"
Por exemplo, "check:scores,init:scores,add:scores:Alice:95,add:scores:Bob:87,check:grades"

Sua tarefa é:

Criar duas variáveis de mapa do tipo map[string]int chamadas scores e grades sem inicializá-las (elas serão nil)
Processar cada operação da string de entrada sequencialmente:
Para operações "check":
- Verificar se o mapa especificado é nil
- Imprimir "Map [map_name] is nil" se o mapa for nil
- Imprimir "Map [map_name] is initialized" se o mapa não for nil
Para operações "init":
- Inicializar o mapa especificado usando make(map[string]int)
- Imprimir "Initialized map [map_name]"
Para operações "add":
- Primeiro, verificar se o mapa é nil
- Se o mapa for nil, imprimir "Cannot add to nil map [map_name]"
- Se o mapa não for nil, adicionar o par chave-valor e imprimir "Added [key]:[value] to [map_name]"
Analisar as operações dividindo a string de entrada:
- Dividir por vírgulas para obter operações individuais
- Para cada operação, dividir por dois-pontos para obter o tipo de operação e os parâmetros
- Converter a string do valor em um inteiro para operações add
Depois de processar todas as operações, exibir o estado final de ambos os mapas:
- Para cada mapa, se ele for nil: "Final state - [map_name]: nil"
- Para cada mapa, se ele estiver inicializado: "Final state - [map_name]: [count] entries", onde count é o número de pares chave-valor
- Imprimir scores primeiro e grades depois, independentemente da ordem em que as operações os utilizaram

Use o pacote strconv para converter strings de valores em inteiros para operações add. Este desafio demonstra como verificar se os mapas são nil antes de operações de escrita evita panics em tempo de execução e torna seu código robusto e confiável.

Experimente você mesmo

package main

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

func main() {
	// Ler entrada
	var numOpsStr string
	var operationsStr string
	fmt.Scanln(&numOpsStr)
	fmt.Scanln(&operationsStr)
	
	// Declare maps sem inicialização (eles serão nil)
	var scores map[string]int
	var grades map[string]int
	
	// Divida as operations por vírgula
	operations := strings.Split(operationsStr, ",")
	
	// TODO: Escreva seu código abaixo
	// Processe cada operação sequencialmente
	// Trate as operações "check", "init" e "add"
	// Para operações add, use strconv.Atoi() para converter value string para inteiro
	
	// Exiba o estado final de ambos os maps
	// Verifique se os maps são nil ou inicializados e imprima de acordo
}