Arrays：數組
在go語言中數組array是一組特定長度的有序的元素集合。
package main
import "fmt"
func main() {
//這里我們創建了一個長度為5的數組. 這一組數組的初值是zero-valued。整型就是0
var a [5]int
fmt.Println("emp:", a)
//可以通過array[index] = value語法賦值
a[4] = 100
fmt.Println("set:", a)
fmt.Println("get:", a[4])
//內置的len函數會返回數組長度
fmt.Println("len:", len(a))
//通過這個語法聲明數組的默認初值
b := [5]int{1, 2, 3, 4, 5}
fmt.Println("dcl:", b)
//數組類型是一維的，但是你可以通過組合創建多維數組結構
var twoD [2][3]int
for i := 0; i < 2; i++ {
for j := 0; j < 3; j++ {
twoD[i][j] = i + j
}
}
fmt.Println("2d: ", twoD)
}
$ go run arrays.go
emp: [0 0 0 0 0]
set: [0 0 0 0 100]
get: 100
len: 5
dcl: [1 2 3 4 5]
2d: [[0 1 2] [1 2 3]]
Slices：切片
Slices是Go語言中的關鍵數據類型，它有比數組（arrays）更強的訪問接口。
package main
import "fmt"
func main() {
//跟數組（arrays）不同，slices的類型跟所包含的元素類型一致（不是元素的數量）。使用內置的make命令，構建一個非零的長度的空slice對象。這里我們創建了一個包含了3個字符的字符串 。(初始化為零值zero-valued)
s := make([]string, 3)
fmt.Println("emp:", s)
//我們可以像數組一樣進行設置和讀取操作。
s[0] = "a"
s[1] = "b"
s[2] = "c"
fmt.Println("set:", s)
fmt.Println("get:", s[2])
//獲取到的長度就是當時設置的長度。
fmt.Println("len:", len(s))
//相對于這些基本的操作，slices支持一些更加復雜的功能。有一個就是內置的append，可以在現有的slice對象上添加一個或多個值。注意要對返回的append對象重新賦值，以獲取最新的添加了元素的slice對象。
s = append(s, "d")
s = append(s, "e", "f")
fmt.Println("apd:", s)
//Slices也可以被復制。這里我們將s復制到了c，長度一致。
c := make([]string, len(s))
copy(c, s)
fmt.Println("cpy:", c)
//Slices支持"slice"操作，語法為slice[low:high]（即截取slice中的某段值）。下面這段代碼就會獲取這些字符： s[2], s[3], 和 s[4]。
l := s[2:5]
fmt.Println("sl1:", l)
//從開始截取到每5個字符（除了值）
l = s[:5]
fmt.Println("sl2:", l)
//從第二個（包括）字符開始截取到最后一個
l = s[2:]
fmt.Println("sl3:", l)
//我們可以將聲明和賦值放在一行。
t := []string{"g", "h", "i"}
fmt.Println("dcl:", t)
//Slices可以被組合成多維數組。里面一維的slices對象可以不等長，這一點跟多維數組不太一樣。
twoD := make([][]int, 3)
for i := 0; i < 3; i++ {
innerLen := i + 1
twoD[i] = make([]int, innerLen)
for j := 0; j < innerLen; j++ {
twoD[i][j] = i + j
}
}
fmt.Println("2d: ", twoD)
}
注意slices跟arrays是兩種不同的數據類型，但是他們的fmt.Println打印方式很相似。
$ go run slices.go
emp: [ ]
set: [a b c]
get: c
len: 3
apd: [a b c d e f]
cpy: [a b c d e f]
sl1: [c d e]
sl2: [a b c d e]
sl3: [c d e f]
dcl: [g h i]
2d: [[0] [1 2] [2 3 4]]
看看這篇文章，輸看看Go團隊是如何在go中設計和實現slices的。
Maps：鍵值對
Maps是Go語言中的關聯數據類型（在其它語言中有時會被稱之為哈希表[hashes]或字典[dicts]）
package main
import "fmt"
func main() {
//使用內置的make來合建一個空的map，make(map[鍵類型]值類型)
m := make(map[string]int)
//設置鍵/值對使用經典的 name[key] = val 語法。
m["k1"] = 7
m["k2"] = 13
//打印map會輸出里面所有的鍵值對
fmt.Println("map:", m)
//獲取某個鍵的值
v1 := m["k1"]
fmt.Println("v1: ", v1)
//len函數會獲取map中鍵/值對的個數
fmt.Println("len:", len(m))
//使用內置的delete函數從map中移除鍵/值對
delete(m, "k2")
fmt.Println("map:", m)
//可選的第二返回值可以指出map中是否包含此鍵的值。避免空值0或""引起的歧義。
_, prs := m["k2"]
fmt.Println("prs:", prs)
//你也可以在一行中完成聲明與賦值
n := map[string]int{"foo": 1, "bar": 2}
fmt.Println("map:", n)
}
注意當使用fmt.Println打印時map的輸出格式為map[k:v k:v]。
$ go run maps.go
map: map[k1:7 k2:13]
v1: 7
len: 2
map: map[k1:7]
prs: false
map: map[foo:1 bar:2]
Range：范圍
range可以在多種數據結構上進行枚舉。讓我們看看如何在之前的數據結構上使用。
package main
import "fmt"
func main() {
//這是我們使用range去求一個slice的和。使用數組跟這個很類似
nums := []int{2, 3, 4}
sum := 0
for _, num := range nums {
sum += num
}
fmt.Println("sum:", sum)
//在數組上使用range將傳入index和值兩個變量。上面那個例子我們不需要使用該元素的序號，所以我們使用空白符"_"省略了。有時侯我們確實需要知道它的索引。
for i, num := range nums {
if num == 3 {
fmt.Println("index:", i)
}
}
//range也可以用在map的鍵值對上。
kvs := map[string]string{"a": "apple", "b": "banana"}
for k, v := range kvs {
fmt.Printf("%s -> %s/n", k, v)
}
//range也可以用來枚舉Unicode字符串。第一個參數是字符的索引，第二個是字符（Unicode的值）本身。
for i, c := range "go" {
fmt.Println(i, c)
}
}
$ go run range.go
sum: 9
index: 1
a -> apple
b -> banana
0 103
1 111
