Arrays：数组

在go语言中数组array是一组特定长度的有序的元素集合，元素类型可以是任意的原始类型例如整形、字符串或者自定义类型，通过索引（位置）来读取（或者修改），索引从0开始，第一个元素索引为 0，第二个索引为 1，以此类推

array.go

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)  
}

[root@mail work]# go run array.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]]

Maps：键值对
Maps是Go语言中的关联数据类型（在其它语言中有时会被称之为哈希表[hashes]或字典[dicts]）

maps.go

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)  
}

[root@mail work]# 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]

Slices：切片
Slices是Go语言中的关键数据类型，它有比数组（arrays）更强的访问接口。

slices.go

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)  
}

[root@mail work]# 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]]