Go语言基础之切片

本文主要介绍Go语言中切片（slice）及它的基本使用。

一、引子

因为数组的长度是固定的并且数组长度属于类型的一部分，所以数组有很多的局限性。例如：

func arraySum(x [3]int) int{
    sum := 0
    for _, v := range x{
        sum = sum + v
    }
    return sum
}

这个求和函数只能接受[3]int类型，其他的都不支持。再比如，

a := [3]int{1, 2, 3}

数组a中已经有三个元素了，我们不能再继续往数组a中添加新元素了。

二、切片

切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。

切片是一个引用类型，它的内部结构包含地址、长度和容量。切片一般用于快速地操作一块数据集合。

//不论切片中存长度有多大，切片这个变量占得内存空间都是一样大的
	
{
	point:地址
	length：切片长度
	cap：切片容量
}

三、切片的定义

切片不拥有任何数据，只是对现有数组的引用

声明切片类型的基本语法如下：

var name []T

其中，

name:表示变量名
T:表示切片中的元素类型
[]没有长度则是切片

举个例子：

func main() {
    // 声明切片类型
    var a []string              //声明一个字符串切片
    var b = []int{}             //声明一个整型切片并初始化
    var c = []bool{false, true} //声明一个布尔切片并初始化
    var d = []bool{false, true} //声明一个布尔切片并初始化
    fmt.Println(a)              //[]
    fmt.Println(b)              //[] a与b默认值是不同的
    fmt.Println(c)              //[false true]
    fmt.Println(a == nil)       //true
    fmt.Println(b == nil)       //false
    fmt.Println(c == nil)       //false
    // fmt.Println(c == d)   //切片是引用类型，不支持直接比较，只能和nil比较
}

只定义，没有赋值，空值是什么？空切片：nil

三、切片的长度和容量

切片拥有自己的长度和容量，我们可以通过使用内置的len()函数求长度，使用内置的cap()函数求切片的容量。

 //  切片的长度和容量 len,cap， 容量表示最多存放多少个值
var a[9]int = [9]int{0,1,2,3,4,5,6,7,8}
fmt.Println(a) // [0 1 2 3 4 5 6 7 8]

var b[]int = a[3:7]
fmt.Println(b) // [3 4 5 6]
// 长度
fmt.Println(len(b)) // 4
// cap 容量: 数组的长度减去切片开始的位置，就是存放数据的容量
fmt.Println(cap(b)) // 6

四、切片定义方式

基于数组定义切片

由于切片的底层就是一个数组，所以我们可以基于数组定义切片。

func main() {
    // 基于数组定义切片
    a := [5]int{55, 56, 57, 58, 59}
    b := a[1:4]                     //基于数组a创建切片，包括元素a[1],a[2],a[3]
    fmt.Println(b)                  //[56 57 58]
    fmt.Printf("type of b:%T\n", b) //type of b:[]int
    // 改变数据，会不会影响切片，数组或者切片发生改变，都会受到影响
    b[0] = 100
    
    fmt.Println(b) 
	fmt.Println(a) 
}

还支持如下方式：

c := a[1:] //[56 57 58 59]
d := a[:4] //[56, 57, 58]
e := a[:]  //[55 56 57 58 59]
[100 56 57 58 59]
[100 56 57 58 59]

切片再切片

除了基于数组得到切片，我们还可以通过切片来得到切片。

func main() {
    //切片再切片
    a := [...]string{"北京", "上海", "广州", "深圳", "成都", "重庆"}
    fmt.Printf("a:%v type:%T len:%d  cap:%d\n", a, a, len(a), cap(a))
    b := a[1:3]
    fmt.Printf("b:%v type:%T len:%d  cap:%d\n", b, b, len(b), cap(b))
    c := b[1:5]
    fmt.Printf("c:%v type:%T len:%d  cap:%d\n", c, c, len(c), cap(c))
}

输出：

a:[北京 上海 广州 深圳 成都 重庆] type:[6]string len:6  cap:6
b:[上海 广州] type:[]string len:2  cap:5
c:[广州 深圳 成都 重庆] type:[]string len:4  cap:4

