Map

Mencari harga lewat indeks posisi tidak praktis: tidak ada yang hafal bahwa nasi goreng berada di indeks tujuh belas. Struktur yang kita butuhkan adalah pasangan key-value — beri nama, dapatkan nilai — dan Go menyediakannya lewat map. Map menyimpan setiap nilai di bawah key yang unik, sehingga pencarian harga["nasi goreng"] berlangsung tanpa memeriksa seluruh isi. Pada chapter ini kita belajar membuat map, membacanya, dan memahami syarat tipe key yang sah.

Apa itu Map #

Tipe map ditulis map[K]V: K adalah tipe key dan V adalah tipe nilai. Sebuah map[string]int memasangkan setiap key string dengan satu nilai int, dan satu key hanya boleh muncul sekali. Operasi utamanya tiga: menyimpan m[key] = nilai, membaca m[key], dan menghapus delete(m, key) — ketiganya kita praktikkan tuntas pada chapter Operasi Map .

Membuat Map #

Dua cara standar membuat map: literal yang menuliskan pasangan key-value langsung, dan make yang menyiapkan map kosong untuk diisi bertahap.

harga := map[string]int{
	"nasi goreng": 25000,
	"mie ayam":    22000,
	"es teh":      5000,
}

umur := make(map[string]int)
umur["Budi"] = 25
umur["Siti"] = 30

Jumlah pasangan yang tersimpan dibaca dengan len(harga), sama seperti slice. Deklarasi var m map[string]int tanpa nilai menghasilkan map nil yang bisa dibaca tetapi tidak bisa diisi — perilaku khusus ini kita bahas tuntas pada chapter nil Slice dan nil Map .

Membaca Key yang Tidak Ada #

Membaca key yang belum pernah diisi tidak menggagalkan program: map mengembalikan zero value tipe nilai. Pada map[string]int, key yang absen menghasilkan 0; pada map[string]bool menghasilkan false. Perilaku ini nyaman tetapi menimbulkan pertanyaan: bagaimana membedakan nilai asli 0 dari key yang memang tidak ada? Jawabannya adalah comma-ok idiom nilai, ok := m[key] yang kita bahas pada chapter berikutnya.

Nilai Bertipe Struct #

Nilai map tidak terbatas pada tipe dasar. Struct membuat setiap entri map memuat beberapa field sekaligus, cocok untuk data seperti stok barang yang punya nama dan jumlah. Field struct dibaca langsung dari hasil akses, misalnya stok["pulpen"].Jumlah.

Tipe Key Harus Comparable #

Map harus bisa membandingkan kesamaan antar key untuk menemukan posisi penyimpanan, sehingga tipe key wajib comparable. Tipe yang sah meliputi string, semua tipe angka, bool, pointer, channel, array dengan elemen comparable, serta struct yang seluruh fieldnya comparable. Tiga tipe dilarang menjadi key: slice, map, dan function, karena ketiganya tidak mendukung perbandingan ==. Kompilator menolak penerapannya sejak proses kompilasi, terbukti pada berkas error-key.go berikut:

package main

func main() {
	// Slice tidak bisa menjadi key map karena tipe slice tidak comparable.
	m := map[[]int]string{}
	_ = m
}

Jalankan berkas tersebut dengan go run error-key.go; kompilasi gagal dengan pesan berikut:

Output yang Dihasilkan:

# command-line-arguments
./error-key.go:5:11: invalid map key type []int

Pesan yang sama muncul untuk map[map[string]int]string (invalid map key type map[string]int) dan untuk key bertipe function. Kegagalan terjadi sebelum program berjalan, sehingga kesalahan desain tipe key selalu ketahuan lebih awal.

Program Utuh #

Berkas map-demo.go menggabungkan literal, make, pembacaan zero value, dan nilai bertipe struct. Jalankan dengan go run map-demo.go dari direktori chapter:

package main

import "fmt"

// Item adalah struct sederhana yang menjadi nilai map.
type Item struct {
	Nama   string
	Jumlah int
}

