数组与slice区别

数组是固定长度的，不同长度的数组不是相同类型，初始化方式如下

  1. t := [3]int{}

slice长度可变，实际上是一个指向相应底层对象的指针，初始化方式如下

  1. t := make([]int, 0)
  3. or
  5. t := []int{}

对任意数组或slice切片得到的是slice，实际上是一个包含了长度和容量的指针，指向了其底层位置

  1. func main() {
  2.     t := [3]int{1,2,3}
  3.     v := t[:]
  4.     fmt.Printf("%v %T %p\n", t, t ,&t)
  5.     fmt.Printf("%v %T %p\n", v, v, v)
  6.     v[1] = 5
  7.     fmt.Printf("%v %T %p\n", t, t, &t)
  8. }
  10. // result
  11. [1 2 3] [3]int 0xc0000ae078
  12. [1 2 3] []int 0xc0000ae078
  13. [1 5 3] [3]int 0xc0000ae078

append

对于append方法，如果其slice所对应的底层数组还有空间，则在原地append，否则会申请新的底层数组空间

  1. func main() {
  2.     t := [3]int{1,2,3}
  3.     v := t[:2]
  4.     fmt.Printf("%v %T %p\n", t, t ,&t)
  5.     fmt.Printf("%v %T %p\n", v, v, v)
  6.     v = append(v ,5)
  7.     fmt.Printf("%v %T %p\n", t, t, &t)
  8.     fmt.Printf("%v %T %p\n", v, v, v)
  11.     fmt.Println("***************************")
  13.     t = [3]int{1,2,3}
  14.     v = t[:]
  15.     fmt.Printf("%v %T %p\n", t, t ,&t)
  16.     fmt.Printf("%v %T %p\n", v, v, v)
  17.     v = append(v ,5)
  18.     fmt.Printf("%v %T %p\n", t, t, &t)
  19.     fmt.Printf("%v %T %p\n", v, v, v)
  20. }
  23. // result
  24. [1 2 3] [3]int 0xc0000ae078
  25. [1 2] []int 0xc0000ae078
  26. [1 2 5] [3]int 0xc0000ae078
  27. [1 2 5] []int 0xc0000ae078
  28. ***************************
  29. [1 2 3] [3]int 0xc0000ae078
  30. [1 2 3] []int 0xc0000ae078
  31. [1 2 3] [3]int 0xc0000ae078
  32. [1 2 3 5] []int 0xc0000c0060

以上是我们所期望多append策略，但并不能保证append一定采用。内置的append采用更复杂的内存扩展策略。因此，通常我们并不知道append调用是否导致了内存的重新分配，因此我们也不能确认新的slice和原始的slice是否引用的是相同的底层数组空间。同样，我们不能确认在原先的slice上的操作是否会影响到新的slice。因此，通常是将append返回的结果直接赋值给输入的slice变量：

  1. runes = append(runes, r)

参数传递

当传参时，数组与slice均是值传递，但slice其实包含3个值，分别是len、cap、和底层指针，所以实际传进去的是底层指针。

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. func printAddressAndChangeValue1(t [3]int) {
  8.     fmt.Printf("the address of array t in function when transmit a value is: %p\n", &t)
  9.     t[1] = 1
  10. }
  12. func printAddressAndChangeValue2(p []int) {
  13.     fmt.Printf("the address of array t in function when transmit a value is: %p\n", p)
  14.     p[1] = 1
  15. }
  17. // 验证go数组是值传递还是地址传递
  18. func main() {
  19.     t := [3]int{9,8,7}
  20.     fmt.Printf("value of t: %v, type of t: %T\n" ,t, t)
  21.     fmt.Printf("the address of array t out function is: %p\n", &t)
  22.     printAddressAndChangeValue1(t)
  23.     fmt.Printf("value of t: %v, type of t: %T\n" ,t, t)
  25.     fmt.Println("************************")
  26.     p := []int{9,8,7}
  27.     fmt.Printf("value of t: %v, type of t: %T\n" ,p, p)
  28.     fmt.Printf("the address of array t out function is: %p\n", p)
  29.     printAddressAndChangeValue2(p)
  30.     fmt.Printf("value of t: %v, type of t: %T\n" ,p, p)
  31. }
  34. // result
  35. value of t: [9 8 7], type of t: [3]int
  36. the address of array t out function is: 0xc000012120
  37. the address of array t in function when transmit a value is: 0xc000012168
  38. value of t: [9 8 7], type of t: [3]int
  39. ************************
  40. value of t: [9 8 7], type of t: []int
  41. the address of array t out function is: 0xc0000121b0
  42. the address of array t in function when transmit a value is: 0xc0000121b0
  43. value of t: [9 1 7], type of t: []int
  45. Process finished with the exit code 0