最适合网络开发者的网站
Golang。初学者课程

尿素

前往地图


前往地图

Maps are used to store data values in key:value pairs.

Each element in a map is a key:value pair.

A map is an unordered and changeable collection that does not allow duplicates.

The length of a map is the number of its elements. You can find it using the len() function.

The default value of a map is nil.

Maps hold references to an underlying hash table.

Go has multiple ways for creating maps.


Creating Maps Using var and :=

Syntax

var a = map[KeyType]ValueType{key1:value1, key2:value2,...}
b := map[KeyType]ValueType{key1:value1, key2:value2,...}

Example

This example shows how to create maps in Go. Notice the order in the code and in the output.

软件包 main
导入(“fmt”)

函数main(){
  var a = map[string]string{"brand": "Ford", "model": "Mustang", "year": "1964"}
  b := map[string]int{"Oslo": 1, "Bergen": 2, "Trondheim": 3, "Stavanger": 4}

  fmt.Printf("a\t%v\n", a)
  fmt.Printf("b\t%v\n", b)
}

结果:

a   map[brand:Ford model:Mustang year:1964]
b   map[Bergen:2 Oslo:1 Stavanger:4 Trondheim:3]
亲自尝试 »

笔记: The order of the map elements defined in the code is different from the way that they are stored. The data are stored in a way to have efficient data retrieval from the map.


Creating Maps Using make() function:

Syntax

var a = make(map[KeyType]ValueType)
b := make(map[KeyType]ValueType)

Example

This example shows how to create maps in Go using the make() function.

软件包 main
导入(“fmt”)

函数main(){
  var a = make(map[string]string) // The map is empty now
  a["brand"] = "Ford"
  a["model"] = "Mustang"
  a["year"] = "1964"
                                 // an is no longer empty
  b := make(map[string]int)
  b["Oslo"] = 1
  b["Bergen"] = 2
  b["Trondheim"] = 3
  b["Stavanger"] = 4

  fmt.Printf("a\t%v\n", a)
  fmt.Printf("b\t%v\n", b)
}

结果:

a   map[brand:Ford model:Mustang year:1964]
b   map[Bergen:2 Oslo:1 Stavanger:4 Trondheim:3]
亲自尝试 »

Creating an Empty Map

There are two ways to create an empty map. One is by using the make() function and the other is by using the following syntax.

Syntax

var a map[KeyType]ValueType

笔记: The make() function is the right way to create an empty map. If you make an empty map in a different way and write to it, it will cause a runtime panic.

Example

This example shows the difference between declaring an empty map using with the make() function and without it.

软件包 main
导入(“fmt”)

函数main(){
  var a = make(map[string]string)
  var b map[string]string

  fmt.Println(a == nil)
  fmt.Println(b == nil)
}

结果:

false
true
亲自尝试 »

Allowed Key Types

The map key can be of any data type for which the equality operator (==) is defined. These include:

  • Booleans
  • Numbers
  • Strings
  • Arrays
  • Pointers
  • Structs
  • Interfaces (as long as the dynamic type supports equality)

Invalid key types are:

  • Slices
  • Maps
  • Functions

These types are invalid because the equality operator (==) is not defined for them.


Allowed Value Types

The map values can be any type.


Accessing Map Elements

You can access map elements by:

Syntax

value = map_name[key]

Example

软件包 main
导入(“fmt”)

函数main(){
  var a = make(map[string]string)
  a["brand"] = "Ford"
  a["model"] = "Mustang"
  a["year"] = "1964"

  fmt.Printf(a["brand"])
}

结果:

Ford
亲自尝试 »

Updating and Adding Map Elements

Updating or adding an elements are done by:

Syntax

map_name[key] = value

Example

This example shows how to update and add elements to a map.

软件包 main
导入(“fmt”)

