chan中传递map数据,传递的是引用

前端之家收集整理的这篇文章主要介绍了chan中传递map数据,传递的是引用前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

写个demo测试一下,channel中传递的是数据的拷贝,还是引用?

预期:传递的是引用类型

  1. package main
  2.  
  3. import (
  4. "fmt"
  5. )
  6.  
  7. func main() {
  8. var sliceChan chan [2]map[string]int = make(chan [2]map[string]int,2)
  9.  
  10. //construct array
  11. m1 := map[string]int{
  12. "rows":12,}
  13. m2 := map[string]int{
  14. "columns":10,}
  15. bulk := [2]map[string]int{m1,m2}
  16.  
  17. //directly read then
  18. sliceChan <- bulk
  19. e := <-sliceChan
  20. fmt.Println(e)
  21.  
  22. //modify m2
  23. m2["finish"] = 1
  24. fmt.Println(e);
  25. }

最终输出的结果,跟预想的一样。打印的结果说明,e使用引用的是原数据的地址。

  1. [map[rows:12] map[columns:10]]
  2. [map[rows:12] map[columns:10 finish:1]]

修改chan数据类型,下面替换为依次替换为数组、slice、struct对象。

传递数组类型

只需修改chan类型,其他不变。将chan类型修改为[2]int类型,其他不变。预期返回的应该是值得拷贝

  1. func main() {
  2. var sliceChan chan [2]int = make(chan [2]int,1)
  3.  
  4. //construct array
  5. bulk := [2]int{1,2}
  6.  
  7. //directly read then
  8. sliceChan <- bulk
  9. e := <-sliceChan
  10. fmt.Println(e)
  11.  
  12. //modify m2
  13. bulk[1] = 3
  14. fmt.Println(e);
  15. fmt.Println(bulk)
  16. }

返回结果跟预期一致:

  1. [1 2]
  2. [1 2]
  3. [1 3]

修改类型为slice

  1. func main() {
  2. var sliceChan chan []int = make(chan []int,1)
  3.  
  4. //construct array
  5. bulk := []int{1,2}
  6.  
  7. //directly read then
  8. sliceChan <- bulk
  9. e := <-sliceChan
  10. fmt.Println(e)
  11.  
  12. //modify m2
  13. bulk[1] = 3
  14. fmt.Println(e);
  15. fmt.Println(bulk)
  16. }

跟预期一致,传递的跟map一样,也是引用。返回的结果如下:

  1. [1 2]
  2. [1 3]
  3. [1 3]

修改类型为struct

预期当struct传递值类型的时候,传递的是值得拷贝;传递引用类型的时候,传递的是引用

  1. func main() {
  2. type people struct {
  3. name string
  4. age int
  5. }
  6. var sliceChan chan people = make(chan people,1)
  7.  
  8. //construct array
  9. bulk := people{
  10. "zhangshan",28,}
  11.  
  12. //directly read then
  13. sliceChan <- bulk
  14. e := <-sliceChan
  15. fmt.Println(e)
  16.  
  17. //modify m2
  18. bulk.name = "wangwu"
  19. fmt.Println(e);
  20. fmt.Println(bulk)
  21. }

上述使用的是值拷贝,结果也确实是这样

  1. {zhangshan 28}
  2. {zhangshan 28}
  3. {wangwu 28}

修改成引用后,确实也是引用传递了。

Golang为什么要这样设计了?这样设计有什么好处?

猜你在找的Go相关文章