Go Language Practical Notes (vi) | Go Map

This is a creation in Article, where the information may have evolved or changed.

"Go language Combat" reading notes, not to be continued, welcome to sweep code attention flysnow_org to the public, the first time to see follow-up notes.

I think it's too hard to translate the map into maps, so I'll use the English map in this article.

A map is a data structure that is a collection that stores a series of unordered key-value pairs. It is based on key storage, like an index, which is also a powerful place for maps to quickly and quickly retrieve data, and keys to the values associated with that key.

Internal implementation

Map is to give a hash list to achieve, is what we often say the hash table, so each time we iterate map, the printed key and value is unordered, each iteration is different, even if we exist in a certain order.

The hash list of the map contains a set of buckets, and each time you store and look up a key-value pair, you select a bucket first. How do you choose a bucket? is to pass the specified key to the hash function, it can be indexed to the corresponding bucket, and then find the corresponding key value.

The advantage of this way is that the more data stored, the more uniform the distribution of the index, so we access the key value of the speed of the more quickly, of course, the details of the storage there are many, we can refer to the knowledge of the hash, here we just remember that the map is stored in the unordered set of key-value pairs .

Declaration and initialization

Map creation has make functions, map literals. makefunction We have created slices with it, and in addition, it can flood to create a map.

dict:=make(map[string]int)

In the example, a map with a key type of string value type is created int . Now that it's created, the map is empty, there's nothing in it, and we're going to store a key-value pair.

dict := make(map[string]int)dict["张三"] = 43

Stores a key value of Zhang San, value 43, for the data.

There is also a way to create and initialize a map using the map literal, which we can do equally for the above example.

dict := map[string]int{"张三":43}

Using a curly brace for initialization, key-value pairs are : separated by separating, if you want to initialize multiple key-value pairs simultaneously, use commas to split them.

dict := map[string]int{"张三":43,"李四":50}

Of course we can not specify any key-value pairs, that is, an empty map.

dict := map[string]int{}

In any case, use the map's literal creation to be sure to bring braces. What if we were to create a nil map? nilmap is uninitialized, so we can declare only one variable, either using the map literal, or using the make function to allocate memory.

var dict map[string]int

That's fine, but we can't manipulate the store key-value pairs, but we have to initialize them before we can, for example, use a make function to open a piece of memory that can store the data, that is, initialize.

var dict map[string]intdict = make(map[string]int)dict["张三"] = 43fmt.Println(dict)

The key of a map can be any value, the type of the key can be a built-in type, or it can be a struct type, but in any case, this key can be == compared using operators, so like slices, functions, and structure types with slices cannot be used for map keys, because they have referential semantics and cannot be compared.

For the value of the map, there is no limit, the slice of this in the key can not be used, is fully used in the value.

Using map

The use of maps is simple, and arrays are similar, array slices are indexed, and map is through keys.

dict := make(map[string]int)dict["张三"] = 43

In the example above, if the key 张三 exists, the value is modified, and if it does not exist, the key value pair is added.

The value of getting a map key is also simple, similar to storage, or given the example above.

age := dict["张三"]

In Go map, if we get a value of a nonexistent key, it is also possible to return a value type of 0 value, so that we do not know whether there is a zero value of a key value pair, or that the key value pair does not exist. In this context, map provides a way for us to detect the existence of a key-value pair.

age,exists := dict["李四"]

Look at this example, and get the value of the key is not much different, just one more return value. The first return value is the value of the key, the second return value marks the existence of the key, which is a boolean variable of type, and we can tell it to know if the key exists. This is also the benefit of Go multi-value return.

If we want to delete a key-value pair from a map, we can use the functions built into go delete .

delete(dict,"张三")

deleteThe function accepts two parameters, the first is the map to be manipulated, and the second is the key of the map to be deleted.

The delete function removes the nonexistent key, but it does not have any effect.

If you want to traverse a map, you can use for range a style loop, just like traversing a slice.

dict := map[string]int{"张三": 43}for key, value := range dict {    fmt.Println(key, value)}

Here the range return two values, the first one is the map key, the second is the map of the key corresponding value. Here again, this traversal is unordered, that is, the key value pair will not appear according to the established data, if you want to go through the sequence, you can first sort the key in the map, and then traverse the sorted key, take the corresponding value out, see below an example to understand.

func main() {    dict := map[string]int{"王五": 60, "张三": 43}    var names []string    for name := range dict {        names = append(names, name)    }    sort.Strings(names) //排序    for _, key := range names {        fmt.Println(key, dict[key])    }}

In this example, there is a trick, range a map, you can also use a return value, the default return value is the key of the map.

Passing a map between functions

Passing a map between functions does not copy a copy of the map, which means that if a map is passed to a function that modifies the map, then all references to the map will be aware of the change.

func main() {    dict := map[string]int{"王五": 60, "张三": 43}    modify(dict)    fmt.Println(dict["张三"])}func modify(dict map[string]int) {    dict["张三"] = 10}

The result of the above example output is that it has been modified by the function to prove that the 10 pass is not a copy of the map. This feature is similar to slicing, so it is much higher because copying the entire map is too expensive.

"Go language Combat" reading notes, not to be continued, welcome to sweep code attention flysnow_org to the public, the first time to see follow-up notes.