Development

How to Check if a Map Contains a Key in Go: Comma-Ok

In this tutorial, we will explore various methods and techniques we can use to determine whether a map contains a specific key.
Captain Salem 2 min read
How to Check if a Map Contains a Key in Go: Comma-Ok
How to Check if a Map Contains a Key in Go: Comma-Ok

Go is an exceptional programming language of the modern age. It comes packed with tons of features and performance benefits that are hard to achieve with languages with similar syntax and learning curve.

Go provides us with the map data type which is a built-in data type that associates values of one type (the key) with values of another type (the value). You are probably familiar with this data type under the name hash or dictionary.

When working with maps, you may encounter instances where you need to check whether a given key is located in the map.

Requirements

To follow along with this post, you should have:

  1. The Go compiler installed on your machine.
  2. Basic understanding of the Go programming language.

The comma-ok idiom

The most common method we can use to check whether a given exists in a map is the comma-ok feature in Go. It returns 0 if the specified key does not exist in the map.

To better understand how to use it, consider the example below:

package main

import "fmt"

func main() {
	m := map[string]int{
		"k1": 1,
		"k2": 2,
		"k3": 3,
	}

	keyToCheck := "k2"

	if value, ok := m[keyToCheck]; ok {
		fmt.Printf("Key %s exists with value %d\n", keyToCheck, value)
	} else {
		fmt.Printf("Key %s does not exist\n", keyToCheck)
	}
}

The value, ok := m[keyToCheck] statement will return two values. The first is the value associated with the key, and the second is a Boolean that will be true if the key was present in the map, and false if it was not.

The code above should return:

Key k2 exists with value 2

Accessing the Key

We can also verify the existence of a given key in a map by accessing it. One disadvantage of this technique is that it can be misleading. This is because Go will return the zero value of the value type if the key doesn't exist. Hence, if there's a zero value in the map, you may not know whether the result is for the value of the missing key.

An example is as shown:

package main

import "fmt"

func main() {
    m := map[string]int{
        "k1": 1,
        "k2": 0,
        "k3": 3,
    }
    
    keyToCheck := "k2"

    value := m[keyToCheck]

    fmt.Printf("Key %s has value %d\n", keyToCheck, value)
}

In the example, the key k2 exists in the map with a value of 0. However, if k2 did not exist in the map, we would still get 0 as a result, leading to potential confusion.

Conclusion

In this tutorial, we discussed two main methods of checking whether a map contains a key in Go. We recommended sticking with the comma-Ok feature in Go as it provides a clear distinction on whether the key exists and not a zero value stored in the key.

Share
Comments
More from GeekBits

Join us at GeekBits

Join our members and get a currated list of awesome articles each month.

Great! You’ve successfully signed up.

Welcome back! You've successfully signed in.

You've successfully subscribed to GeekBits.

Success! Check your email for magic link to sign-in.

Success! Your billing info has been updated.

Your billing was not updated.