陣列：

• golang陣列包含的每個資料稱為陣列元素（element），陣列包含的元素個數被稱為陣列長度（length）。
• golang陣列的長度在定義後不可更改，並且在宣告時可以是一個常量或常量表達式（在編譯期即可計算結果的表示式）。golang陣列長度是一個內建常量，可以用len()函式來獲取。
•  golang陣列是一個值型別，在賦值和作為引數傳遞時都將產生一次複製動作，因此在函式體中無法修改傳入的陣列的內容。

陣列宣告和初始化

▶ 陣列宣告

▪ 語法如下

var array [n]Type

// 陣列宣告和初始化
var array [n]Type = [n]Type{v1, v2, ..., vn}
var array = [n]Type{v1, v2, ..., vn}
array := [n]Type{v1, v2, ..., vn}

▪ 示例如下

[32]byte                    // 長度為32的陣列，每個元素為一個位元組
[2*N] struct { x, y int32 } // 複雜型別陣列
[1000]*float64              // 指標陣列
[3][5]int                   // 二維陣列
[2][2][2]float64            // 等同於[2]([2]([2]float64))

• 陣列常用操作

▶ 遍歷元素

⊙ 按下標遍歷

       √ 使用len()獲取元素個數，然後按下標進行元素遍歷操作。

▪ 語法如下

for i := 0; i < len(array); i++ {
    ...
}

▪ 示例如下

package main

import "fmt"

func main() {

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

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

		fmt.Println("array[", i, "] =", array[i])

	}

}

⊙ rang遍歷

       √ 可以使用range關鍵字來快速遍歷所有元素。

▪ 語法如下

for i, v := range array {
    ...
}

▪ 示例如下

package main

import "fmt"

func main() {

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

	for i, v := range array {

		fmt.Println("array[", i, "] =", v)

	}

}

陣列切片

       √ golang陣列切片解決的問題：golang陣列長度在定義之後無法再次修改，並且陣列是值型別，每次傳遞都將產生一份副本。

       √ golang陣列切片擁有獨立的資料結構，可抽象為3個變數：一個指向原陣列的指標，陣列切片中元素個數，陣列切片分配的儲存空間。

• 建立陣列切片

▶ 基於陣列

▪ 語法如下

var arraySlice []Type = array[first:last]

       √ 陣列切片的元素範圍為[first, last)。

       √ first和last的值可以省略，預設情況下，first=0，last=len(array)

       √ first和last的值必須滿足條件：非負，0 ≤ first ≤ last ≤ len(array)，否則編譯器將給出錯誤：
       

       

       

▪ 示例如下

package main

import "fmt"

func main() {

	var array [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

	var arraySlice1 []int = array[:]   // 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

	var arraySlice2 []int = array[:5]  // 1, 2, 3, 4, 5

	var arraySlice3 []int = array[5:]  // 6, 7, 8, 9, 10

	var arraySlice4 []int = array[3:8] // 4, 5, 6, 7, 8

	fmt.Println("\nElements of arraySlice1: ")

	for _, v := range arraySlice1 {

		fmt.Print(v, " ")

	}

	fmt.Println("\nElements of arraySlice2: ")

	for _, v := range arraySlice2 {

		fmt.Print(v, " ")

	}

	fmt.Println("\nElements of arraySlice3: ")

	for _, v := range arraySlice3 {

		fmt.Print(v, " ")

	}

	fmt.Println("\nElements of arraySlice4: ")

	for _, v := range arraySlice4 {

		fmt.Print(v, " ")

	}

	fmt.Println()

}

▶ 直接建立

       √ golang提供的內建函式make()可以用於靈活地建立陣列切片。

▪ 語法如下

// 建立一個初始元素個數為m的陣列切片
arraySlice := make([]Type, m)

// 建立一個初始元素個數為m的陣列切片，並預留n個元素的儲存空間
arraySlice := make([]Type, m, n)

// 直接建立並初始化包含m個元素的陣列切片
arraySlice := []Type{v1, v2, ..., vn}

▪ 示例如下

  package main

import "fmt"

func main() {

	arraySlice1 := make([]int, 5)       // 0 0 0 0 0

	arraySlice2 := make([]int, 5, 10)   // 0 0 0 0 0

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

	fmt.Println("\nElements of arraySlice1: ")

	for _, v := range arraySlice1 {

		fmt.Print(v, " ")

	}

	fmt.Println("\nElements of arraySlice2: ")

	for _, v := range arraySlice2 {

		fmt.Print(v, " ")

	}

	fmt.Println("\nElements of arraySlice3: ")

	for _, v := range arraySlice3 {

		fmt.Print(v, " ")

	}

}

▶ 基於陣列切片

       √ 陣列切片（newSlice）也可以基於另一個數組切片（oldSlice）建立。

       √ newSlice元素範圍可以超過oldSlice所包含的元素個數，只要選擇範圍不超過oldSlice的儲存能力，即cap(oldSlice)的值，那麼這個建立是合法的，newSlice中超出oldSlice元素的部分都會填上0。

       √ newSlice的儲存能力等同於oldSlice的儲存能力，即cap(newSlice) = cap(oldSlice)。

▪ 語法如下

newSlice := oldSlice[first:last] // 0 ≤ first ≤ last ≤ cap(oldSlice)

▪ 示例如下

package main

import "fmt"

func main() {

	oldSlice := make([]int, 5, 10)

	newSlice := oldSlice[:8]

	fmt.Println("Length   of oldSlice: ", len(oldSlice)) // 5

	fmt.Println("Capacity of oldSlice: ", cap(oldSlice)) // 10

	fmt.Println("Length   of newSlice: ", len(newSlice)) // 8

	fmt.Println("Capacity of newSlice: ", cap(newSlice)) // 10

}

• 陣列切片的元素個數和儲存能力

       √ 與陣列相比，陣列切片多了一個儲存能力（capacity）的概念，即當前容納的元素個數和分配的空間可以是兩個不同的值。

       √ 儲存能力，可以理解為最大容納元素個數，最大容納元素個數減去當前容納元素個數剩下的空間是隱藏的，不能直接使用。如果要往隱藏空間中新增元素，可以使用append()函式。

       √ 取得當前容納元素個數可以使用len()函式，取得最大容納元素個數可以使用cap()函式。

package main

import "fmt"

func main() {

	arraySlice := make([]int, 5, 10)

	fmt.Println("len(arraySlice):", len(arraySlice)) // len(arraySlice): 5

	fmt.Println("cap(arraySlice):", cap(arraySlice)) // cap(arraySlice): 10

}

• 陣列切片常用操作

▶ 遍歷元素

⊙ 按下標遍歷

       √ 與遍歷陣列一樣，使用len()獲取元素個數，然後按下標進行元素遍歷操作。

▪ 語法如下

for i := 0; i < len(arraySlice); i++ {
    ...
}

▪ 示例如下

package main

import "fmt"

func main() {

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

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

		fmt.Println("arraySlice[", i, "] =", arraySlice[i])

	}

}