func main() {
	// Literal map: key dan value ditulis berpasangan.
	harga := map[string]int{
		"nasi goreng": 25000,
		"mie ayam":    22000,
		"es teh":      5000,
	}
	fmt.Println("harga     :", harga)
	fmt.Println("len(harga):", len(harga))

	// Membuat map kosong dengan make, lalu mengisi bertahap.
	umur := make(map[string]int)
	umur["Budi"] = 25
	umur["Siti"] = 30
	fmt.Println("umur      :", umur)

	// Membaca key yang tidak ada menghasilkan zero value tipe nilai.
	fmt.Println("harga bakso:", harga["bakso"])

	// Nilai bertipe struct: pasangan key-value yang lebih kaya.
	stok := map[string]Item{
		"pulpen": {Nama: "Pulpen Hitam", Jumlah: 12},
		"buku":   {Nama: "Buku Tulis", Jumlah: 40},
	}
	fmt.Println("stok      :", stok)
	fmt.Println("stok pulpen:", stok["pulpen"].Jumlah)
}

Output yang Dihasilkan:

harga     : map[es teh:5000 mie ayam:22000 nasi goreng:25000]
len(harga): 3
umur      : map[Budi:25 Siti:30]
harga bakso: 0
stok      : map[buku:{Buku Tulis 40} pulpen:{Pulpen Hitam 12}]
stok pulpen: 12

Mari kita telaah baris demi baris program di atas:

1. Baris 5–8 (struct Item): mendefinisikan tipe nilai yang menyimpan dua field; struct termasuk tipe nilai map yang sah.
2. Baris 11–15 (literal harga): tiga pasangan key-value string-int; len(harga) bernilai 3, dan fungsi fmt mencetak key secara terurut sehingga output stabil.
3. Baris 18–21 (make + pengisian): map dibuat kosong lalu diisi bertahap dengan key "Budi" dan "Siti".
4. Baris 24 (harga["bakso"]): key tidak pernah diisi, sehingga pembacaan menghasilkan zero value 0 tanpa galat.
5. Baris 27–30 (literal stok): setiap nilai ditulis sebagai struct literal {Nama: ..., Jumlah: ...} dengan key "pulpen" dan "buku".
6. Baris 33 (stok["pulpen"].Jumlah): mengakses field Jumlah langsung dari hasil pembacaan map, menghasilkan 12.

Map sudah siap dipakai, dan langkah alami berikutnya adalah mengelola isinya secara penuh: menambah, mengubah, menghapus, memeriksa keberadaan key, dan mengiterasi seluruh pasangan secara terurut — pokok bahasan chapter Operasi Map.

Referensi #

• Go Blog: Maps in action (maps) — panduan resmi pemakaian map.
• Spesifikasi Go: Map types — definisi resmi tipe map dan key comparable.
• Spesifikasi Go: Comparison operators — daftar tipe yang dapat dibandingkan dengan ==.
• A Tour of Go: More types — latihan interaktif map.

package main

func main() {
	// Slice tidak bisa menjadi key map karena tipe slice tidak comparable.
	m := map[[]int]string{}
	_ = m
}

package main

import "fmt"

// Item adalah struct sederhana yang menjadi nilai map.
type Item struct {
	Nama   string
	Jumlah int
}

func main() {
	// Literal map: key dan value ditulis berpasangan.
	harga := map[string]int{
		"nasi goreng": 25000,
		"mie ayam":    22000,
		"es teh":      5000,
	}
	fmt.Println("harga     :", harga)
	fmt.Println("len(harga):", len(harga))

	// Membuat map kosong dengan make, lalu mengisi bertahap.
	umur := make(map[string]int)
	umur["Budi"] = 25
	umur["Siti"] = 30
	fmt.Println("umur      :", umur)

	// Membaca key yang tidak ada menghasilkan zero value tipe nilai.
	fmt.Println("harga bakso:", harga["bakso"])

	// Nilai bertipe struct: pasangan key-value yang lebih kaya.
	stok := map[string]Item{
		"pulpen": {Nama: "Pulpen Hitam", Jumlah: 12},
		"buku":   {Nama: "Buku Tulis", Jumlah: 40},
	}
	fmt.Println("stok      :", stok)
	fmt.Println("stok pulpen:", stok["pulpen"].Jumlah)
}