GO语言学习——切片一

切片（slice）

数组的长度的固定的、是声明之后不能变的、是类型的一部分

切片是一个引用类型

切片的定义

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

var name []T

其中，

• name:表示变量名
• T:表示切片中的元素类型

切片底层就是数组

切片定义之后初始化 和数组一样 只不过前面没有长度的数字

切片的长度和容量

内置的len()函数求长度

内置的cap()函数求容量

切片指向了一个底层的数组

切片的长度就是它元素的个数

切片的容量是底层数组从切片的第一个元素到最后一个元素的数量

package main

import "fmt"

// 切片slice

func main(){
        // 切片的定义
        var s1 []int // 定义一个存放int类型元素的切片
        var s2 []string // 定义一个存放string类型元素的切片
        fmt.Println(s1, s2)
        fmt.Println(s1 == nil) // true nil 是空的意思
        fmt.Println(s2 == nil) // true
        // 初始化
        s1 = []int{1,2,3}
        s2 = []string{"奋斗", "坚持", "努力"}
        fmt.Println(s1, s2)
        fmt.Println(s1 == nil) // false
        fmt.Println(s2 == nil) // false
        // 长度和容量
        fmt.Printf("len(s1):%d cap(s1):%d\n", len(s1), cap(s1))
        fmt.Printf("len(s2):%d cap(s2):%d\n", len(s2), cap(s2))

        // 2. 由数组得到切片
        a1 := [...]int{1,3,5,7,9,11,13}
        // 基于一个数组切割 左包含右不包含 （左闭右开）
        s3 := a1[0:4] // [1 3 5 7]
        fmt.Println(s3)
        s4 := a1[1:6]
        fmt.Println(s4)
        s5 := a1[:4] // [1 3 5 7]  => [0:4]
        s6 := a1[3:] // [7 9 11 13] => [3:len(a1)]
        s7 := a1[:] // [1 3 5 7 9 11 13]  => [0:len(a1)]
        fmt.Println(s5, s6, s7)
        // 切片的容量是指底层数组的容量
        fmt.Printf("len(s5):%d cap(s5):%d\n", len(s5), cap(s5)) // len(s5):4 cap(s5):7
        // 底层数组从切片的第一个元素到最后的元素数量
        fmt.Printf("len(s6):%d cap(s6):%d\n", len(s6), cap(s6)) // len(s6):4 cap(s6):4
        // 切片再切割
        s8 := s6[3:] // [13]
        fmt.Printf("len(s8):%d cap(s8):%d\n", len(s8), cap(s8)) // len(s8):1 cap(s8):1
        // 切片是引用类型 都指向了底层的一个数组
        fmt.Println("s6: ", s6)
        a1[6] = 1300 // 修改了底层数组的值
        fmt.Println("s6: ", s6)
        fmt.Println("s8: ", s8)
}