(4). GO嵌入式开发之 --- 数组和切片
数组
数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整形、字符串或者自定义类型。
数组声明语法
Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：
var array_name [leng]array_type
还是代码描述，来的直观：
package array_test
import "testing"
///数组声明
func TestArryFunction(t *testing.T) {
///声明并初始化为默认零值
var a [3]int
a[0] = 1
t.Log(a)
///声明的同时初始化
b := [3]int{0, 1, 2}
t.Log(b)
///多维数组初始化
c := [2][2]int{{0, 1}, {2, 3}}
t.Log(c)
///... 自动填充元素个数
d := [...]int{1, 2, 3, 4, 5}
t.Log(d)
/*
=== RUN TestArryFunction
TestArryFunction: arry_test.go:9: [1 0 0]
TestArryFunction: arry_test.go:13: [0 1 2]
TestArryFunction: arry_test.go:17: [[0 1] [2 3]]
TestArryFunction: arry_test.go:21: [1 2 3 4 5]
--- PASS: TestArryFunction (0.00s)
*/
}
///数组遍历
func TestArrayTraverse(t *testing.T) {
arr := [...]int{33, 44, 55, 66, 77}
/*传统遍历写法
for i:=0;i<len(arr);i++{
t.Log(arr[i])
}
*/
/// 其中，idx为数组下标索引，e为数组元素值
//! for _, e := range arr : 其中 “_” 表示并不关心这个值结果,但是也有个返回值占位
for idx, e := range arr {
t.Log(idx, e)
}
/*
=== RUN TestArrayTraverse
TestArrayTraverse: arry_test.go:43: 0 33
TestArrayTraverse: arry_test.go:43: 1 44
TestArrayTraverse: arry_test.go:43: 2 55
TestArrayTraverse: arry_test.go:43: 3 66
TestArrayTraverse: arry_test.go:43: 4 77
--- PASS: TestArrayTraverse (0.00s)
*/
}
///数组截取
func TestArrayCut(t *testing.T) {
//声明数组
a := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
t.Log(a)
b := a[2:4] //!result: 2,3 可看作数学区间[2,4)
t.Log(b)
c := a[3:len(a)] //!result: 3,4,5,6,7
t.Log(c)
d := a[5:] //!result: 5,6,7
t.Log(d)
e := a[:3] //!result:0,1,2 可看作数学区间[0,3)
t.Log(e)
/*
=== RUN TestArrayCut
TestArrayCut: arry_test.go:63: [0 1 2 3 4 5 6 7]
TestArrayCut: arry_test.go:66: [2 3]
TestArrayCut: arry_test.go:69: [3 4 5 6 7]
TestArrayCut: arry_test.go:72: [5 6 7]
TestArrayCut: arry_test.go:75: [0 1 2]
--- PASS: TestArrayCut (0.00s)
*/
}
切片
Go的切片类型为处理同类型数据序列提供一个方便而高效的方式,是对数组的抽象。
Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。
切片内部数据结构
切片定义
你可以声明一个未指定大小的数组来定义切片：
var identifier []type
var slice1 []type = make([]type, len) //使用make()函数来创建切片
slice1 := make([]type, len)
切片可以使用内置函数 make 创建，函数签名为：
func make([]T, len, cap) []T
其中T代表被创建的切片元素的类型。函数 make 接受一个类型、一个长度和一个可选的容量参数。 调用 make 时，内部会分配一个数组，然后返回数组对应的切片。
注意
- 切片的长度可以自动地随着其中元素数量的增长而增长，但不会随着元素数量的减少而减少；
- Go 语言的切片类型属于引用类型，同属引用类型的还有后面会讲到的字典类型、通道类型、函数类型等；而 Go 语言的数组类型则属于值类型，同属值类型的有基础数据类型以及结构体类型；
- 如果传递的值是引用类型的，那么就是“传引用”。如果传递的值是值类型的，那么就是“传值”
切片初始化
s :=[] int {1,2,3 }
直接初始化切片，[]表示是切片类型，{1,2,3}初始化值依次是1,2,3.其cap=len=3
切片的生长
Go提供了一个内置函数 append ， 用于在原切片的末尾添加元素；它的函数签名：
func append(s []T, x ...T) []T
append 函数将 x 追加到切片 s 的末尾，并且在必要的时候增加容量。
package slice_test
import "testing"
func TestSliceAppend(t *testing.T) {
var s []int
for i := 0; i < 10; i++ {
s = append(s, i)
t.Log(s, len(s), cap(s))
}
//同时添加多个元素
s = append(s, 10, 11, 12)
t.Log(s, len(s), cap(s))
/*
=== RUN TestSliceAppend
TestSliceAppend: slice_test.go:9: [0] 1 1
TestSliceAppend: slice_test.go:9: [0 1] 2 2
TestSliceAppend: slice_test.go:9: [0 1 2] 3 4
TestSliceAppend: slice_test.go:9: [0 1 2 3] 4 4
TestSliceAppend: slice_test.go:9: [0 1 2 3 4] 5 8
TestSliceAppend: slice_test.go:9: [0 1 2 3 4 5] 6 8
TestSliceAppend: slice_test.go:9: [0 1 2 3 4 5 6] 7 8
TestSliceAppend: slice_test.go:9: [0 1 2 3 4 5 6 7] 8 8
TestSliceAppend: slice_test.go:9: [0 1 2 3 4 5 6 7 8] 9 16
TestSliceAppend: slice_test.go:9: [0 1 2 3 4 5 6 7 8 9] 10 16
TestSliceAppend: slice_test.go:14: [0 1 2 3 4 5 6 7 8 9 10 11 12] 13 16
--- PASS: TestSliceAppend (0.00s)
*/
}
1. AppendVector
a = append(a, b...)
如果是要将一个切片追加到另一个切片尾部，需要使用 ... 语法将第2个参数展开为参数列表
package slice_test
import "testing"
func TestAppendVector(t *testing.T) {
Q1 := []string{"Jan", "Feb", "Mar"}
Q2 := []string{"Apr", "May", "Jun"}
Q := append(Q1, Q2...)
t.Log(Q)
/*
=== RUN TestAppendVector
TestAppendVector: slice_test.go:42: [Jan Feb Mar Apr May Jun]
--- PASS: TestAppendVector (0.00s)
*/
}
2. Copy Slice（理清深拷贝和浅拷贝的概念）
浅拷贝：
Q := []string{"Jan", "Feb", "Mar", "Apr", "May", "Jun"}
L := Q
//测试浅拷贝
func TestSliceShallowCopy(t *testing.T) {
Q := []string{"Jan", "Feb", "Mar", "Apr", "May", "Jun"}
L := Q
L[1] = "Unknow"
t.Log(Q, L)
/*
=== RUN TestSliceShallowCopy
TestSliceShallowCopy: slice_test.go:56: [Jan Unknow Mar Apr May Jun] [Jan Unknow Mar Apr May Jun]
--- PASS: TestSliceShallowCopy (0.00s)
*/
}
深拷贝：
//深拷贝
func TestSliceDeepCopy(t *testing.T) {
Q := []string{"Jan", "Feb", "Mar", "Apr", "May", "Jun"}
S := make([]string, len(Q))
copy(S, Q)
t.Log(S)
//or
S1 := append([]string(nil), Q...)
t.Log(S1)
/*
=== RUN TestSliceCopy
TestSliceCopy: slice_test.go:55: [Jan Feb Mar Apr May Jun]
TestSliceCopy: slice_test.go:59: [Jan Feb Mar Apr May Jun]
--- PASS: TestSliceCopy (0.00s)
*/
}
3. Slice cut
a = append(a[:i], a[j:]...) //a = a-a[1,4)
func TestSliceCut(t *testing.T) {
Q := []string{"Jan", "Feb", "Mar", "Apr", "May", "Jun"}
t.Log(Q)
//去掉"Feb", "Mar", "Apr" [)
Q = append(Q[:1], Q[4:]...)
t.Log(Q)
/*
=== RUN TestSliceCut
TestSliceCut: slice_test.go:85: [Jan Feb Mar Apr May Jun]
TestSliceCut: slice_test.go:89: [Jan May Jun]
--- PASS: TestSliceCut (0.00s)
*/
}
4. Slice Delete
a = append(a[:i], a[i+1:]...) //delete a[i]
func TestSliceDelete(t *testing.T) {
Q := []string{"Jan", "Feb", "Mar", "Apr", "May", "Jun"}
//去掉"Mar"
Q = append(Q[:2], Q[3:]...)
t.Log(Q)
/*
=== RUN TestSliceDelete
TestSliceDelete: slice_test.go:103: [Jan Feb Apr May Jun]
--- PASS: TestSliceDelete (0.00s)
*/
}
5. Slice Push/Pop
a = append(a, x) //push
e, a = a[len(a)-1], a[:len(a)-1] //pop