⊙ rang遍歷

       √ 與遍歷陣列一樣，可以使用range關鍵字來快速遍歷所有元素。

▪ 語法如下

for i, v := range arraySlice {
    ...
}

▪ 示例如下

package main

import "fmt"

func main() {

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

	for i, v := range arraySlice {

		fmt.Println("arraySlice[", i, "] =", v)

	}

}

▶ 增加元素

       √ 為陣列切片增加元素的方法是使用append()函式。

⊙ 追加元素

       √ 追加元素時，會自動處理儲存空間不足的問題，如果追加的內容超過當前最大容納元素空間，那麼陣列切片會自動分配一塊足夠大的記憶體。自動分配記憶體策略為：當前儲存能力 * 2，即cap(arraySlice) * 2。

▪ 語法如下

arraySlice = append(arraySlice, v1, v2, ..., vn)

▪ 示例如下

package main

import "fmt"

func main() {

	arraySlice := make([]int, 0, 10)

	arraySlice = append(arraySlice, 1, 2, 3, 4, 5)

	fmt.Println("len(arraySlice) =", len(arraySlice)) // 5

	fmt.Println("cap(arraySlice) =", cap(arraySlice)) // 10

	for _, v := range arraySlice {

		fmt.Print(v, " ")

	}

	fmt.Println()

	arraySlice = append(arraySlice, 6, 7, 8, 9, 10, 11, 12, 13)

	fmt.Println("len(arraySlice) =", len(arraySlice)) // 13

	fmt.Println("cap(arraySlice) =", cap(arraySlice)) // 20

	for _, v := range arraySlice {

		fmt.Print(v, " ")

	}

}

⊙ 追加陣列切片

      √ 為陣列切片arraySlice1追加陣列切片arraySlice2時，注意在arraySlice2後面追加三個點，這三個點的意思是把arraySlice2所有元素打散後傳遞給append()函式，這是由於append()函式從第二個引數起的所有引數都必須是待附加的單個元素。

▪ 語法如下

arraySlice = append(arraySlice, appendSlice...)

▪ 示例如下

package main

import "fmt"

func main() {

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

	appendSlice := []int{4, 5}

	arraySlice = append(arraySlice, appendSlice...)

	fmt.Println("len(arraySlice) =", len(arraySlice)) // 5

	fmt.Println("cap(arraySlice) =", cap(arraySlice)) // 6

	for _, v := range arraySlice {

		fmt.Print(v, " ")

	}

}

▶ 刪除元素

      √ 陣列切片可以動態新增元素，但沒有刪除元素的函式。代替方法是：可以使用陣列切片重新組合的方式來刪除一個或多個項。不過從陣列切片這種資料結構來看，本身並不適合做刪除操作，所以儘量減少使用。

▪ 示例如下

package main

import "fmt"

func main() {

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

	i := 2

	s = append(s[:i], s[i+1:]...)

	fmt.Println(s) // [1 2 4 5 6]

}

▶ 切片之間元素複製

       √ golang使用內建函式copy()將陣列切片arraySlice2的內容複製到陣列切片arraySlice1中。

       √ 如果兩個陣列切片元素個數不同，那麼就會按其中元素個數較少的陣列切片元素個數進行復制操作。

▪ 示例如下

package main

import "fmt"

func main() {

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

	arraySlice2 := []int{5, 4, 3}

	copy(arraySlice2, arraySlice1) // 只會複製arraySlice1的前3個元素到arraySlice2中

	fmt.Println(arraySlice2)       // [1 2 3]

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

	arraySlice4 := []int{5, 4, 3}

	copy(arraySlice3, arraySlice4) // 只會複製arraySlice4的3個元素到arraySlice3的前3個位置

	fmt.Println(arraySlice3)       // [5 4 3 4 5]

}