Go Academy · Aula

Maps: armazenamentos de chave e valor

Crie, leia, escreva e exclua entradas de map

Maps: armazenamentos de chave e valor é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

O que é um mapa

Um mapa em Go é uma coleção não ordenada de pares chave-valor. As chaves devem ser de um tipo comparável (strings, inteiros etc.). Mapas são tipos de referência apoiados por uma tabela de dispersão.

Criando mapas

Use um literal ou make:

package main
import "fmt"

func main() {
    ages  := map[string]int{"Alice": 30, "Bob": 25}
    cache := make(map[string]string)
    fmt.Println(ages, cache)
}

Leitura e escrita

Acesse valores com m[key] e atribua valores com m[key] = value. Ler uma chave ausente retorna o valor zero:

package main
import "fmt"

func main() {
    m := map[string]int{}
    m["hits"] = 10
    m["hits"]++
    fmt.Println(m["hits"])    // 11
    fmt.Println(m["missing"]) // 0
}

Verificando a existência de uma chave

A forma de dois valores distingue uma chave ausente de um valor zero:

package main
import "fmt"

func main() {
    m := map[string]int{"a": 0}
    v, ok := m["a"]
    fmt.Println(v, ok) // 0 true
    v2, ok2 := m["z"]
    fmt.Println(v2, ok2) // 0 false
}

Excluindo entradas

Use a função integrada delete. Excluir uma chave inexistente não faz nada:

package main
import "fmt"

func main() {
    m := map[string]int{"x": 1, "y": 2}
    delete(m, "x")
    delete(m, "z") // no-op
    fmt.Println(m) // map[y:2]
}

Iterando sobre um mapa

Use range para iterar. A ordem não é garantida:

package main
import "fmt"

func main() {
    scores := map[string]int{"Alice": 90, "Bob": 85}
    for name, score := range scores {
        fmt.Printf("%s: %d\n", name, score)
    }
}

Mapas com valores de estrutura

Mapas podem armazenar estruturas como valores. Atualize por meio de uma variável temporária (estruturas em mapas não são endereçáveis):

package main
import "fmt"

type Point struct{ X, Y int }

func main() {
    points := map[string]Point{"A": {1, 2}}
    p := points["A"]
    p.X = 99
    points["A"] = p
    fmt.Println(points["A"]) // {99 2}
}

Mapas nil

Um mapa nil é lido como um mapa vazio (valores zero), mas escrever em um mapa nil causa pânico:

package main

func main() {
    var m map[string]int
    _ = m["key"]   // ok — returns 0
    // m["key"] = 1 // PANIC: assignment to nil map
}

Mapas não são seguros para uso concorrente

O mapa integrado de Go não é seguro para gorrotinas. Leituras concorrentes são permitidas, mas escritas concorrentes (ou leitura e escrita simultâneas) exigem um mutex ou sync.Map:

package main
import "sync"

func main() {
    var mu sync.Mutex
    m := map[string]int{}
    mu.Lock()
    m["key"] = 1
    mu.Unlock()
    _ = m
}

Contando frequências

Um padrão clássico de mapa — contar ocorrências:

package main
import "fmt"

func main() {
    words := []string{"go", "is", "fast", "go", "is", "go"}
    freq := map[string]int{}
    for _, w := range words {
        freq[w]++
    }
    fmt.Println(freq) // map[fast:1 go:3 is:2]
}

Verificação rápida

O que acontece quando você lê uma chave que não existe em um mapa Go?

Recapitulação: mapas

Principais aprendizados:

Mapas são armazenamentos não ordenados de pares chave-valor
Use a forma de dois valores para verificar a existência de uma chave
Nunca escreva em um mapa nil
A ordem de iteração é aleatória — ordene as chaves se necessário
Proteja mapas com um mutex em código concorrente

Exercício prático

Escreva uma função que receba uma string e retorne um map[rune]int contando quantas vezes cada caractere aparece. Teste-a com a string "hello".

Perguntas Frequentes

A aula “Maps: armazenamentos de chave e valor” é grátis?

Sim — o texto completo de “Maps: armazenamentos de chave e valor” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Maps: armazenamentos de chave e valor”?

Crie, leia, escreva e exclua entradas de map Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Maps: armazenamentos de chave e valor”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy