golang 切片小记

1 切片初始化

 func printSlice(s []int) {
     fmt.Printf("len=%d cap=%d underlying array:%p, %v\n", len(s), cap(s), s, s)
 }

 func sliceInit() {

     var s1 []int   //声明s1，并没有初始化，此时s1是nil切片，没有分配底层数组
     if s1 == nil {
         fmt.Println("s1 is nil")
     }

     s2 := []int{}
     if s2 == nil {
         fmt.Println("s2 is nil")
     }

     s3 := make([]int, )
     if s3 == nil {
         fmt.Println("s3 is nil!")
     }

     printSlice(s1)
     printSlice(s2)
     printSlice(s3)
 }
 func main(){
     sliceInit()
 }

Out：

s1 is nil
len= cap= underlying array:0x0, []
len= cap= underlying array:0x55c988, []
len= cap= underlying array:0x55c988, []

2 切片长度与容量

切片的长度就是它所包含的元素个数。

切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数

func main() {
    s := []int{, , , , , }
    printSlice(s)

    // Slice the slice to give it zero length.
    s = s[:]
    printSlice(s)

    // Extend its length.
    s = s[:]
    printSlice(s)

    // Drop its first two values.
    s = s[:]
    printSlice(s)
}

Out：

len= cap= underlying array:0xc04200a2a0, [     ]
len= cap= underlying array:0xc04200a2a0, []
len= cap= underlying array:0xc04200a2a0, [   ]
len= cap= underlying array:0xc04200a2b0, [ ]

3 赋值与传参

 func sliceT() {
     arrayA := []int{, , , , }
     fmt.Printf("arrayA: %p, %v\n", arrayA, arrayA)
     fmt.Printf("arrayA: %p, %v\n", &arrayA, arrayA)

     fmt.Printf("arrayA: %p, %v\n", &arrayA[], arrayA)
     fmt.Printf("arrayA: %p, %v\n", &arrayA[], arrayA)
     fmt.Printf("arrayA: %p, %v\n", &arrayA[], arrayA)
     fmt.Printf("arrayA: %p, %v\n", &arrayA[], arrayA)
     fmt.Printf("arrayA: %p, %v\n", &arrayA[], arrayA)

     slice := arrayA[::]
     fmt.Printf("slice: %p, %v\n", slice, slice)
     fmt.Printf("slice: %p, %v\n", &slice[], slice)
     fmt.Printf("slice: %p, %v\n", &slice[], slice)

     slice[] =
     fmt.Printf("slice: %p, %v\n", slice, slice)
     fmt.Printf("arrayA: %p, %v\n", &arrayA, arrayA)

 }

Out

 arrayA: %!p([]int=[    ]), [    ]
 arrayA: 0xc04206c030, [    ]
 arrayA: 0xc04206c030, [    ]
 arrayA: 0xc04206c038, [    ]
 arrayA: 0xc04206c040, [    ]
 arrayA: 0xc04206c048, [    ]
 arrayA: 0xc04206c050, [    ]
13 slice: 0xc04206c038, [ ]
14 slice: 0xc04206c038, [ ]
15 slice: 0xc04206c040, [ ]
 slice: 0xc04206c038, [ ]
 arrayA: 0xc04206c030, [    ]

2~4

一个数组变量表示整个数组，它不是指向第一个元素的指针（不像 C 语言的数组）因此数组名通过%p 无法打印地址。 当一个数组变量被赋值或者被传递的时候，实际上会复制整个数组。 （为了避免复制数组，可以传递一个指向数组的指针）

6~9

int 在64机器上占8个字节

12~15

切片语法 a[ low:high:cap ]; cap 表示切片容量

切片名通过%p 打印，输出的是切片所引用的底层数组的地址

18~19

改变切片元素值就是改变其引用的数组的对应元素值

 func sliceT() {
     s := []int{,,,,}
     fmt.Printf("underlying array: %p, slice addr: %p\n", s, &s)
     changeSlice(s)
     fmt.Println(s)
 }

 func changeSlice(s []int) {
     fmt.Printf("underlying array: %p, param slice addr: %p\n", s, &s)
     s[] = -
 }

Out：

underlying array: 0xc04206c030, slice addr: 0xc04204a3a0
underlying array: 0xc04206c030, param slice addr: 0xc04204a400
[ -   ]

 func sliceT1() {
     s := []int{,,,,}
     fmt.Printf("underlying array: %p, slice addr: %p\n", s, &s)
     changeSlice1(s)
     fmt.Println(s)
 }

 func changeSlice1(s []int) {
     fmt.Printf("underlying array: %p, param slice addr: %p\n", s, &s)
     s = append(s, )
 }

Out：

underlying array: 0xc04200a2a0, slice addr: 0xc0420023e0
underlying array: 0xc04200a2a0, param slice addr: 0xc042002440
[    ]

切片作为函数参数传递时是值传递，会拷贝一个切片，但形参和实参，拥有相同的底层数组引用。

更多内容： https://blog.go-zh.org/go-slices-usage-and-internals

https://www.jianshu.com/p/030aba2bff41