1、赋值操作

  1. // 案例1
  2. var x = 10
  3. fmt.Printf("x的地址%p\n", &x)
  4. y := x
  5. fmt.Printf("y的地址%p\n", &y)
  6. x = 100
  7. fmt.Println(y)
  9. // 案例2
  10. var a = []int{1, 2, 3}
  11. b := a
  12. a[0] = 100
  13. fmt.Println(b)
  15. // 案例3
  16. var m1 = map[string]string{"name":"yuan"}
  17. var m2 = m1
  18. m2["age"] = "22"
  19. fmt.Println(m1)

2、函数传参

  1. package main
  3. import "fmt"
  5. func func01(x int) {
  6.   x = 100
  7. }
  9. func func02(s []int) {
  10.   fmt.Printf("func02的s的地址：%p\n",&s)
  11.   s[0] = 100
  12.   // s = append(s, 1000)
  13. }
  15. func func03(p *int)  {
  16.   *p = 100
  17. }
  18. func main() {
  20.   // 案例1
  21.   var x = 10
  22.   func01(x)
  23.   fmt.Println(x)
  25.   // 案例2
  26.   var s = []int{1, 2, 3}
  27.   fmt.Printf("main的s的地址：%p\n",&s)
  28.   func02(s)
  29.   fmt.Println(s)
  31.   //案例3
  32.   var a = 10
  33.   var p *int = &a
  34.   func03(p)
  35.   fmt.Println(a)
  37. }

Go语言中所有的传参都是值传递（传值），都是一个副本，一个拷贝。因为拷贝的内容有时候是非引用类型（int、string、struct等这些），这样就在函数中就无法修改原内容数据；有的是引用类型（指针、map、slice、chan等这些），这样就可以修改原内容数据。

  1. func makemap(t *maptype, hint int64, h *hmap, bucket unsafe.Pointer) *hmap {
  2. }

make函数创建的map就是一个指针类型，工作原理类似于案例3，所以map数据和切片数据一样虽然值拷贝但依然可以修改原值。