本文系第十二篇Golang语言学习教程
上一节学习了golang数组的知识，这节开始学习切片的概念应用；首先来看多维数组

多维数组

Go语言可以创建多维数组：

package main

import "fmt"

func test(a [3][2]string) {   //定义函数test，输入值为多维二维数组 a
    for _, v1 := range a {
        for _, v2 :=range v1 {
            fmt.Printf("%s ", v2)  //两次循环得到其中一个值并输出
        }
        fmt.Println("\n")
    }
}

func main() {
    a := [3][2]string{  //定义一个二维数组
        {"1x1", "1x2"},
        {"2x1", "2x2"},
        {"3x1", "3x2"},
    }
    test(a) //调用函数输出
}

上面程序中用简略语法声明一个二维数组 a，使用两个range循环来打印数组的值。
以上程序的输出为：

1x1 1x2
2x1 2x2
3x1 3x2

另一种声明语法为一个个添加字符串索引来达到初始化二维数组的目的：

func main() {
    var b [3][2]string
    b[0][0] = "apple"
    b[0][1] = "samsung"
    b[1][0] = "microsoft"
    b[1][1] = "google"
    b[2][0] = "AT&T"
    b[2][1] = "T-Mobile"
    fmt.Printf("\n")
    test(b)
}

切片

切片是由数组建立的一种方便、灵活、功能强大的包装。切片本身不拥有任何数据，只是对现有数组引用。

带有T类型元素的切片由[]T表示，T代表slice中元素的类型：

package main

import "fmt"

func main(){
    a := [6]int{45, 56, 67, 78, 89, 90}
    var b []int = a[1:5]  //创建一个切片 从 a[1] - a[4]
    fmt.Println(b)
}

以上程序中，由a[start:end]创建了一个从a数组索引start到end-1的切片.
a[1:5]创建了一个从a[1] - a[4]的切片。切片b的值为：[56 67 78 89]

还有另一种创建切片的方法：

package main

import "fmt"

func main(){
    c := []int{6, 7, 8}  //创建一个数组 c ,并返回一个存储在 c 中的切片引用
    fmt.Println(c)
}

修改切片

切片不拥有自己的数据，它只是底层数组的一种表现形式。因此对切片进行任何修改都会反映在底层数组中。

package main

import "fmt"

func main(){
    num := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}   //定义数组 num 
    snum := num[2:8]   //创建切片从 num[2] - num[7]
    fmt.Println("before change", num)   //输出改变前
    for i := range snum {
        snum[i]++  //给切片每个参数+1
    }
    fmt.Println("after change", num)   //输出改变后
}

以上程序中创建了一个切片snum，for循环将切片的索引逐个递增，当打印数组时，可以看到对切片的更改反映在了数组中：

before change [1 2 3 4 5 6 7 8 9]
after change [1 2 4 5 6 7 8 9 9]

并且多个切片共用相同的数组时，每个切片所做的更改都将反映在数组中。
定义切片时若不标明开始和结束值，如：num[:] 则开始和结束的默认值分别为 0 和 len (numa)，即引用整个数组。

切片的长度和容量

slice的长度对应slice中的元素数量；长度不能超过容量。容量一般是从slice的开始为止到底层数组的结束位置。
写一个月份的程序，来理解slice的长度和容量：

package main

import "fmt"

func main(){
    /*一个数组的第一个索引是从0开始，若想跳过0，则用1:的方式，第0个元素会自动初始化为空字符串*/
    months := [...]string{1: "Jan", 2: "Feb", 3: "Mar", 4: "Apr", 5: "May", 6: "Jun", 7: "Jul", 8: "Aug", 9: "Sep", 10: "Oct", 11: "Nov", 12: "Dec"}
    Q2 := months[4:7]  //第二季度
    summer := months[6:9]   //夏天

    fmt.Printf("length of Q2 is %d, capacity is %d\n", len(Q2), cap(Q2))
    fmt.Printf("length of summer is %d, capacity is %d", len(summer), cap(summer))
}