注意： 对切片进行再切片时，索引不能超过原数组的长度，否则会出现索引越界的错误。

使用make()函数构造切片

我们上面都是基于数组来创建的切片，如果需要动态的创建一个切片，我们就需要使用内置的make()函数，格式如下：

make([]T, size, cap)

其中：

T:切片的元素类型
size:切片中元素的数量
cap:切片的容量

举个例子：

func main() {
    a := make([]int, 2, 10)
    fmt.Println(a)      //[0 0]
    fmt.Println(len(a)) //2
    fmt.Println(cap(a)) //10
    // 传一个值表示，长度是3，容量也是3
	var b []int = make([]int, 3)
}

上面代码中a的内部存储空间已经分配了10个，但实际上只用了2个。容量并不会影响当前元素的个数，所以len(a)返回2，cap(a)则返回该切片的容量。

多维切片

// 多维切片（用的很少,了解）
var b=[][]string{{"a","b"},{"c","d"}}
var c [][]string=[][]string{{"a","b"},{"c","d"}}
fmt.Println(b)
fmt.Println(len(b))
fmt.Println(cap(b))
fmt.Println(c)
fmt.Println(len(c))
fmt.Println(cap(c))

五、切片的本质

切片的本质就是对底层数组的封装，它包含了三个信息：底层数组的指针（地址）、切片的长度（len）和切片的容量（cap）。

举个例子，现在有一个数组a := [8]int{0, 1, 2, 3, 4, 5, 6, 7}，切片s1 := a[:5]，相应示意图如下。

slice_01 切片s2 := a[3:6]，相应示意图如下：

slice_02

六、切片不能直接比较

切片之间是不能比较的，我们不能使用==操作符来判断两个切片是否含有全部相等元素。 切片唯一合法的比较操作是和nil比较。 一个nil值的切片并没有底层数组，一个nil值的切片的长度和容量都是0。但是我们不能说一个长度和容量都是0的切片一定是nil，例如下面的示例：

var s1 []int         //len(s1)=0;cap(s1)=0;s1==nil
s2 := []int{}        //len(s2)=0;cap(s2)=0;s2!=nil
s3 := make([]int, 0) //len(s3)=0;cap(s3)=0;s3!=nil
if s1 == nil {
		fmt.Println("我是空的")
}

所以要判断一个切片是否是空的，要是用len(s) == 0来判断，不应该使用s == nil来判断。

七、切片的赋值拷贝

下面的代码中演示了拷贝前后两个变量共享底层数组，对一个切片的修改会影响另一个切片的内容，这点需要特别注意。

func main() {
    s1 := make([]int, 3) //[0 0 0]
    s2 := s1             //将s1直接赋值给s2，s1和s2共用一个底层数组
    s2[0] = 100
    fmt.Println(s1) //[100 0 0]
    fmt.Println(s2) //[100 0 0]
}

八、切片遍历

切片的遍历方式和数组是一致的，支持索引遍历和for range遍历。

func main() {
    s := []int{1, 3, 5}

    for i := 0; i < len(s); i++ {
        fmt.Println(i, s[i])
    }

    for index, value := range s {
        fmt.Println(index, value)
    }
}

九、append()方法为切片添加元素

使用内置的append函数，append函数的特点是：哪怕操作的切片是零值nil切片，都不需为其初始化值或用make开辟空间，就可以直接执行append功能开辟空间加添加元素一条龙服务

Go语言的内建函数append()可以为切片动态添加元素。每个切片会指向一个底层数组，这个数组能容纳一定数量的元素。当底层数组不能容纳新增的元素时，切片就会自动按照一定的策略进行“扩容”， 此时该切片指向的底层数组就会更换。“扩容”操作往往发生在append()函数调用时。举个例子：

func main() {
    //append()添加元素和切片扩容
    var numSlice []int
    for i := 0; i < 10; i++ {
        numSlice = append(numSlice, i)
        fmt.Printf("%v  len:%d  cap:%d  ptr:%p\n", numSlice, len(numSlice), cap(numSlice), numSlice)
    }
}

