How to check if a key exists in a map in Go

1The comma-ok idiomRecommended

Assigning a map index to two variables switches it into its second form: value, ok := m[key]. For a present key you get the stored value and true; for a missing one, the zero value and false. Most Go code folds the lookup into the if statement itself, which keeps both variables scoped to the branch that uses them.

package main

import "fmt"

func main() {
	ports := map[string]int{"http": 80, "https": 443, "ssh": 22}

	// Present: you get the value, and ok == true
	port, ok := ports["https"]
	fmt.Println(port, ok)

	// Missing: you get the zero value, and ok == false
	ftp, ok := ports["ftp"]
	fmt.Println(ftp, ok)

	// The idiomatic form scopes both variables to the if statement
	if p, ok := ports["ssh"]; ok {
		fmt.Println("ssh runs on port", p)
	}
}

Prints 443 true, 0 false, and ssh runs on port 22. The name ok is convention, not keyword — but it's a strong one; every Go reader recognizes v, ok := on sight, so don't get creative with it.

2The trap: missing key vs stored zero

Why not just compare against the zero value — if m[key] != 0? Because a map can legitimately store a zero. A product with 0 stock and a product you never stocked both index to 0; only the ok boolean can tell you which is which. This distinction is the entire reason the idiom exists.

package main

import "fmt"

func main() {
	stock := map[string]int{"pens": 12, "chairs": 0}

	// A missing key and a stored zero look identical by value alone
	fmt.Println(stock["chairs"]) // in the map, zero in stock
	fmt.Println(stock["desks"])  // not in the map at all

	// The ok bool is the only way to tell them apart
	chairs, ok := stock["chairs"]
	fmt.Println(chairs, ok)

	desks, ok := stock["desks"]
	fmt.Println(desks, ok)
}

The first two lines both print 0 — indistinguishable. With comma-ok, chairs comes back as 0 true (present, zero stock) and desks as 0 false (absent). Same value, opposite meanings — carried entirely by the boolean.

3Existence-only checks and sets

When only membership matters, discard the value with the blank identifier: _, ok := m[key]. Push that one step further and you get Go's idiomatic set: a map whose values carry no information at all. map[string]struct{} is the classic choice — the empty struct occupies zero bytes — while map[string]bool trades a byte per entry for a friendlier read at the call site.

package main

import "fmt"

func main() {
	// A set in Go is a map whose values you ignore
	seen := map[string]struct{}{
		"alice": {},
		"bob":   {},
	}

	if _, ok := seen["alice"]; ok {
		fmt.Println("alice already visited")
	}

	seen["carol"] = struct{}{} // add a member
	_, ok := seen["carol"]
	fmt.Println("carol in set:", ok)
	fmt.Println("members:", len(seen))

	// map[string]bool reads even cleaner -- a missing key is just false
	admins := map[string]bool{"alice": true}
	fmt.Println(admins["alice"], admins["bob"])
}

Prints alice already visited, carol in set: true, members: 3, then true false. The bool version's charm is that last line: admins["bob"] is a missing key, so it evaluates to false — exactly what "not an admin" should say, no comma-ok needed. It only misleads if you ever store an explicit false.

4Which form should you use?

5Checking if a value exists

Comma-ok answers "is this key here?" in O(1). The reverse question — does any key map to this value? — has no shortcut: maps only index one way, so you range over the entries. If you ask it often, build the inverse map once and do comma-ok lookups on that instead.

package main

import "fmt"

func main() {
	ports := map[string]int{"http": 80, "https": 443, "ssh": 22}

	target := 443
	found := ""
	for name, port := range ports {
		if port == target {
			found = name
			break
		}
	}
	fmt.Println(found)
}

Prints https. One thing to know before you extend this: Go deliberately randomizes map iteration order on every run, so if several keys matched, which one wins the break would vary run to run — collect all matches (or sort the keys first) when that matters.

6nil maps, delete, and len

A declared-but-uninitialized map is nil, and it behaves asymmetrically: reading is completely safe — every key is simply missing, comma-ok included — but writing panics. That asymmetry makes lookup code robust by default and is why the panic assignment to entry in nil map always points at a missing make. Rounding out the toolkit: delete(m, k) removes a key and is a silent no-op if it wasn't there.

package main

import "fmt"

func main() {
	var m map[string]int // nil -- declared, never initialized

	// Reading from a nil map is safe: every key is simply missing
	v, ok := m["anything"]
	fmt.Println(v, ok, len(m))

	// Writing would panic: m["boom"] = 1
	// -> panic: assignment to entry in nil map

	m = make(map[string]int)
	m["x"] = 1
	delete(m, "x")        // remove the key
	delete(m, "not-here") // deleting a missing key is a no-op, not an error
	_, gone := m["x"]
	fmt.Println(gone, len(m))
}

Prints 0 false 0 from the nil map — zero value, not present, length zero — and false 0 after the delete. Note that delete returns nothing: if you need to know whether the key was there, do a comma-ok check first.