Go基礎語法0x01-數組
數組
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]//studygolang.com/articles/1177
[2]//studygolang.com/articles/3816
（全文完）
更多關於大數據、分散式、存儲、區塊鏈、Linux相關文章請關注微信公眾號：asympTech漸進線實驗室
Github、知乎、部落格園、CSDN、簡書全網唯一id：JasonCeng
技術人，不白嫖，如果您覺得文章對您有幫助，幫忙點個推薦吧~