输出：

[0]  len:1  cap:1  ptr:0xc0000a8000
[0 1]  len:2  cap:2  ptr:0xc0000a8040
[0 1 2]  len:3  cap:4  ptr:0xc0000b2020
[0 1 2 3]  len:4  cap:4  ptr:0xc0000b2020
[0 1 2 3 4]  len:5  cap:8  ptr:0xc0000b6000
[0 1 2 3 4 5]  len:6  cap:8  ptr:0xc0000b6000
[0 1 2 3 4 5 6]  len:7  cap:8  ptr:0xc0000b6000
[0 1 2 3 4 5 6 7]  len:8  cap:8  ptr:0xc0000b6000
[0 1 2 3 4 5 6 7 8]  len:9  cap:16  ptr:0xc0000b8000
[0 1 2 3 4 5 6 7 8 9]  len:10  cap:16  ptr:0xc0000b8000

从上面的结果可以看出：

append()函数将元素追加到切片的最后并返回该切片。
切片numSlice的容量按照1，2，4，8，16这样的规则自动进行扩容，每次扩容后都是扩容前的2倍。
扩容是原切片容量的两倍，一旦扩容将不再依赖原先数组，而是底层重新实现了一个引用数据，切片修改值，也不会在影响原先数组，都不会相互影响

append()函数还支持一次性追加多个元素。例如：

var citySlice []string
// 追加一个元素
citySlice = append(citySlice, "北京")
// 追加多个元素
citySlice = append(citySlice, "上海", "广州", "深圳")
// 追加切片
a := []string{"成都", "重庆"}
citySlice = append(citySlice, a...)
fmt.Println(citySlice) //[北京 上海 广州 深圳 成都 重庆]

切片的扩容策略

可以通过查看$GOROOT/src/runtime/slice.go源码，其中扩容相关代码如下：

newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
    newcap = cap
} else {
    if old.len < 1024 {
        newcap = doublecap
    } else {
        // Check 0 < newcap to detect overflow
        // and prevent an infinite loop.
        for 0 < newcap && newcap < cap {
            newcap += newcap / 4
        }
        // Set newcap to the requested cap when
        // the newcap calculation overflowed.
        if newcap <= 0 {
            newcap = cap
        }
    }
}

从上面的代码可以看出以下内容：

首先判断，如果新申请容量（cap）大于2倍的旧容量（old.cap），最终容量（newcap）就是新申请的容量（cap）。
否则判断，如果旧切片的长度小于1024，则最终容量(newcap)就是旧容量(old.cap)的两倍，即（newcap=doublecap），
否则判断，如果旧切片长度大于等于1024，则最终容量（newcap）从旧容量（old.cap）开始循环增加原来的1/4，即（newcap=old.cap,for {newcap += newcap/4}）直到最终容量（newcap）大于等于新申请的容量(cap)，即（newcap >= cap）
如果最终容量（cap）计算值溢出，则最终容量（cap）就是新申请容量（cap）。

需要注意的是，切片扩容还会根据切片中元素的类型不同而做不同的处理，比如int和string类型的处理方式就不一样。

十、使用copy()函数复制切片

首先我们来看一个问题：

func main() {
    a := []int{1, 2, 3, 4, 5}
    b := a
    fmt.Println(a) //[1 2 3 4 5]
    fmt.Println(b) //[1 2 3 4 5]
    b[0] = 1000
    fmt.Println(a) //[1000 2 3 4 5]
    fmt.Println(b) //[1000 2 3 4 5]
}

由于切片是引用类型，所以a和b其实都指向了同一块内存地址。修改b的同时a的值也会发生变化。

Go语言内建的copy()函数可以迅速地将一个切片的数据复制到另外一个切片空间中，copy()函数的使用格式如下：

copy(destSlice, srcSlice []T)

其中：

srcSlice: 数据来源切片
destSlice: 目标切片

举个例子：

