Usage of map golang

Golang is a very powerful programming language with high efficiency and simple and easy to learn syntax. When it comes to the benefits of Go, one of the main reasons is the built-in data structures like maps. In this article, we will take a deeper look at Go map usage.

Go map is an unordered collection of key-value pairs, which means you can use any type of value as key and value. The key-value pairs within the map are not stored in any particular order, but rather in the order of their hash values. We will discuss this feature further below.

Create a Map

To create a map in Go, you need to use the built-in function make(). Let's see how to create a map and add key-value pairs to it.

m := make(map[string]int) // 创建一个字符串为键，int 类型为值的 map
m["foo"] = 42             // 向 map 中添加键为 "foo" 的值为 42
fmt.Println(m["foo"])     // 输出 map 中键为 "foo" 的值，输出 42

In this example, we create a map with string keys and int values, and then we add the value 42 with the key "foo" to it. The last line of code outputs the value in the map with key "foo", so we get 42 as output.

There is also an alternative method to specify the initial value when creating the map. You can try it as follows:

m := map[string]int {
    "foo": 42,
    "bar": 24,
}

In this example, we create a map with two key-value pairs, where the key "foo" has the value 42 and the key "bar" has the value is 24.

Accessing the value in a Map

To access the value of the map in Go, you can use the following method:

val, ok := m["foo"]
fmt.Println(val, ok)     // 输出 42, true

Here the val variable stores the key in the map as "foo" The value of , and the ok variable indicates whether there is an entry with the key "foo" in the map.

If there is no such entry in the map (that is, "foo" is not a key), then the ok variable will be false. So if you want to check whether the value in the map was successfully accessed, you can check the value of the ok variable.

Iterating over the values ​​in a Map

Iterating over the values ​​of a map in Go is easy, you can use a for-range loop.

m := map[string]int {
    "foo": 42,
    "bar": 24,
}

for k, v := range m {
    fmt.Printf("key: %s, value: %d
", k, v)
}

// 输出：
// key: foo, value: 42
// key: bar, value: 24

In this example, we use a for-range loop to iterate over the keys and values ​​in map m and output them in each iteration. Note that the syntax of the for loop iterates not only the keys of the map, but also the values ​​in the map.

Deleting values ​​in Map

Deleting values ​​in Go map is also very simple, you only need to use the delete() function.

m := map[string]int {
    "foo": 42,
    "bar": 24,
}

delete(m, "foo") // 删除 map 中键为 "foo" 的键值对

In this example, we use the delete() function to delete the key-value pair with the key "foo" in the map. After deletion, the map will no longer contain an entry with key "foo".

Map’s size and capacity

In Go, map has size and capacity attributes. However, unlike data structures in other languages, maps in Go do not have an explicit capacity attribute. So, if you want to know the size of map, you need to use the built-in function len() as shown below:

m := map[string]int {
    "foo": 42,
    "bar": 24,
}

fmt.Println(len(m)) // 输出长度为 2

Here, we use len() function to output the length of map m and its output is 2 .

Performance and Usage Recommendations for Map

Map is a very powerful data structure, but it needs to be used with caution. Since map is a dynamic hash table, many developers consider it to be faster than other data structures. However, in real-world use, map performance can be affected by memory management and hash conflicts, resulting in slower code.

Here are some suggestions for using Go maps:

• Avoid adding too many key-value pairs in the map. Too many key-value pairs can lead to more hash collisions.
• For situations where large maps need to be processed, it is recommended to use the concurrency-safe sync.Map type.
• When considering performance, you should consider using arrays, slices, or other data structures.

Nonetheless, map is a very convenient and flexible data structure. If you use it in a sensible way, it will be ideal for your Go code.

Summary

In this article, we have learned about the usage of map in Golang. We've learned how to create, access, iterate, and delete entries in a map, as well as how to view a map's size and capacity. At the same time, we also provide some suggestions on the use of map, hoping to help you better use this data structure in Go.

The above is the detailed content of Usage of map golang. For more information, please follow other related articles on the PHP Chinese website!