函数main(){
  var a = make(map[string]string)
  a["brand"] = "Ford"
  a["model"] = "Mustang"
  a["year"] = "1964"

  fmt.Println(a)

  a["year"] = "1970" // Updating an element
  a["color"] = "red" // Adding an element

  fmt.Println(a)
}

结果:

map[brand:Ford model:Mustang year:1964]
map[brand:Ford color:red model:Mustang year:1970]
亲自尝试 »

Remove Element from Map

Removing elements is done using the delete() function.

Syntax

delete(map_name, key)

Example

软件包 main
导入(“fmt”)

函数main(){
  var a = make(map[string]string)
  a["brand"] = "Ford"
  a["model"] = "Mustang"
  a["year"] = "1964"

  fmt.Println(a)

  delete(a,"year")

  fmt.Println(a)
}

结果:

map[brand:Ford model:Mustang year:1964]
map[brand:Ford model:Mustang]
亲自尝试 »

Check For Specific Elements in a Map

You can check if a certain key exists in a map using:

Syntax

val, ok :=map_name[key]

If you only want to check the existence of a certain key, you can use the blank identifier (_) in place of val.

Example

软件包 main
导入(“fmt”)

函数main(){
  var a = map[string]string{"brand": "Ford", "model": "Mustang", "year": "1964", "day":""}

  val1, ok1 := a["brand"] // Checking for existing key and its value
  val2, ok2 := a["color"] // Checking for non-existing key and its value
  val3, ok3 := a["day"]   // Checking for existing key and its value
  _, ok4 := a["model"]    // Only checking for existing key and not its value

  fmt.Println(val1, ok1)
  fmt.Println(val2, ok2)
  fmt.Println(val3, ok3)
  fmt.Println(ok4)
}

结果:

Ford true
 false
 true
true
亲自尝试 »

Example Explained

In this example, we checked for existence of different keys in the map.

The key "color" does not exist in the map. So the value is an empty string ('').

The ok2 variable is used to find out if the key exist or not. Because we would have got the same value if the value of the "color" key was empty. This is the case for val3.


Maps Are References

Maps are references to hash tables.

If two map variables refer to the same hash table, changing the content of one variable affect the content of the other.

Example

软件包 main
导入(“fmt”)

函数main(){
  var a = map[string]string{"brand": "Ford", "model": "Mustang", "year": "1964"}
  b := a

  fmt.Println(a)
  fmt.Println(b)

  b["year"] = "1970"
  fmt.Println("After change to b:")

  fmt.Println(a)
  fmt.Println(b)
}

结果:

map[brand:Ford model:Mustang year:1964]
map[brand:Ford model:Mustang year:1964]
After change to b:
map[brand:Ford model:Mustang year:1970]
map[brand:Ford model:Mustang year:1970]
亲自尝试 »

Iterating Over Maps

You can use range to iterate over maps.

Example

This example shows how to iterate over the elements in a map. Note the order of the elements in the output.

软件包 main
导入(“fmt”)

函数main(){
  a := map[string]int{"one": 1, "two": 2, "three": 3, "four": 4}

  for k, v := range a {
    fmt.Printf("%v : %v, ", k, v)
  }
}

结果:

two : 2, three : 3, four : 4, one : 1,
亲自尝试 »

Iterate Over Maps in a Specific Order

Maps are unordered data structures. If you need to iterate over a map in a specific order, you must have a separate data structure that specifies that order.

Example

软件包 main
导入(“fmt”)

函数main(){
  a := map[string]int{"one": 1, "two": 2, "three": 3, "four": 4}

  var b = []string             // defining the order
  b = append(b, "one", "two", "three", "four")

  for k, v := range a {        // loop with no order
    fmt.Printf("%v : %v, ", k, v)
  }

  fmt.Println()

  for _, element := range b {  // loop with the defined order
    fmt.Printf("%v : %v, ", element, a[element])
  }
}

结果:

two : 2, three : 3, four : 4, one : 1,
one : 1, two : 2, three : 3, four : 4,
亲自尝试 »