func main() {
    // copy()复制切片
    a := []int{1, 2, 3, 4, 5}
    c := make([]int, 5, 5)
     // 如果a长度大于c， c只会保留c的容量的值，如果小于c则是c中的默认值
    copy(c, a)     //使用copy()函数将切片a中的元素复制到切片c
    fmt.Println(a) //[1 2 3 4 5]
    fmt.Println(c) //[1 2 3 4 5]
    c[0] = 1000
    fmt.Println(a) //[1 2 3 4 5]
    fmt.Println(c) //[1000 2 3 4 5]
}

十一、从切片中删除元素

Go语言中并没有删除切片元素的专用方法，我们可以使用切片本身的特性来删除元素。代码如下：

func main() {
    // 从切片中删除元素
    a := []int{30, 31, 32, 33, 34, 35, 36, 37}
    // 要删除索引为2的元素
    a = append(a[:2], a[3:]...)
    fmt.Println(a) //[30 31 33 34 35 36 37]
}

总结一下就是：要从切片a中删除索引为index的元素，操作方法是a = append(a[:index], a[index+1:]...)

下面代码的输出结果。

func main() {
    var a = make([]string, 5, 10)
    for i := 0; i < 10; i++ {
        a = append(a, fmt.Sprintf("%v", i))
    }
    fmt.Println(a)
    fmt.Println(len(a))
}

[ 0 1 2 3 4 5 6 7 8 9]

使用内置的sort包对数组var a = [...]int{3, 7, 8, 9, 1}进行排序。

sort.IntsAreSorted(a[:])
fmt.Println(a)

//降序排列
sort.Sort(sort.Reverse(sort.IntSlice(a[:])))
fmt.Println(a)

十二、总结

中括号内加东西，都是数组,不加东西是切片
定义并初始化之一：通过数组切出来数组[起始:终止],长度,终止-起始,容量数组长度-起始位置
定义并初始化之二：make函数 make(类型，长度，容量)：底层也有一个数组
定义并初始化之三：a:=[]int
定义并初始化之四：var a []int默认值nil
长度和容量 len cap
切片=append(切片，要追加的值，追加的值),var a []int默认值为nil,可以通过append直接添加值
append追加超过切片容量，容量会变成原来容量的两倍，指向新的数组,make(slice,6,10),追加会在6后面添加数据
切片删除数据:a = append(a[:index], a[index+1:]...)
赋值切片copy(目标，源),不依赖原有切片
数组，切片修改，都会相互影响（前提是：切片依附于当前数组）
切片的空值 nil,不能直接比较,判断数组是否为空len(切片)
当做参数传递（在函数中，修改切片，会修改原切片）
遍历跟数组完全一样 range 数组/切片/maps

posted @ 2021-10-16 13:51 RandySun 阅读(210) 评论(0) 编辑收藏举报

刷新页面返回顶部

RandySun

有角度，才会有方向在当下的阶段，必将由程序员来主导，甚至比以往更甚

Go语言基础之切片

Go语言基础之切片

一、引子

二、切片

三、切片的定义

三、切片的长度和容量

四、切片定义方式

基于数组定义切片

切片再切片

使用make()函数构造切片

多维切片

五、切片的本质

六、切片不能直接比较

七、切片的赋值拷贝

八、切片遍历

九、append()方法为切片添加元素

切片的扩容策略

十、使用copy()函数复制切片

十一、从切片中删除元素

十二、总结

公告

RandySun

有角度，才会有方向 在当下的阶段，必将由程序员来主导，甚至比以往更甚

Go语言基础之切片

Go语言基础之切片

一、引子

二、切片

三、切片的定义

三、切片的长度和容量

四、切片定义方式

基于数组定义切片

切片再切片

使用make()函数构造切片

多维切片

五、切片的本质

六、切片不能直接比较

七、切片的赋值拷贝

八、切片遍历

九、append()方法为切片添加元素

切片的扩容策略

十、使用copy()函数复制切片

十一、从切片中删除元素

十二、总结

公告

有角度，才会有方向在当下的阶段，必将由程序员来主导，甚至比以往更甚