數(shù)組
數(shù)組是具有相同唯一類型的一組已編號且長度固定的數(shù)據(jù)項序列，這種類型可以是任意的原始類型例如整形腺占、字符串或者自定義類型。
數(shù)組聲明語法
Go 語言數(shù)組聲明需要指定元素類型及元素個數(shù)挨措，語法格式如下：
var array_name [leng]array_type
還是代碼描述惭缰，來的直觀：
package array_test
import "testing"
///數(shù)組聲明
func TestArryFunction(t *testing.T) {
///聲明并初始化為默認(rèn)零值
var a [3]int
a[0] = 1
t.Log(a)
///聲明的同時初始化
b := [3]int{0, 1, 2}
t.Log(b)
///多維數(shù)組初始化
c := [2][2]int{{0, 1}, {2, 3}}
t.Log(c)
///... 自動填充元素個數(shù)
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)
*/
}
///數(shù)組遍歷
func TestArrayTraverse(t *testing.T) {
arr := [...]int{33, 44, 55, 66, 77}
/*傳統(tǒng)遍歷寫法
for i:=0;i<len(arr);i++{
t.Log(arr[i])
}
*/
/// 其中，idx為數(shù)組下標(biāo)索引晚缩，e為數(shù)組元素值
//! for _, e := range arr : 其中 “_” 表示并不關(guān)心這個值結(jié)果,但是也有個返回值占位
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)
*/
}
///數(shù)組截取
func TestArrayCut(t *testing.T) {
//聲明數(shù)組
a := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
t.Log(a)
b := a[2:4] //!result: 2,3 可看作數(shù)學(xué)區(qū)間[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 可看作數(shù)學(xué)區(qū)間[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的切片類型為處理同類型數(shù)據(jù)序列提供一個方便而高效的方式,是對數(shù)組的抽象尾膊。
Go 數(shù)組的長度不可改變，在特定場景中這樣的集合就不太適用荞彼，Go中提供了一種靈活冈敛，功能強(qiáng)悍的內(nèi)置類型切片("動態(tài)數(shù)組"),與數(shù)組相比切片的長度是不固定的，可以追加元素鸣皂，在追加時可能使切片的容量增大莺债。
切片定義
你可以聲明一個未指定大小的數(shù)組來定義切片：
var identifier []type
var slice1 []type = make([]type, len) //使用make()函數(shù)來創(chuàng)建切片
slice1 := make([]type, len)
切片可以使用內(nèi)置函數(shù) make 創(chuàng)建，函數(shù)簽名為：
func make([]T, len, cap) []T
其中T代表被創(chuàng)建的切片元素的類型签夭。函數(shù) make 接受一個類型齐邦、一個長度和一個可選的容量參數(shù)。 調(diào)用 make 時第租，內(nèi)部會分配一個數(shù)組措拇，然后返回數(shù)組對應(yīng)的切片。
注意
- 切片的長度可以自動地隨著其中元素數(shù)量的增長而增長慎宾，但不會隨著元素數(shù)量的減少而減少丐吓；
- Go 語言的切片類型屬于引用類型，同屬引用類型的還有后面會講到的字典類型趟据、通道類型券犁、函數(shù)類型等；而 Go 語言的數(shù)組類型則屬于值類型汹碱，同屬值類型的有基礎(chǔ)數(shù)據(jù)類型以及結(jié)構(gòu)體類型粘衬；
- 如果傳遞的值是引用類型的，那么就是“傳引用”咳促。如果傳遞的值是值類型的稚新，那么就是“傳值”
切片初始化
s :=[] int {1,2,3 }
直接初始化切片，[]表示是切片類型跪腹，{1,2,3}初始化值依次是1,2,3.其cap=len=3
切片的生長
Go提供了一個內(nèi)置函數(shù) append 褂删， 用于在原切片的末尾添加元素；它的函數(shù)簽名：
func append(s []T, x ...T) []T
append 函數(shù)將 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個參數(shù)展開為參數(shù)列表
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
