十六、Go基础编程：复合类型—切片slice

超、凢脫俗 2022-05-16 15:57 138阅读 0赞

1. 概述

数组的长度在定义之后无法再次修改；数组是值类型，每次传递都将产生一份副本。显然这种数据结构无法完全满足开发者的真实需求。Go语言提供了数组切片（slice）来弥补数组的不足。

切片并不是数组或数组指针，它通过内部指针和相关属性引⽤数组⽚段，以实现变⻓⽅案。

slice并不是真正意义上的动态数组，而是一个引用类型。slice总是指向一个底层array，slice的声明也可以像array一样，只是不需要长度。  
![SouthEast][]

# 2. 切片的创建 #

slice和数组的区别：声明数组时，方括号内写明了数组的长度或使用…自动计算长度，而声明slice时，方括号内没有任何字符

var s1 []int //声明切片和声明array一样，只是少了长度，此为空(nil)切片
        s2 := []int{}
    
        //make([]T, length, capacity) //capacity可以省略，则和length的值相同
        var s3 []int = make([]int, 0)
        s4 := make([]int, 0, 0)
    
        s5 := []int{1, 2, 3} //创建切片并初始化

# 3. 切片的操作 #

## 3.1 切片截取 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzg4NzI0OA_size_16_color_FFFFFF_t_70][]

示例说明：![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzg4NzI0OA_size_16_color_FFFFFF_t_70 1][]

3.2 切片和底层数组关系

s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    
        s1 := s[2:5]       //[2 3 4]
        s1[2] = 100        //修改切片某个元素改变底层数组
        fmt.Println(s1, s) //[2 3 100] [0 1 2 3 100 5 6 7 8 9]
    
        s2 := s1[2:6] // 新切片依旧指向原底层数组 [100 5 6 7]
        s2[3] = 200
        fmt.Println(s2) //[100 5 6 200]
    
        fmt.Println(s) //[0 1 2 3 100 5 6 200 8 9]

## 3.3 内建函数 ##

### 3.3.1 append ###

append函数向 slice 尾部添加数据，返回新的 slice 对象：

var s1 []int //创建nil切换
        //s1 := make([]int, 0)
        s1 = append(s1, 1)       //追加1个元素
        s1 = append(s1, 2, 3)    //追加2个元素
        s1 = append(s1, 4, 5, 6) //追加3个元素
        fmt.Println(s1)          //[1 2 3 4 5 6]
    
        s2 := make([]int, 5)
        s2 = append(s2, 6)
        fmt.Println(s2) //[0 0 0 0 0 6]
    
        s3 := []int{1, 2, 3}
        s3 = append(s3, 4, 5)
        fmt.Println(s3)//[1 2 3 4 5]

append函数会智能地底层数组的容量增长，一旦超过原底层数组容量，通常以2倍容量重新分配底层数组，并复制原来的数据：

func main() {
        s := make([]int, 0, 1)
        c := cap(s)
        for i := 0; i < 50; i++ {
            s = append(s, i)
            if n := cap(s); n > c {
                fmt.Printf("cap: %d -> %d\n", c, n)
                c = n
            }
        }
        /*
            cap: 1 -> 2
            cap: 2 -> 4
            cap: 4 -> 8
            cap: 8 -> 16
            cap: 16 -> 32
            cap: 32 -> 64
        */
    }

### 3.3.2 copy ###

函数 copy 在两个 slice 间复制数据，复制⻓度以 len 小的为准，两个 slice 可指向同⼀底层数组。

data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
        s1 := data[8:]  //{8, 9}
        s2 := data[:5] //{0, 1, 2, 3, 4}
        copy(s2, s1)    // dst:s2, src:s1
    
        fmt.Println(s2)   //[8 9 2 3 4]
        fmt.Println(data) //[8 9 2 3 4 5 6 7 8 9]

# 4. 切片做函数参数  #

func test(s []int) { //切片做函数参数
        s[0] = -1
        fmt.Println("test : ")
        for i, v := range s {
            fmt.Printf("s[%d]=%d, ", i, v)
            //s[0]=-1, s[1]=1, s[2]=2, s[3]=3, s[4]=4, s[5]=5, s[6]=6, s[7]=7, s[8]=8, s[9]=9,
        }
        fmt.Println("\n")
    }
    
    func main() {
        slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
        test(slice)
    
        fmt.Println("main : ")
        for i, v := range slice {
            fmt.Printf("slice[%d]=%d, ", i, v)
            //slice[0]=-1, slice[1]=1, slice[2]=2, slice[3]=3, slice[4]=4, slice[5]=5, slice[6]=6, slice[7]=7, slice[8]=8, slice[9]=9,
        }
        fmt.Println("\n")
    }

[SouthEast]: /images/20220503/23b2ed87091740ffabc690c1172ea8a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzg4NzI0OA_size_16_color_FFFFFF_t_70]: /images/20220503/ffc1470d99a64292be059bd0f55ca45a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzg4NzI0OA_size_16_color_FFFFFF_t_70 1]: /images/20220503/1c90cc291472414aa122dc92f0237782.png