目錄
陣列是同一型別元素的集合，可以放多個值，但是型別一致，記憶體中連續儲存
go 語言中不允許混合不同型別的元素，而且陣列的大小，在定義階段就確定了，不能更改
// 定義乙個大小為3的string型別和int8型別的陣列，裡面可以放3個字串和3個數字
var names [3]string
var ages [3]int8
fmt.println(names, ages) // 輸出：[ ] [0 0 0]
var ages [3]int8
ages[0] = 18
ages[2] = 22
fmt.println(ages)
fmt.println(ages[1])
// 輸出
[18 0 22]
0// 方式一：
var ages [3]int = [3]int
fmt.println(ages) // 輸出：[1 2 3]
// 方式二：
var ages = [3]int
fmt.println(ages) // 輸出：[1 2 3]
// 方式三：...後面放幾個值，陣列大小就是多少
var ages = [...]int
fmt.println(ages) // 輸出：[1 2 3 4 5 6 7 8]
// 方式四：
ages := [...]int
fmt.println(ages) // 輸出：[1 2 3 4 8]
var a [2]int = [2]int
var b [2]int = [2]int
b = a // 如果不是同一種型別，不允許相互賦值
fmt.println(b)
因為陣列是值型別，go 函式傳參，都是copy傳遞，如果是值型別，函式內改了，不會影響原來的
var a = [2]int
fmt.println(a) // [1 2]
test(a) // [99 2]
fmt.println(a) // [1 2]
func test(a [2]int)
var a = [2]int
fmt.println(len(a)) // 輸出：2
// 普通迴圈
var a = [...]int
for i := 0; i < len(a); i++
// 通過 range 來迴圈（range不是乙個內建函式，是乙個關鍵字如：for，if，else）
// 如果用乙個變數接收，這個值是可迭代的索引
// 如果用兩個變數接收，這兩個變數乙個是索引，乙個是具體的值
var a = [...]int
for i, value := range a
// 不要索引只要值迴圈列印
for _, value := range a
var a [3][3]int // 定義
a[0][1] = 20 // 使用
fmt.println(a) // 輸出：[[0 20 0] [0 0 0] [0 0 0]]
// 定義並賦初始值
var a [3][3]int = [3][3]int, , }
fmt.println(a) // 輸程式設計客棧出：[[1 0 0] [2 3 4] [5 6 0]]
// 迴圈多維陣列
var a [3][3]int = [3][3]int, , }
for _, value := range a
}// 在索引為5和7的位置指定初始化值
var ages [10]int = [10]int
fmt.println(ages) // 輸出：[0 0 0 0 0 55 0 77 0 0]
切片是由陣列建立的一種方案、靈活且功能強大的包裝（wrapper）。
它本身不擁有任何資料，只對現有陣列的引用。
// 定義乙個陣列
var a = [10]int
// 基於陣列，做乙個切片
b := a[:]
fmt.println(b) // 輸出：[9 8 7 6 5 4 3 2 1 0]
fmt.printf("%t", b) // 輸出：int 中括號中不帶東西，就是切片型別
fmt.println(a) // 輸出：[9 8 7 6 5 4 3 2 1 0]
fmt.printf("%t", a) // 輸出：[10]int
var a = [10]int
b := a[:]
fmt.println(b[0]) // 輸出：9
fmt.println(b[2]) // 輸出：7
var a = [10]int
b := a[:]
b[0] = 99 // 修改切片
fmt.println(b) // 輸出：[99 8 7 6 5 pusevejxc4 3 2 1 0]
// 陣列會被修改
fmt.println(a) // 輸出：[99 8 7 6 5 4 3 2 1 0]
var a = [10]int
b := a[:]
a[1] = 99 // 修改陣列
fmt.println(a) // 輸出：[9 99 7 6 5 4 3 2 1 0]
// 切片也會被修改
fmt.println(b) // 輸出：[9 99 7 6 5 4 3 2 1 0]
var a = [10]int
b := a[3:6]
// 修改切片
b[0] = 66
fmt.println(b) // 輸出：[66 5 4]
fmt.println(a) // 輸出：[9 8 7 66 5 4 3 2 1 0]
// 修改陣列
a[4] = 55
fmt.println(b) // 輸出：[66 55 4]
fmt.println(a) // 輸出：[9 8 7 66 55 4 3 2 1 0]
var a = [10]int
b := a[3:5]
c := a[4:6]
fmt.println(a) // 輸出：[9 8 7 6 5 4 3 2 1 0]
fmt.println(b) // 輸出：[6 5]
fmt.println(c) // 輸出：[5 4]
b[1] = 555
fmt.println(a) // 輸出：[9 8 7 6 555 4 3 2 1 0]
fmt.println(b) // 輸出：[6 555]
fmt.println(c) // 輸出：[555 4]
var a = [10]int
b := a[3:7]
fmt.println(b) // 輸出：[6 5 4 3]
fmt.println(a) // 輸出：[9 8 7 6 5 4 3 2 1 0]
// 切片長度
fmt.println(len(b)) // 輸出：4
// 切片容量（我最多能存多少值，從切片的起始位置開始往後所有的，從索引為3開始）
fmt.println(cap(b)) // 輸出：7
var a = [10]int
b := a[6:8]
b = append(b,11)
b = append(b,22)
fmt.println(a) // 輸出：[9 8 7 6 5 4 3 2 11 22]
// 追加到臨界點了在追加
b = append(b,33)
b = append(b,44)
fmt.println(a) // 輸出：[9 8 7 6 5 4 3 2 11 22]
fmt.println(b) // 輸出：[3 2 11 22 33 44]
// 陣列長度不會在變了，他會在原來基礎上翻倍，把我原來那個值copy到我新的陣列上a和b已經沒有關係了
b[0] = 33
fmt.println(b) // 輸出：[33 2 11 22 33 44]
fmt.println(a) // 輸出：[9 8 7 6 5 4 3 2 11 22]
go語言之陣列與切片
都屬於集合類的型別，它們的值用來儲存某一型別的值。本質上來說，我們可以把切片看做是對陣列的一層簡單的封裝，每個切片的底層資料結構都是陣列，它可以看作是對陣列某個連續片段的引用，這裡需要注意的幾點是 我們可以通過切片字面量表示式int和內建make函式make int,5,6 初始化乙個切片，也可以通...
go語言之切片
go語言陣列和切片的異同 go 語言切片是對陣列的抽象。go 陣列的長度不可改變，在特定場景中這樣的集合就不太適用，go中提供了一種靈活，功能強悍的內建型別切片 動態陣列 與陣列相比切片的長度是不固定的，可以追加元素，在追加時可能使切片的容量增大。下面看具體例項 package main impor...
go語言之陣列
陣列是go語言程式設計中最常用的資料結構之一，陣列中的每個資料被稱為陣列元素，乙個陣列中元素的個數被稱為陣列的長度。陣列的宣告方法 var arr 32 int 宣告乙個長度為32的陣列，陣列中的元素為int var arr 12 int 宣告乙個長度為12的陣列，陣列中的元素為 int var a...