以上程序中，切片Q2是由数组months的索引4到6创建的，所以Q2的长度是3；因为是从数组months的索引4开始创建的切片，所以Q2的容量是从4到12 ：9；切片sunmer同理。
以上程序运行结果为：

length of Q2 is 3, capacity is 9
length of summer is 3, capacity is 7

如果切片操作超出容量cap(s)上限将会报错，但是超出长度len(s)上限则意味着扩展了切片，因为新的切片长度会变大。

fmt.Println(summer[:20])   //报错panic:runtime error: slice bounds out of range

package main

import "fmt"

func main(){
    /*一个数组的第一个索引是从0开始，若想跳过0，则用1:的方式，第0个元素会自动初始化为空字符串*/
    months := [...]string{1: "Jan", 2: "Feb", 3: "Mar", 4: "Apr", 5: "May", 6: "Jun", 7: "Jul", 8: "Aug", 9: "Sep", 10: "Oct", 11: "Nov", 12: "Dec"}
    Q2 := months[4:7]  //第二季度
    summer := months[6:9]   //夏天

    //fmt.Printf("length of Q2 %d, capacity %d\n", len(Q2), cap(Q2))
    //fmt.Printf("length of summer %d, capacity %d", len(summer), cap(summer))

    //fmt.Println(summer[:20])  //报错panic:runtime error: slice bounds out of range

    endlessSummer := summer[:5]  //扩展summer长度，并给切片endlessSummer
    fmt.Println(endlessSummer)
    fmt.Printf("the length os endlessSummer is %d, capacity is %d", len(endlessSummer), cap(endlessSummer))
}

以上程序中，扩展了summer的长度，并赋给endlessSummer
以上程序运行结果为：

the length os endlessSummer is 5, capacity is 7

使用make创建切片

func make（[]T，len，cap）[]T 通过传递类型，长度和容量来创建切片。容量是可选参数, 默认值为切片长度。make 函数创建一个数组，并返回引用该数组的切片。

package main

import (
    "fmt"
)

func main() {
    i := make([]int, 5, 5)  //引用make函数创建切片
    fmt.Println(i)
}

追加切片元素

数组的长度是固定的，不可以增加，但是切片的长度是可以增加的，使用append可以将新元素增加到切片上。append 函数的定义是 func append（s[]T，x ... T）[]T。

x ... T 在函数定义中表示该函数接受参数 x 的个数是可变的。这些类型的函数被称为可变函数。

package main

import "fmt"

func main(){
    cars := []string{"Ferrari", "Honda", "Ford"}  //定义切片cars
    fmt.Println(cars)
    fmt.Println("old cars length is ", len(cars), "and capacity is ", cap(cars))  //输出cars的长度和容量
    newcars := append(cars, "BYD")   //cars 切片增加新元素并定义给另一个切片newcars
    fmt.Println(newcars)
    fmt.Println("new cars length is ", len(newcars), "and capacity is ", cap(newcars))  //输出newcars长度和容量

}

以上程序中，原来cars切片的长度是3，容量是3，我们使用append函数添加了一个新元素，并赋给另一个切片newcars。
以上程序运行结果为：

[Ferrari Honda Ford]
old cars length is 3 and capacity is 3
[Ferrari Honda Ford BYD]
new cars length is 4 and capacity is 6

多维切片

类似于数组，切片可以有多个维度。

package main

import "fmt"

func main(){
    /*多维数组*/
    pls := [][]string {
        {"C", "C++"},
        {"JavaScript"},
        {"Go", "Rust"},
    }
    for _, v1 := range pls {
        for _, v2 := range v1 {
            fmt.Printf("%s ", v2)
        }
        fmt.Printf("\n")
    }
}

以上程序运行结果为:

C C++
JavaScript
Go Rust

以上为学习Golang 切片篇