Go 語言數組
Go 語言數組
引言
數組是相同數據類型的一組數據的集合，數組一旦定義長度不能修改，數組可以通過下標（或者叫索引)來訪問元素。
相對於去聲明 number0, number1, …, number99 的變量，使用數組形式 numbers[0], numbers[1] …, numbers[99] 更加方便且易於擴展。
數組元素可以通過索引（位置）來讀取（或者修改），索引從0 開始，第一個元素索引為 0，第二個索引為1，以此類推。
一、數組的定義
1. 語法
var variable_name [SIZE] variable_type
variable_name:數組的名稱 SIZE:數組長度，必須是常量 variable_type:數組保存元素的類型
2. 示例
package main
import "fmt"
func main() {
var a [3]int //定義一個int類型的數組a，長度是3
var b [2]string //定義一個字符串類型的數組b，長度是2
fmt.Printf("a: %T\n", a) //使用%T來輸出類型
fmt.Printf("b: %T\n", b)
fmt.Printf("a: %v\n", a)
fmt.Printf("b: %v\n", b)
}
//輸出結果如下，可以看到沒初始化的值，int是0，而字符串則是空的字符串
a: [3]int
b: [2]string
a: [0 0 0]
b: [ ]
從上面運行的結果中可以看出來，數組和長度和元素類型共同組成了數組的類型
二、數組的初始化
初始化，就是給數組的元素賦值，沒有初始化的數組，默認元素值都是零值，布爾類型是false，字符串是空字符串。
1. 未初始化的數組
package main
import "fmt"
func main() {
var a [2]bool
var b [2]int
var c [3]string
var d [3]float32
fmt.Printf("a: %v\n", a)
fmt.Printf("b: %v\n", b)
fmt.Printf("c: %v\n", c)
fmt.Printf("d: %v\n", d)
}
//輸出結果如下
a: [false false]
b: [0 0]
c: [ ]
d: [0 0 0]
2. 使用初始化列表
package main
import "fmt"
func main() {
var a = [3]int{1, 2, 3}
var b = [2]string{"hello world"}
var c = [2]bool{true, false}
a1 := [2]int{1, 2} //類型推斷
fmt.Printf("a: %v\n", a)
fmt.Printf("b: %v\n", b)
fmt.Printf("c: %v\n", c)
fmt.Printf("a1: %v\n", a1)
}
//輸出結果如下
a: [1 2 3]
b: [hello world ]
c: [true false]
a1: [1 2]
使用初始化列表，就是將值寫在大括號裏面
3. 省略數組長度
如果數組長度不確定，可以使用 ...代替數組的長度，編譯器會根據元素個數自行推斷數組的長度
package main
import "fmt"
func main() {
var a = [...]int{1, 2, 3, 4, 5}
var b = [...]string{"hello", "world", "hello", "go"}
var c = [...]bool{true, false}
a1 := [...]int{1, 2} //類型推斷
fmt.Printf("a: %v\n", a)
fmt.Printf("b: %v\n", b)
fmt.Printf("c: %v\n", c)
fmt.Printf("a1: %v\n", a1)
}
//輸出結果如下
a: [1 2 3 4 5]
b: [hello world hello go]
c: [true false]
a1: [1 2]
4. 指定索引值的方式來初始化
可以通過指定所有方式來初始化，未指定的所有默認值為零值
package main
import "fmt"
func main() {
var a = [...]int{0: 1, 2: 2}
var b = [...]string{1: "hello", 2: "go"}
var c = [...]bool{2: true, 5: false}
a1 := [...]int{1, 2} //類型推斷
fmt.Printf("a: %v\n", a)
fmt.Printf("b: %v\n", b)
fmt.Printf("c: %v\n", c)
fmt.Printf("a1: %v\n", a1)
}
//輸出結果如下
a: [1 0 2]
b: [ hello go]
c: [false false true false false false]
a1: [1 2]
總結
初始化數組中{}中的元素個數不能大於[]中的數字。
如果忽略[]中的數字不設置數組大小，Go 語言會根據元素的個數來設置數組的大小：
5. 訪問數組元素
數組元素可以通過索引（位置）來讀取。
格式為數組名後加中括號，中括號中為索引的值。數組的最大下標為數組長度-1，大於這個下標會發生數組越界。
示例
package main
import "fmt"
func main() {
var a [2]int
a[0] = 100
a[1] = 200
fmt.Printf("a[0]: %v\n", a[0])
fmt.Printf("a[1]: %v\n", a[1])
//對數組進行修改
a[0] = 1
a[1] = 2
fmt.Println("---------修改後--------")
fmt.Printf("a[0]: %v\n", a[0])
fmt.Printf("a[1]: %v\n", a[1])
}
//輸出結果如下
a[0]: 100
a[1]: 200
---------修改後--------
a[0]: 1
a[1]: 2
6. 根據數組長度遍曆數組
可以根據數組長度，通過for循環的方式來遍曆數組，數組的長度可以使用len函數獲得
使用len()函數獲取數組的長度
package main
import "fmt"
func main() {
var a1 = [3]int{1, 2, 3}
fmt.Printf("len(a1): %v\n", len(a1))
var a2 = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
fmt.Printf("len(a2): %v\n", len(a2))
}
//輸出結果如下
len(a1): 3
len(a2): 9
數組遍歷，根據長度和下標
package main
import "fmt"
func main() {
a := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
for i := 0; i < len(a); i++ {
fmt.Printf("a[%d]:%v\n", i, a[i])
}
}
//輸出結果如下
a[0]:1
a[1]:2
a[2]:3
a[3]:4
a[4]:5
a[5]:6
a[6]:7
a[7]:8
a[8]:9
使用for range
package main
import "fmt"
func main() {
var a = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
for i, v := range a { //i也可以使用空白標識符代替，不接受索引的值
fmt.Printf("a[%v]:%v\n", i, v)
}
}
//輸出結果如下
a[0]:1
a[1]:2
a[2]:3
a[3]:4
a[4]:5
a[5]:6
a[6]:7
a[7]:8
a[8]:9
總結
-
數組的元素可以通過下標的方式來訪問，下標的最大長度為數組長度-1，如果大於這個下標則會越界
-
遍曆數組的兩種方法：
① 通過for循環，長度可以使用len()獲取
② 通過for range循環遍曆數組，返回數組下標和對應的值；若不想要下標，可以使用空白標識符_來取代
