Golang 地图

在 Go 语言中，map 是一种强大、巧妙、通用的数据结构。 Golang Maps 是一组无序的键值对的集合。它被广泛使用，因为它提供了快速查找和值，可以在键的帮助下检索、更新或删除。

• 它是对哈希表的引用。
• 由于它的引用类型，它的传递成本很低，例如，对于 64 位机器，它需要 8 个字节，而对于 32 位机器，它需要 4 个字节。
• 在映射中，键必须是唯一的，并且始终是使用==运算符比较的类型或支持!=运算符的类型。因此，大多数内置类型都可以用作键，如 int、float64、rune、 字符串、可比较数组和结构、指针等。切片和不可比较数组和结构等数据类型或自定义数据类型不具有可比性，请勿用作地图键。
• 在映射中，值不像键那样是唯一的，可以是任何类型，如 int、float64、rune、 字符串、指针、引用类型、映射类型等。
• 键的类型和值的类型必须是相同的类型，同一映射中不允许有不同类型的键和值。但是键的类型和类型值可以不同。
• 该映射也称为哈希映射、哈希表、无序映射、字典或关联数组。
• 在映射中，如果尝试在未初始化的映射中添加值，则只能在映射初始化时添加值，然后编译器会抛出错误。

如何创建和初始化地图？

在 Go 语言中，地图可以使用两种不同的方式创建和初始化：

1. 简单：在此方法中，您可以在不使用make()函数的情况下创建和初始化地图：

   创建地图：您可以使用给定的语法简单地创建地图：

   // An Empty map
   map[Key_Type]Value_Type{}
   
   // Map with key-value pair
   map[Key_Type]Value_Type{key1: value1, ..., keyN: valueN}
   

   例子：

   var mymap map[int]string

   在地图中，地图的零值是 nil 并且一个 nil 地图不包含任何键。如果您尝试在 nil 映射中添加键值对，那么编译器将抛出运行时错误。
   使用地图字面量初始化地图：地图字面量是用数据初始化地图的最简单方法，只需用冒号分隔键值对，如果不使用，最后一个尾随冒号是必需的，那么编译器将给出错误。

   例子：

   // Go program to illustrate how to
   // create and initialize maps
   package main
     
   import "fmt"
     
   func main() {
     
       // Creating and initializing empty map
       // Using var keyword
       var map_1 map[int]int
     
       // Checking if the map is nil or not
       if map_1 == nil {
         
           fmt.Println("True")
       } else {
         
           fmt.Println("False")
       }
     
       // Creating and initializing a map
       // Using shorthand declaration and
       // using map literals
       map_2 := map[int]string{
         
               90: "Dog",
               91: "Cat",
               92: "Cow",
               93: "Bird",
               94: "Rabbit",
       }
         
       fmt.Println("Map-2: ", map_2)
   }
   

   输出：

   True
   Map-2:  map[90:Dog 91:Cat 92:Cow 93:Bird 94:Rabbit]
   

2. 使用 make函数：您还可以使用 make()函数创建地图。这个函数是一个内置函数，在这个方法中，你只需要传递地图的类型，它就会返回一个初始化的地图。]

   句法：

   make(map[Key_Type]Value_Type, initial_Capacity)
   make(map[Key_Type]Value_Type)
   

   例子：

   // Go program to illustrate how to
   // create and initialize a map
   // Using make() function
   package main
     
   import "fmt"
     
   func main() {
     
       // Creating a map
       // Using make() function
       var My_map = make(map[float64]string)
       fmt.Println(My_map)
     
       // As we already know that make() function
       // always returns a map which is initialized
       // So, we can add values in it
       My_map[1.3] = "Rohit"
       My_map[1.5] = "Sumit"
       fmt.Println(My_map)
   }
   

   输出：

   map[]
   map[1.3:Rohit 1.5:Sumit]
   

要点

1. 如何迭代地图？：您可以使用范围 for 循环迭代地图。这个循环的值可能会有所不同，因为地图是一个无序的集合。

   例子：

   // Go program to illustrate how
   // to iterate the map using for
   // rang loop
     
   package main
     
   import "fmt"
     
   // Main function
   func main() {
     
       // Creating and initializing a map
       m_a_p := map[int]string{
     
           90: "Dog",
           91: "Cat",
           92: "Cow",
           93: "Bird",
           94: "Rabbit",
       }
     
       // Iterating map using for rang loop
       for id, pet := range m_a_p {
     
           fmt.Println(id, pet)
       }
   }
   

   输出：

   90 Dog
   91 Cat
   92 Cow
   93 Bird
   94 Rabbit
   

2. 如何在地图中添加键值对？：在地图中，您可以使用给定的语法在初始化的地图中添加键值对：

   map_name[key]=value

   在地图中，如果您尝试添加一个已经存在的键，那么它只会用新值覆盖或更新该键的值。

   例子：

   // Go program to illustrate how to add
   // a key-value pair in the map using
   // make() function
   package main
     
   import "fmt"
     
   // Main function
   func main() {
     
       // Creating and initializing a map
       m_a_p := map[int]string{
           90: "Dog",
           91: "Cat",
           92: "Cow",
           93: "Bird",
           94: "Rabbit",
       }
     
       fmt.Println("Original map: ", m_a_p)
     
       // Adding new key-value pairs in the map
       m_a_p[95] = "Parrot"
       m_a_p[96] = "Crow"
       fmt.Println("Map after adding new key-value pair:\n", m_a_p)
     
       // Updating values of the map
       m_a_p[91] = "PIG"
       m_a_p[93] = "DONKEY"
       fmt.Println("\nMap after updating values of the map:\n", m_a_p)
   }
   

   输出：

   Original map:  map[90:Dog 91:Cat 92:Cow 93:Bird 94:Rabbit]
   Map after adding new key-value pair:
    map[90:Dog 91:Cat 92:Cow 93:Bird 94:Rabbit 95:Parrot 96:Crow]
   
   Map after updating values of the map:
    map[90:Dog 91:PIG 92:Cow 93:DONKEY 94:Rabbit 95:Parrot 96:Crow]
   

