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 porque tentar adicionar chaves a um map nil fará com que seu programa entre em pânico (panic) e encerre inesperadamente.

Veja como um mapa nil ocorre e como ele se parece:

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

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

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

// Isso causará um pânico!
myMap["key"] = 42

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

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

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

Teste seus conhecimentos

Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.

Teste seus conhecimentos

Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.

Teste seus conhecimentos

Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.

Desafio

Fácil

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

Você receberá duas entradas:

Uma string representando o número de operações (ex: "5")
Uma string contendo operações no formato: "operation1:key1:value1,operation2:key2:value2" onde as operações são "check", "init", ou "add" (ex: "check:scores,init:scores,add:Alice:95,add: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 as 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 de valor para um inteiro para operações de adição
Após processar todas as operações, exibir o estado final de ambos os mapas:
- Para cada mapa, se for nil: "Final state - [map_name]: nil"
- Para cada mapa, se estiver inicializado: "Final state - [map_name]: [count] entries" onde count é o número de pares chave-valor

Use o pacote strconv para converter strings de valor em inteiros para operações de adição. Este desafio demonstra como a verificação de mapas nulos antes das operações de escrita evita pânicos em tempo de execução e torna seu código robusto e confiável.

Folha de consulta

Um mapa nil é um mapa não inicializado que não aponta para nada na memória. Tentar adicionar chaves a um mapa nil fará com que seu programa entre em pânico (panic) e trave.

Declarar um mapa sem inicializá-lo cria um mapa nil:

var myMap map[string]int
// myMap is nil at this point

Ler de um mapa nil é seguro (retorna o valor zero), mas escrever nele causará um pânico:

// This is safe - returns 0
value := myMap["key"]

// This will panic!
myMap["key"] = 42

Sempre verifique se um mapa é nil antes de adicionar chaves:

if myMap == nil {
    myMap = make(map[string]int)
}
myMap["key"] = 42 // Now this is safe

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)
	
	// Declarar mapas sem inicialização (eles serão nil)
	var scores map[string]int
	var grades map[string]int
	
	// Dividir operações por vírgula
	operations := strings.Split(operationsStr, ",")
	
	// TODO: Escreva seu código abaixo
	// Processar cada operação sequencialmente
	// Lidar com as operações "check", "init" e "add"
	// Para operações add, use strconv.Atoi() para converter a string de valor em inteiro
	
	// Saída do estado final de ambos os mapas
	// Verificar se os mapas são nil ou inicializados e imprimir adequadamente
}

Teste seus conhecimentos

Esta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.