Does golang map require make?

##map

Similar to hash tables or dictionaries in other languages, storing data in key-value form                                                                                                                            

go)

key must be a type that supports == or != comparison operations, and cannot be a function, map or slice

Map searches for value through key than linear search Much faster

Map is created using make() and supports the abbreviation of :=

make([keyType]valueType,cap), cap represents capacity and can be omitted

It will automatically expand when the capacity is exceeded, but try to provide a reasonable initial value

Use len() to get the number of elements

The key-value pair will be automatically added when it does not exist. Use delete() to delete a key-value pair

Use for range to iterate map and slice

The declaration and default value of map

// 声明
var m map[string]string
 
// bool 的零值是false
var m map[int]bool 
a, ok := m[1]
fmt.Println(a, ok) // false  false
 
// int 的零值是0
var m map[int]int 
a, ok := m[1]
fmt.Println(a, ok) // 0  false

map When declared, the default value is nil. At this time, the value is retrieved and the zero value of the corresponding type is returned (zero value is returned if it does not exist)

// 先声明map
var m1 map[string]string
// 再使用make函数创建一个非nil的map，nil map不能赋值
m1 = make(map[string]string)
// 最后给已声明的map赋值
m1["a"] = "aa"
m1["b"] = "bb"
 
// 直接创建
m2 := make(map[string]string)
// 然后赋值
m2["a"] = "aa"
m2["b"] = "bb"
 
// 初始化 + 赋值一体化
m3 := map[string]string{
    "a": "aa",
    "b": "bb",
}
 
// ==========================================
// 查找键值是否存在
if v, ok := m1["a"]; ok {
    fmt.Println(v)
} else {
    fmt.Println("Key Not Found")
}
 
// 遍历map
for k, v := range m1 {
    fmt.Println(k, v)
}
 
m := make(map[interface{} ]interface{})
m[1] = 56
m["str"] = "dfsdf"
fmt.Println(m)

map data type initialization:

Two ways: map[string]string{} or make(map[string]string)

Uninitialized map is nil:

An uninitialized map is nil, which is basically equivalent to an empty map, except that a nil map does not allow adding values ​​to it. (A nil map is equivalent to an empty map except that no elements may be added)

Therefore, when the map is nil, an error will not be reported when the value is obtained (it cannot be obtained), but an error will be reported when the value is added. .

Actually, there is another difference. Deleting a nil map will panic, but deleting an empty map is a no-op (and will not panic) (this difference is no longer in the latest Go tips, that is: delete A nil map will not panic)

When printing map through fmt, the results of empty map and nil map are the same:

When printing map through fmt, empty map The result is the same as nil map, both are map[]. Therefore, don't judge whether map is empty or nil at this time, but judge it by map == nil.

This is the case with the Form field in Request. When ParseForm() is not called directly or indirectly, Form is actually nil. However, if you println it out and it is map[], you may be a little confused. By tracing the source code, we can find that the Form is not initialized at all.

In the FormValue() method, it will be judged whether the Form is nil, and then decide whether to call the ParseForm() method. Of course, you can also manually call the ParseForm() method

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