逍遥阁

go语言切片笔记

关键词: golang

go语言切片笔记

```
package main

import (
    "fmt"
)

/*
func main(){
    data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    slice := data[2:5:7]
    fmt.Println(slice)
    fmt.Println(len(slice))
    fmt.Println(cap(slice))
}
*/

/*
func main(){
    data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    slice := data[:]
    p := &slice //p是一个指针，指向切片的内存地址
    test := (*p)[1] //*p和slice是等价的变量
    fmt.Println(test)
}
*/

func main(){
    data1 := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    data2 := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    slice1 := data1[0:4:5] //元素有4个，容量是5个
    slice2 := data2[0:4:5] //元素有4个，容量是5个
    slice3 := append(slice1, 10) //再追加1个元素，容量刚好用完(slice1和slice3是同步的)
    slice4 := append(slice2, 10, 20) //再追加2个元素，容量不够了(slice2和slice4不是同步的)
    fmt.Println(slice1, slice3)
    slice1[0] = 30
    fmt.Println(slice1, slice3)
    fmt.Println("-----")
    fmt.Println(slice2, slice4)
    slice2[0] = 40
    fmt.Println(slice2, slice4)
}
```

变量名 := 数组变量[start:end:max]

表示通过指针引用底层数组并且限定在`[start,end)`这个右半开区间规定的区域内

`start`可以省略，默认为0，且不能大于数组长度

`end`可以省略，默认为数组长度，且不能大于数组长度

`max`可以省略，默认为数组长度，且不能大于数组长度

切片的长度len=end-start=len(变量)

切片的容量cap=max-start=cap(变量)

切片可以通过下标访问里面的元素，下标从0开始，最大为`长度-1`

切片本身并非动态数组或数组指针

切片本身是个只读对象

切片不支持比较操作，只能判断是否为nil

切片可以用`append`向尾部追加元素并返回新的切片对象，由于都是引用底层数组，所以只要有一个变量修改了值，另一个变量同步修改，相当于修改内存地址里面的值

```
slice2 := append(slice1, 10, 20)
```

当切片容量不够用的时候情况就不同了，容量不够时会开辟新的数组空间，新的切片对象会指向这个新的数组空间，两个切片变量修改值不再是同步的了

切片的复制用`copy`，如果进行操作的两个切片元素个数不一致，将会按照个数较小的切片进行复制

```
copy(sliceTo, sliceFrom)
```

其他创建切片的语法

```
var 变量名 []类型
变量名 := make([]类型, len, cap)
变量名 := make([]类型, len) //此时cap=len
变量名 := []类型{0, 1, 2, 3}
变量名 := []类型{}
```

admin
2018-11-11 00:18:16
go

文章分类

文章标签

文章归档

友情链接

go语言切片笔记