slice

Go语言的切片是对数组的抽象。

数组的使用

<code>package main

import (

"fmt"

)

// 传递固定长度的数组还是值传递的方式

func printArray(myArray [5]int) {

for index, value := range myArray {

fmt.Println("index:", index, "value:", value)

}

}

func main() {

var myArr [5]int

myArr2 := [10]int{1, 2, 3, 4}

myArr3 := [4]int{1, 2, 3, 4}

myArr4 := []int{1, 2, 3, 4}

for i := 0; i < len(myArr); i++ {

fmt.Println(myArr[i])

}

for index, value := range myArr2 {

fmt.Println("index:", index, "value:", value)

}

fmt.Printf("myArr1 type=%T\n", myArr)

fmt.Printf("myArr2 type=%T\n", myArr2)

fmt.Printf("myArr3 type=%T\n", myArr3)

}

注意：

数组传递的参数是以值拷贝的形式进行传递，如下：（在函数中修改了，但在主函数中并没有变化）

<code>package main

import (

"fmt"

)

// 传递固定长度的数组还是值传递的方式

func printArray(myArray [5]int) {

for index, value := range myArray {

fmt.Println("index:", index, "value:", value)

}

myArray[0] = 15

}

func main() {

myArr2 := [5]int{1, 2, 3, 4}

printArray(myArr2)

fmt.Println("==================")

for index, value := range myArr2 {

fmt.Println("index:", index, "value:", value)

}

}

Go数组的长度不可改变，在特定的场景中这样的集合就不太适合了，Go中就提供了内置类型切片(动态数组)，与数组相比，切片的长度是不固定的，可以追加时可能使得切片的容量增大。

定义切片

可以声明一个未指定大小的数组来定义切片（切片不需要说明长度。）

<code>var identifier []type

使用make()函数来创建切片:

var slice1 []type = make([]type, len)

也可以简写为

slice1 := make([]type, len)

//也可以指定容量，其中capacity为可选参数。

make([]T, length, capacity)

切片的四种初始化的方式

package main

import "fmt"

func main() {

//声明slice是一个切片，并且初始化，默认值是1，2，3长度是len=3

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

//声明slice是一个切片，但是并没有为slice分配空间

var slice2 []int

slice2 = make([]int, 10, 15)

slice2[0] = 100

//声明slice是一个切片，同时给slice分配3个空间，初始化值是0

var slice3 []int = make([]int, 10)

//声明slice是一个切片，同时为slice分配空间，10个空间，初始化值是0，通过:=推导出slice是一个切片

slice4 := make([]int, 10)

fmt.Printf("len=%d,slice=%v\n", len(slice1), slice1)

fmt.Printf("len=%d,slice=%v,cap=%d\n", len(slice2), slice2, cap(slice2))

fmt.Printf("len=%d,slice=%v\n", len(slice3), slice3)

fmt.Printf("len=%d,slice=%v\n", len(slice4), slice4)

}

切片的追加，截取与拷贝

切片示意图：

追加

如果想增加切片的容量，我们必须创建一个新的更大的切片并把原分片的内容都拷贝过来

长度增加后，超过容量，则容量增加2倍

<code>package main

import "fmt"

func main() {

var numbers = make([]int, 3, 5)

fmt.Printf("len=%d,cap=%d,slice=%v\n", len(numbers), cap(numbers), numbers)

numbers = append(numbers, 1)

fmt.Printf("len=%d,cap=%d,slice=%v\n", len(numbers), cap(numbers), numbers)

numbers = append(numbers, 1)

numbers = append(numbers, 1)

fmt.Printf("len=%d,cap=%d,slice=%v\n", len(numbers), cap(numbers), numbers)

}

截取

<code>s := []int{1, 2, 3}

//左闭右开

s1 := s[0:2]

s1[0] = 100

s[1] = 200

fmt.Printf("len=%d,cap=%d,slice=%v\n", len(s), cap(s), s)

fmt.Printf("len=%d,cap=%d,slice=%v\n", len(s1), cap(s1), s1)

拷贝

截取是采用的浅拷贝，是指向的同一个地址。

如果要深拷贝。可以使用copy函数

<code>s := []int{1, 2, 3}

var s1 = make([]int, 3)

copy(s1, s)

s1[0] = 100

fmt.Printf("len=%d,cap=%d,slice=%v\n", len(s), cap(s), s)

fmt.Printf("len=%d,cap=%d,slice=%v\n", len(s1), cap(s1), s1)