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 mainimport "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 mainimport "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 mainimport "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
*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 mainimport "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}
这种方式的优点是效率高，避免了不必要的复制操作，尤其是在处理大型结构体时。
常见陷阱：尝试修改Map中非指针值类型的数据一个非常常见的错误，尤其对于初学者，是尝试直接修改Map中存储的值类型（非指针）的结构体字段。
package mainimport "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
？什么时候应该避免？
理解
*map[K]V
的适用场景和限制，对于写出清晰、高效的Go代码至关重要。这并非一个非黑即白的选择，更多是基于你希望实现的行为和Go语言的惯例。
*什么时候应该使用 `map[K]V`？**
使用
*map[K]V
的主要场景是，当你需要在函数内部改变Map变量本身所引用的对象时。这意味着你不仅想修改Map的键值对内容，更想修改
main
函数或其他调用者持有的那个Map变量指向的内存地址。
在函数内部将Map置为
nil
或重新初始化：这是最典型的用例。如果你有一个函数需要“清空”一个Map，或者让它指向一个全新的Map实例，那么你必须传入
*map[K]V
。
func clearAndReset(m *map[string]string) { *m = nil // 将Map置为nil // 或者 // *m = make(map[string]string) // 重新初始化为一个新的空Map}
如果不传入指针，你修改的只是函数参数的副本，原始Map变量不会受到影响。
实现接口方法时，需要修改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
。
仅修改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
只会增加不必要的解引用操作和代码复杂度。
作为结构体字段时：在结构体中定义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语言习惯、更清晰且更易于维护的代码。过度使用指针往往会引入不必要的复杂性。
以上就是Golang指针与Map类型操作实例的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1404751.html
微信扫一扫 
支付宝扫一扫 
