陣列

【陣列的概念】陣列是同一種資料型別元素的集合。

【陣列的宣告與初始化】　宣告之後，不可改變型別，不可改變長度。同類型&&同長度陣列之間才可以相互賦值

// 陣列初始化的幾種方法
var num = [...]int{1, 2, 3} // [...]表示讓編譯器自己推斷陣列長數
var a = [9]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
var b [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
c := [8]int{1, 2, 3, 4, 5, 6, 7, 8}
	
// 初始化不賦值
var d = [9]int{}
fmt.Println(d)	// [0 0 0 0 0 0 0 0 0]

// 陣列元素的訪問
fmt.Println(a[0])	// 1

// 陣列的長度
fmt.Println(len(b))	// 10

// 陣列的遍歷
for k, v := range c {
	fmt.Println(k, v)
}

【多維陣列】

a := [3][4]int{  
	{0, 1, 2, 3} ,   /*  第一行索引為 0 */
	{4, 5, 6, 7} ,   /*  第二行索引為 1 */
	{8, 9, 10, 11},   /* 第三行索引為 2 */
}

fmt.Println(a[1][2])	// 索引為1的第3個元素　　

陣列是值型別，賦值會複製整個陣列。因此改變副本的值，不會改變本身的值

package main

import "fmt"

func main() {
	var a = [9]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
	var b [9]int
	b = a
	a[1] = 5
	fmt.Println(a)	// [1 5 3 4 5 6 7 8 9]
	fmt.Println(b)	// [1 2 3 4 5 6 7 8 9]
}

切片

【切片的概念】（Slice）是一個擁有相同型別元素的可變長度的序列

【切片的宣告】

var a []string              //宣告一個字串切片
var b = []int{}             //宣告一個整型切片並初始化
var c = []bool{false, true} //宣告一個布林切片並初始化
var d = []bool{false, true} //宣告一個布林切片並初始化

【切片的初始化】

//建立一個容量cap為8，長度len為5的零值切片，值為[0 0 0 0 0]
var s1 []int = make([]int, 5, 8)
 
//建立一個容量和長度都為8的零值切片，值為[0 0 0 0 0 0 0 0]
var s2 []int = make([]int, 8)
 
//也可以這樣建立零值切片，引數從左到右依次是型別，Len，cap
var s1 = make([]int, 5, 8)
s2 := make([]int, 8)
 
//這樣建立的切片是滿容的
var s []int = []int{1,2,3,4,5}  // cap和len都為5
 
//建立空切片，他們值均為[] cap為0 len也為0
var s1 []int                   
var s2 []int = []int{}
var s3 []int = make([]int, 0)

切片之間直接賦值之後，修改其中一個切片的元素的值，另一個切片相對應元素的值會隨之改變

切片之間用copy()賦值後，修改其中一個切片元素的值，另一個切片相對應元素的值不會發生改變

【切片的基礎操作】

package main
 
func main() {
    var s1 []int
    s2 := []int{14,15}
    for i := 0; i < 10; i++ {
        s1 = append(s1, i)
    }
 
    // 新增一個元素元素
    s1 = append(s1, 10)
 
    // 新增多個元素元素
    s1 = append(s1, 11, 12, 13)
 
    // 新增另一個切片的元素（後面加…）
    s1 = append(s1, s2...)
 
    // 刪除索引最小的元素
    _ = s1[1:]
 
    // 刪除索引最大的元素
    _ = s1[:1]
 
    // 刪除 (非最大最小 && 索引為index)的元素
    index := 4
    _ = append(s1[:index], s1[index+1:]...)
}

切片append之後賦值給一個新的變數，不能賦值給_，切片append追加之後如果超出了原切片的容量，會變成一個新的切片，不再和原切片共享同一個底層陣列，原切片改變元素新切片對應元素不變。

切片的擴容要用append，不能用賦值的方法擴容，否則會觸發panic中斷程式

func main() {
    var s1 []int
    s1[0] = 1   // 此處會觸發panic
}

當比較短的切片擴容時，系統會多分配 100% 的空間
但切片長度超過1024時，擴容策略調整為多分配 25% 的空間

【切片之後再切片】

package main

import (
    "fmt"
)

func main() {
    a := [5]int{1, 2, 3, 4, 5}
    s := a[1:3] // s := a[low:high]
    //s:[2 3]
    fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s))
    s2 := s[3:4] // 索引的上限是cap(s)而不是len(s)
    fmt.Printf("s2:%v len(s2):%v cap(s2):%v\n", s2, len(s2), cap(s2))
}

結果：

s:[2 3] len(s):2 cap(s):4
s2:[5] len(s2):1 cap(s2):1

【len()和cap】切片擁有自己的長度和容量，我們可以通過使用內建的len()函式求長度，使用內建的cap()函式求切片的容量。

【空切片】