★切片的基本介绍

1）切片的英文是slice

2）七篇是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的机制。

3）切片的使用和数组类似，遍历切片、访问切片的元素和求切片的长度len（slice）都一样。

4）切片的长度是可以变化的。因此切片是一个可以动态变化数组。

5）切片定义的基本语法：

　　var 变量名 []类型

　　比如： var a []int

package main

import (
    "fmt"
)

func main() {
    //演示切片的使用
    //切片的来源是数组，首先要存在数组
    var intArr [5]int = [...]int {1,22,33,44,66}
    //声明定义一个切片
    //slice := intArr[1:3]
    //1. slice 就是切片名
    //2. intArr[1:3] 表示 slice 引用到intArr这个数组
    //3. 引用intArr数组的起始下标为 1， 最后的下标为3（但是不包含3）
    slice := intArr[1:3]
    fmt.Println("intArr = ",intArr)
    fmt.Println("slice 的元素是 = ",slice)
    fmt.Println("slice 的元素个数 = ",len(slice))
    fmt.Println("slice 的容量 =",cap(slice))
}

★切片的使用

方式1

第一种方式：定义一个切片，然后让切片去引用一个已经创建好的数组，比如前面的案例就是这样的。

方式2

第二种方式：通过make来创建切片。

基本语法：

　　 var 切片名 []type = make([],len,[cap])

参数说明：

　　type：就是数据类型

　　len：大小

　　cap：指定切片容量，可选

import (
    "fmt"
)

func main() {
    //演示切片的使用 make
    var slice []float64 = make([]float64,5,10)
    slice[1] = 10
    slice[3] = 20
    //对于切片必须make使用
    fmt.Println(slice)
    fmt.Println("slice的size=",len(slice))
    fmt.Println("slice的cap=",cap(slice))
}

方式3

第三种方式：定义一个切片，直接就指定具体数组，使用原理类似make的方式

import (
    "fmt"
)

func main() {
    //演示切片的使用，直接定义

    var slice []int = []int {1,3,5}
    fmt.Println(slice)
}

方式1和方式2的区别（面试）

方式1是直接应用数组，这个数组是事先存在的，程序员是可见的。

方式2是通过马克来创建切片，make也会创建一个数组，是由切片在底层进行维护，程序员是看不见的。

★切片的遍历

切片的遍历和数组一样，也由两种方式

方式1：for循环常规遍历

import (
    "fmt"
)

func main() {
    //使用常规的for循环遍历切片
    var arr [5]int = [...]int{10,20,30,40,50}
    slice := arr[1:4]
    for i :=0;i< len(slice); i++{
        fmt.Printf("slice[%v]=%v",i,slice[i])
    }

}

 

方式2：for-range结构遍历切片

import (
    "fmt"
)

func main() {

    //使用for-range 方式遍历切片
    for i,v := range slice{
        fmt.Printf("i=%v v=%v \n",i,v)
    }
}

★切片注意事项和细节说明

1）切片初始化时，var slice = arr[startIndex:endIndex]

　　说明：从arr数组洗标为startIndex，取到下标为endIndex的元素（不含arr[endIndex]）。

2）切片初始化时，仍然不能越界。范围在[0-len(arr)]之间，但是可以动态增长。

　　2.1）var slice = arr[0:end] 可以简写 var slice = arr[:end]

　　2.2）var slice = arr[start:len(arr)] 可以简写：var slice = arr[start:]

　　2.3）var slice = arr[0:len(arr)] 可以简写： var slice = arr[:]

3）cap是一个内置函数，用于统计切片的容量，即最大可以存放多少个元素。

4）切片定义完后，还不能使用，因为本身是一个空的，需要让其引用到一个数组，或者make一个空间供切片来使用

5）切片可以继续切片

★切片的遍历

切片的遍历有两种方式

方式1 ：for循环常规方式

import (
    "fmt"
)

func main() {
    //使用常规for循环遍历切片
    var   arr [5]int = [...]int{10,20,30,40,50}
    slice := arr[1:4]
    for i :=0;i < len(slice); i++{
        fmt.Printf("slice[%v]=%v",i,slice[i])
    }
}

 

方式2：for-range方式

import (
    "fmt"
)

func main() {

    //使用for-ange 方式遍历切片
    for  i, v := range slice {
        fmt.Printf("i=%v v=%v \n",i,v)
    }
}