3. 如何检索与映射中的键相关的值？：在映射中，您可以使用以下语法在键的帮助下检索值：

   map_name[key]

   如果键在给定的映射中不存在，那么它将返回映射的零值，即 nil。如果键存在于给定的映射中，那么它将返回与该键相关的值。

   例子：

   // Go program to illustrate how to
   // retrieve the value of the key
     
   package main
     
   import "fmt"
     
   // Main function
   func main() {
     
       // Creating and initializing a map
       m_a_p := map[int]string{
           90: "Dog",
           91: "Cat",
           92: "Cow",
           93: "Bird",
           94: "Rabbit",
       }
       fmt.Println("Original map: ", m_a_p)
     
       // Retrieving values with the help of keys
       value_1 := m_a_p[90]
       value_2 := m_a_p[93]
       fmt.Println("Value of key[90]: ", value_1)
       fmt.Println("Value of key[93]: ", value_2)
   }
   

   输出：

   Original map:  map[90:Dog 91:Cat 92:Cow 93:Bird 94:Rabbit]
   Value of key[90]:  Dog
   Value of key[93]:  Bird
   

4. 如何检查映射中的键是否存在？：在映射中，您可以使用以下语法检查给定的键是否存在：

   // With value
   // It will gives the value and check result
   value, check_variable_name:= map_name[key]
   
   or
   
   // Without value using the blank identifier
   // It will only give check result
   _, check_variable_name:= map_name[key]
   

   在这里，如果check_variable_name 的值为 true，则表示该键存在于给定的映射中，如果check_variable_name 的值为 false，则表示该键在给定的映射中不存在。

   例子：

   // Go program to illustrate how to
   // check the key is available or not
     
   package main
     
   import "fmt"
     
   // Main function
   func main() {
     
       // Creating and initializing a map
       m_a_p := map[int]string{
           90: "Dog",
           91: "Cat",
           92: "Cow",
           93: "Bird",
           94: "Rabbit",
       }
     
       fmt.Println("Original map: ", m_a_p)
     
       // Checking the key is available
       // or not in the m_a_p map
       pet_name, ok := m_a_p[90]
       fmt.Println("\nKey present or not:", ok)
       fmt.Println("Value:", pet_name)
     
       // Using blank identifier
       _, ok1 := m_a_p[92]
       fmt.Println("\nKey present or not:", ok1)
   }
   

   输出：

   Original map:  map[90:Dog 91:Cat 92:Cow 93:Bird 94:Rabbit]
   
   Key present or not: true
   Value: Dog
   
   Key present or not: true
   

5. 如何从地图中删除键？：在地图中，您可以使用 delete()函数删除地图中存在的键。它是内置函数，不返回任何值，如果给定映射中不存在键，则不执行任何操作。在此函数，您只需传递要从地图中删除的地图和键即可。

   句法：

   delete(map_name, key)

   例子：

   // Go program to illustrate how to delete a key
     
   package main
     
   import "fmt"
     
   // Main function
   func main() {
     
       // Creating and initializing a map
       m_a_p := map[int]string{
           90: "Dog",
           91: "Cat",
           92: "Cow",
           93: "Bird",
           94: "Rabbit",
       }
     
       fmt.Println("Original map: ", m_a_p)
     
       // Deleting keys
       // Using delete function
       delete(m_a_p, 90)
       delete(m_a_p, 93)
     
       fmt.Println("Map after deletion: ", m_a_p)
   }
   

   输出：

   Original map:  map[90:Dog 91:Cat 92:Cow 93:Bird 94:Rabbit]
   Map after deletion:  map[91:Cat 92:Cow 94:Rabbit]
   

6. 修改地图：众所周知，地图是引用类型的。因此，当我们将现有映射分配给新变量时，两个映射仍然引用相同的底层数据结构。因此，当我们更新一张地图时，它会反映在另一张地图中。

   例子：

   // Go program to illustrate the
   // modification concept in map
     
   package main
     
   import "fmt"
     
   // Main function
   func main() {
     
       // Creating and initializing a map
       m_a_p := map[int]string{
           90: "Dog",
           91: "Cat",
           92: "Cow",
           93: "Bird",
           94: "Rabbit",
       }
       fmt.Println("Original map: ", m_a_p)
     
       // Assigned the map into a new variable
       new_map := m_a_p
     
       // Perform modification in new_map
       new_map[96] = "Parrot"
       new_map[98] = "Pig"
     
       // Display after modification
       fmt.Println("New map: ", new_map)
       fmt.Println("\nModification done in old map:\n", m_a_p)
   }
   

   输出：

   Original map:  map[90:Dog 91:Cat 92:Cow 93:Bird 94:Rabbit]
   New map:  map[90:Dog 91:Cat 92:Cow 93:Bird 94:Rabbit 96:Parrot 98:Pig]
   
   Modification done in old map:
    map[90:Dog 91:Cat 92:Cow 93:Bird 94:Rabbit 96:Parrot 98:Pig]