陣列
1、Go陣列簡介
陣列是Go語言程式設計中最常用的資料結構之一。顧名思義，陣列就是指一系列同一型別資料的集合。陣列中包含的每個資料被稱為陣列元素（element），一個陣列包含的元素個數被稱為陣列的長度。
在Go語言中陣列是一個值型別（value type）。是真真實實的陣列，而不是一個指向陣列記憶體起始位置的指標，也不能和同型別的指標進行轉化，這一點嚴重不同於C語言。所有的值型別變數在賦值和作為引數傳遞時都將產生一次複製動作。如果將陣列作為函式的引數型別，則在函式呼叫時該引數將發生資料複製。因此，在函式體中無法修改傳入的陣列的內容，因為函式內操作的只是所傳入陣列的一個副本。
2、陣列定義
定義方式如下
var arr [n]type
n表示陣列長度，type表示陣列儲存型別。
在Go語言中，陣列長度在定義後就不可更改，在宣告時長度可以為一個常量或者一個常量表示式（常量表示式是指在編譯期即可計算結果的表示式）。陣列的長度是該陣列型別的一個內建常量，可以用Go語言的內建函式len()來獲取。
arrLength := len(arr)
3、常規宣告方法
var a [5]byte //長度為5的陣列，每個元素為一個位元組
var b [2*N] struct { x, y int5 } //複雜型別陣列
var c [5]*int // 指標陣列
var d [2][3]int //二維陣列
var e [2][3][4]int //等同於[2]([3]([4]int))
4、陣列初始化
（1）先宣告再初始化
a = {'1','2','3'}
d = {{1,2,3},{4,5,6}}
（2）直接宣告並初始化
a := [3]byte{'1', '2', '3'} //宣告並初始化一個長度為3的byte陣列
a := [...]byte{'1', '2', '3'} //可以省略長度而採用`...`的方式，Go會自動根據元素個數來計算長度
d := [2][3]int{[3]int{1,2,3},[3]int{4,5,6}}
d := [2][3]int{{1,2,3},{4,5,6}} //如果內部的元素和外部的一樣，那麼上面的宣告可以簡化，直接忽略內部的
型別
（3）示例
package main
import(
"fmt"
)
func main(){
var arr1 [5]int
arr2 := [5]int{1, 2, 3, 4, 5} //指定長度為5，並賦5個初始值
arr3 := [5]int{1, 2, 3} //指定長度為5，對前3個元素進行賦值，其他元素為零值
arr4 := [5]int{4: 1} //指定長度為5，對第5個元素賦值
arr5 := [...]int{1, 2, 3, 4, 5} //不指定長度，對陣列賦以5個值
arr6 := [...]int{8: 1} //不指定長度，對第9個元素（下標為8）賦值1
fmt.Println(arr1, arr2, arr3, arr4, arr5, arr6)
}
輸出結果為：
[root@localhost mygo]# go run test.go
[0 0 0 0 0] [1 2 3 4 5] [1 2 3 0 0] [0 0 0 0 1] [1 2 3 4 5] [0 0 0 0 0 0 0 0 1]
（4）建立並初始化陣列的多種方式
package main
import "fmt"
func arraySliceTest() {
//陣列初始化的各種方式
//建立陣列(宣告長度)
var array1 = [5]int{1, 2, 3}
fmt.Printf("array1--- type:%T \n", array1)
rangeIntPrint(array1[:])
//建立陣列(不宣告長度)
var array2 = [...]int{6, 7, 8}
fmt.Printf("array2--- type:%T \n", array2)
rangeIntPrint(array2[:])
//建立陣列切片
var array3 = []int{9, 10, 11, 12}
fmt.Printf("array3--- type:%T \n", array3)
rangeIntPrint(array3)
//建立陣列(宣告長度)，並僅初始化其中的部分元素
var array4 = [5]string{3: "Chris", 4: "Ron"}
fmt.Printf("array4--- type:%T \n", array4)
rangeObjPrint(array4[:])
//建立陣列(不宣告長度)，並僅初始化其中的部分元素，陣列的長度將根據初始化的元素確定
var array5 = [...]string{3: "Tom", 2: "Alice"}
fmt.Printf("array5--- type:%T \n", array5)
rangeObjPrint(array5[:])
//建立陣列切片，並僅初始化其中的部分元素，陣列切片的len將根據初始化的元素確定
var array6 = []string{4: "Smith", 2: "Alice"}
fmt.Printf("array6--- type:%T \n", array6)
rangeObjPrint(array6)
}
//輸出整型陣列切片
func rangeIntPrint(array []int) {
for i, v := range array {
fmt.Printf("index:%d value:%d\n", i, v)
}
}
//輸出字串陣列切片
func rangeObjPrint(array []string) {
for i, v := range array {
fmt.Printf("index:%d value:%s\n", i, v)
}
}
func main() {
arraySliceTest();
}
輸出如下：
array1--- type:[5]int
index:0 value:1
index:1 value:2
index:2 value:3
index:3 value:0
index:4 value:0
array2--- type:[3]int
index:0 value:6
index:1 value:7
index:2 value:8
array3--- type:[]int
index:0 value:9
index:1 value:10
index:2 value:11
index:3 value:12
array4--- type:[5]string
index:0 value:
index:1 value:
index:2 value:
index:3 value:Chris
index:4 value:Ron
array5--- type:[4]string
index:0 value:
index:1 value:
index:2 value:Alice
index:3 value:Tom
array6--- type:[]string
index:0 value:
index:1 value:
index:2 value:Alice
index:3 value:
index:4 value:Smith
5、陣列元素訪問
可以使用陣列下標來訪問陣列中的元素。陣列下標從0開始，len(arr)-1則表示最後一個元素的下標。
（1） 計算陣列長度
通過go語言內建函式len
package main
import(
"fmt"
)
func main(){
arr := [...]int {9: 1}
fmt.Println(arr)
fmt.Println(len(arr))
}
輸出結果為：
[root@localhost mygo]# go run test.go
[0 0 0 0 0 0 0 0 0 1]
10
（2）普通訪問方式
for i := 0; i < len(arr); i++ {
fmt.Println(i, arr[i])
}
例如：
package main
import(
"fmt"
)
func main(){
arr := [5]int {1, 2, 3, 4, 5}
for i := 0; i < len(arr); i++{
fmt.Printf("arr[%d]=%d\n", i, arr[i])
}
}
列印結果如下：
[root@localhost mygo]# go run test.go
arr[0]=1
arr[1]=2
arr[2]=3
arr[3]=4
arr[4]=5
（3）通過range訪問
for i, v := range arr {
fmt.Println(i, v)
}
range具有兩個返回值，第一個返回值i是元素的陣列下標，第二個返回值v是元素的值。
例如：
package main
import(
"fmt"
)
func main(){
arr := [5]int {1, 2, 3, 4, 5}
for i, v := range(arr) {
fmt.Printf("arr[%d]=%d\n", i, v)
}
}
列印結果如下：
[root@localhost mygo]# go run test.go
arr[0]=1
arr[1]=2
arr[2]=3
arr[3]=4
arr[4]=5
6、陣列值傳遞
例如：
package main
import(
"fmt"
)
func modify(arr [5]int){
arr[0] = 10
fmt.Println("In modify(), arr values:", arr)
}
func main(){
arr := [5]int{1, 2, 3, 4, 5}
modify(arr)
fmt.Println("In main(), arr values:", arr)
}
輸出結果為：
[root@localhost mygo]# go run test.go
In modify(), arr values: [10 2 3 4 5]
In main(), arr values: [1 2 3 4 5]
參考
[1]https://studygolang.com/articles/1177
[2]https://studygolang.com/articles/3816
（全文完）
更多關於大資料、分散式、儲存、區塊鏈、Linux相關文章請關注微信公眾號：asympTech漸進線實驗室
Github、知乎、部落格園、CSDN、簡書全網唯一id：JasonCeng
技術人，不白嫖，如果您覺得文章對您有幫助，幫忙點個推薦吧~