Golang指针与Map类型操作实例

go中map是引用类型，传参时无需指针即可修改内容；使用*map仅在需修改map变量本身（如置为nil）时才必要。

在golang中，指针与Map类型的操作是一个既基础又容易让人产生疑问的话题。简单来说，go语言中的Map本身就是一种引用类型，它在内部维护着一个指向底层数据结构的指针。这意味着当你将一个Map传递给函数或者赋值给另一个变量时，你实际上是在复制这个引用，而不是复制整个Map的数据。因此，通过这个引用对Map内容进行的任何修改，都会反映在原始Map上。而如果需要修改Map变量本身（比如将其置为nil或重新初始化），就需要使用到指向Map的指针。

解决方案

理解Golang中指针与Map的交互，关键在于区分“Map是引用类型”和“指向Map的指针”这两种情况。

Map作为引用类型： 当你声明一个

map[KeyType]ValueType

并用

make

初始化后，这个Map变量实际上是一个头部结构，其中包含了指向实际底层数据（哈希表）的指针。

package main  import "fmt"  func modifyMapContent(m map[String]int) {     m["apple"] = 20     m["banana"] = 30     delete(m, "orange") }  func main() {     myMap := make(map[string]int)     myMap["apple"] = 10     myMap["orange"] = 15      fmt.Println("Original map:", myMap) // Output: Original map: map[apple:10 orange:15]      modifyMapContent(myMap)      fmt.Println("Modified map:", myMap) // Output: Modified map: map[apple:20 banana:30] } 

在这个例子中，

modifyMapContent

函数接收的是

myMap

的一个副本，但这个副本仍然指向与

myMap

相同的底层哈希表。所以，函数内部对Map内容的修改直接影响了

main

函数中的

myMap

。

*指向Map的指针 (`map[KeyType]ValueType

)：** 当你需要从一个函数内部，彻底改变调用者持有的Map变量本身（例如，将其置为

nil`，或者让它指向一个全新的Map实例），这时就需要传入一个指向Map变量的指针。

立即学习“go语言免费学习笔记（深入）”；

package main  import "fmt"  func reassignMap(m *map[string]int) {     // 将传入的指针指向的Map变量置为nil     *m = nil }  func initializeNewMap(m *map[string]int) {     // 将传入的指针指向的Map变量重新初始化为一个新的Map     *m = make(map[string]int)     (*m)["new_key"] = 100 }  func main() {     myMap := make(map[string]int)     myMap["old_key"] = 50     fmt.Println("Before reassign:", myMap) // Output: Before reassign: map[old_key:50]      reassignMap(&myMap) // 传入myMap的地址     fmt.Println("After reassign:", myMap)  // Output: After reassign: map[] (实际上是nil map，打印为空)      // myMap 现在是 nil，需要重新make才能使用     initializeNewMap(&myMap) // 传入myMap的地址，让它指向一个新Map     fmt.Println("After initialize new map:", myMap) // Output: After initialize new map: map[new_key:100] } 

这个例子清楚地展示了

*map

的用途：它允许你改变Map变量本身所引用的对象，而不仅仅是修改Map的内容。

Map值是自定义结构体指针： 更常见的场景是Map的值类型是一个结构体指针，这允许你直接修改Map中存储的结构体实例的字段，而无需将整个结构体取出、修改再放回。

package main  import "fmt"  type User struct {     ID   int     Name string }  func main() {     userMap := make(map[int]*User)      user1 := &User{ID: 1, Name: "Alice"}     userMap[1] = user1      userMap[2] = &User{ID: 2, Name: "Bob"} // 直接存入结构体指针      fmt.Println("Original user 1 name:", userMap[1].Name) // Output: Original user 1 name: Alice      // 通过Map中存储的指针直接修改User的Name字段     userMap[1].Name = "Alicia"     fmt.Println("Modified user 1 name:", userMap[1].Name) // Output: Modified user 1 name: Alicia      // 如果Map值是结构体本身（非指针），则无法直接修改字段     // userMapValue := make(map[int]User)     // userMapValue[3] = User{ID: 3, Name: "Charlie"}     // userMapValue[3].Name = "Charles" // 编译错误：cannot assign to userMapValue[3].Name (value of type User)     // 因为 userMapValue[3] 是一个值副本，取不到地址，不能直接修改其内部字段 } 

当Map的值是

*User

时，

userMap[1]

返回的是一个

*User

类型的指针，你可以直接通过这个指针访问和修改其字段。如果Map的值是

User

（非指针），那么

userMap[1]

返回的是一个

User

的副本，对其字段的修改不会影响到Map中存储的原始值，而且Go语言不允许直接对Map返回的值进行取地址操作来修改其字段。

Golang中，Map本身是不是指针？为什么我们很少看到

*map

？

这是一个非常好的问题，也常常是初学者感到困惑的地方。从技术角度讲，Golang的

map

类型确实可以被视为一种“引用类型”（reference type），它内部封装了一个指向底层哈希表数据结构的指针。当你声明一个

map

变量时，你得到的实际上是一个Map头部结构，这个结构体包含了指向哈希表数据的指针、哈希函数、大小等元信息。

因此，当你将一个

map

变量赋值给另一个变量，或者将其作为函数参数传递时，Go语言会复制这个Map头部结构。这意味着新的变量或函数参数会拥有与原始Map相同的底层数据结构的指针。所以，通过新的变量或函数参数对Map内容（添加、删除或修改键值对）的任何操作，都会直接作用于原始Map所引用的那份数据。这也就是为什么我们说Map是引用类型，它不需要像切片那样，在函数内部修改后还需要返回新的切片。

正因为这种行为，在绝大多数情况下，我们不需要在函数参数中使用

*map[K]V

这样的语法。如果你只是想在函数内部修改Map的键值对内容，直接传入

map[K]V

就足够了，它已经提供了“引用”行为。

那什么时候会用到

*map[K]V

呢？它存在的意义，在于当你需要改变Map变量本身所引用的对象时。比如，你可能想在函数内部将一个Map变量彻底置为

nil

，或者让它指向一个全新的、通过

make

创建的Map实例。在这种情况下，仅仅传入

map[K]V

是不够的，因为函数接收的是Map头部结构的副本，你只能修改副本指向的底层数据，而不能改变副本本身指向的Map实例。只有传入

*map[K]V

，才能通过解引用

*m

来修改调用者持有的Map变量。

所以，我们很少看到

*map

，是因为Go语言的设计让Map在行为上已经足够像引用类型，能够满足大部分内容修改的需求，而

*map

只在少数特定场景下才显得必要。这体现了Go语言追求简洁和避免不必要复杂性的设计哲学。

如何通过Map中的指针值修改数据？（以及一些常见陷阱）

在Golang中，当Map的值类型是指针时，修改数据变得非常直接和高效。这通常发生在Map存储的是自定义结构体的指针，例如

map[int]*User

。

直接修改指针值指向的数据： 如果你的Map定义是

m := make(map[KeyType]*ValueType)

，那么当你通过

m[key]

获取到

*ValueType

时，你实际上得到了一个指向

ValueType

实例的指针。此时，你可以直接通过这个指针来访问并修改

ValueType

实例的字段。Go语言的语法糖甚至允许你省略显式的解引用操作（

(*ptr).Field

），直接写成

ptr.Field

。

package main  import "fmt"  type Product struct {     ID    string     Name  string     Price float64 }  func main() {     products := make(map[string]*Product)      // 存入Product结构体的指针     products["p1"] = &Product{ID: "p1", Name: "Laptop", Price: 1200.0}     products["p2"] = &Product{ID: "p2", Name: "Mouse", Price: 25.0}      fmt.Printf("Original Laptop Price: %.2fn", products["p1"].Price) // Output: Original Laptop Price: 1200.00      // 直接通过Map中存储的指针修改Product的Price字段     products["p1"].Price = 1150.0 // 降价了！     fmt.Printf("New Laptop Price: %.2fn", products["p1"].Price)    // Output: New Laptop Price: 1150.00      // 甚至可以修改整个指针指向的对象，虽然不常见     // products["p1"] = &Product{ID: "p1", Name: "Gaming Laptop", Price: 1500.0}     // fmt.Printf("Replaced Laptop Name: %sn", products["p1"].Name) // Output: Replaced Laptop Name: Gaming Laptop } 

这种方式的优点是效率高，避免了不必要的复制操作，尤其是在处理大型结构体时。

多墨智能

多墨智能 – AI 驱动的创意工作流写作工具

99

查看详情

常见陷阱：尝试修改Map中非指针值类型的数据 一个非常常见的错误，尤其对于初学者，是尝试直接修改Map中存储的值类型（非指针）的结构体字段。

package main  import "fmt"  type Item struct {     Name  string     Count int }  func main() {     inventory := make(map[string]Item)      inventory["apple"] = Item{Name: "Apple", Count: 10}      // 错误示范：Go不允许直接修改Map中值类型元素的字段     // inventory["apple"].Count = 15 // 编译错误: cannot assign to inventory["apple"].Count (value of type Item)      // 正确的做法是：取出值，修改，再放回     appleItem := inventory["apple"] // 取出副本     appleItem.Count = 15           // 修改副本     inventory["apple"] = appleItem // 将修改后的副本放回Map      fmt.Printf("Updated Apple Count: %dn", inventory["apple"].Count) // Output: Updated Apple Count: 15      // 另一个常见的错误是试图获取Map值类型的地址     // ptr := &inventory["apple"] // 编译错误: cannot take address of map element } 

为什么会这样？因为

inventory["apple"]

返回的是

Item

结构体的一个副本。Map的内部实现可能会在内存中移动其元素，所以Go不允许你直接获取Map元素的地址。如果你能获取地址并修改，当Map内部结构发生变化（比如扩容），你持有的地址可能就失效了，导致不确定行为。

因此，当Map存储的是值类型时，你必须先取出这个值，对副本进行修改，然后再将修改后的副本重新存回Map中，覆盖原来的值。为了避免这种繁琐的操作，当Map的值是结构体且你需要频繁修改其字段时，通常会选择将Map的值定义为结构体的指针（

*Item

）。

什么时候应该使用

*map[K]V

？什么时候应该避免？

理解

*map[K]V

的适用场景和限制，对于写出清晰、高效的Go代码至关重要。这并非一个非黑即白的选择，更多是基于你希望实现的行为和Go语言的惯例。

*什么时候应该使用 `map[K]V`？**

使用

*map[K]V

的主要场景是，当你需要在函数内部改变Map变量本身所引用的对象时。这意味着你不仅想修改Map的键值对内容，更想修改

main

函数或其他调用者持有的那个Map变量指向的内存地址。

1. 在函数内部将Map置为

   nil

   或重新初始化： 这是最典型的用例。如果你有一个函数需要“清空”一个Map，或者让它指向一个全新的Map实例，那么你必须传入

   *map[K]V

   。

   func clearAndReset(m *map[string]string) {     *m = nil // 将Map置为nil     // 或者     // *m = make(map[string]string) // 重新初始化为一个新的空Map }

   如果不传入指针，你修改的只是函数参数的副本，原始Map变量不会受到影响。

2. 实现接口方法时，需要修改Map字段的结构体： 虽然不直接是

   *map

   ，但如果一个结构体包含一个Map字段，并且该结构体实现了某个接口，而接口方法需要修改这个Map字段，那么该方法通常需要一个指针接收者。

   type MyData struct {     Values map[string]int }  func (md *MyData) AddValue(key string, val int) {     if md.Values == nil {         md.Values = make(map[string]int) // 如果是nil，需要初始化     }     md.Values[key] = val }

   这里

   AddValue

   方法需要

   *MyData

   作为接收者，才能修改

   MyData

   实例中的

   Values

   Map。

*什么时候应该避免使用 `map[K]V`？**

在大多数情况下，你都应该避免在函数参数中使用

*map[K]V

，而直接使用

map[K]V

。

1. 仅修改Map的键值对内容时： 这是最常见的场景。由于Map本身就是引用类型，传递

   map[K]V

   作为函数参数时，函数内部对Map内容（添加、删除、修改键值对）的任何操作都会反映到原始Map上。

   func updateScores(scores map[string]int, name string, score int) {     scores[name] = score }

   这里，

   scores

   参数直接就是

   map[string]int

   ，不需要指针。使用

   *map[string]int

   只会增加不必要的解引用操作和代码复杂度。

2. 作为结构体字段时： 在结构体中定义Map字段时，通常直接使用

   map[K]V

   ，而不是

   *map[K]V

   。

   type Config struct {     Settings map[string]string // 通常这样定义     // OtherSettings *map[string]string // 很少这样定义，除非有特殊需求 }

   当

   Config

   实例被传递时，其内部的

   Settings

   Map字段的行为与独立Map变量的传递行为一致。

总结来说，Go语言的惯例是，除非你明确需要修改一个Map变量本身所指向的底层内存地址（即重新赋值

nil

make

map[K]V

。 这种做法与Go语言中切片（slice）的传递方式类似：如果你想修改切片头（长度、容量、底层数组指针），你需要传入

*[]T

；如果只是修改切片元素，传入

[]T

就够了。理解这一点，能帮助你写出更符合Go语言习惯、更清晰且更易于维护的代码。过度使用指针往往会引入不必要的复杂性。