指針

Go 具有指針氨淌。 指針保存了變量的內(nèi)存地址泊愧。
類型 *T 是指向類型 T 的值的指針伊磺。其零值是 nil盛正。

var p *int
& 符號(hào)會(huì)生成一個(gè)指向其作用對象的指針。
i := 42
p = &i

'*' 符號(hào)表示指針指向的底層的值屑埋。

fmt.Println(*p) // 通過指針 p 讀取 i
*p = 21         // 通過指針 p 設(shè)置 i

這也就是通常所說的“間接引用”或“非直接引用”豪筝。
與 C 不同，Go 沒有指針運(yùn)算摘能。

func main() {
    i, j := 42, 2701

    p := &i         // 指向i
    fmt.Println(*p) // 通過指針獲取i的值
    *p = 21         // 通過指針給賦值
    fmt.Println(i)  

    p = &j         // 指向j
    *p = *p / 37   // 通過指針進(jìn)行運(yùn)算
    fmt.Println(j) 
}
/*
42
21
73
*/

結(jié)構(gòu)體

一個(gè)結(jié)構(gòu)體（struct）就是一個(gè)字段的集合续崖。
（而 type 的含義跟其字面意思相符。）

type Vertex struct {
    X int
    Y int
}
func main() {
    fmt.Println(Vertex{1, 2})
}
// {1, 2}

結(jié)構(gòu)體字段使用點(diǎn)號(hào)來訪問

func main() {
    v := Vertex{1, 2}
    v.X = 4
    fmt.Println(v.X)
}

結(jié)構(gòu)體指針
結(jié)構(gòu)體字段可以通過結(jié)構(gòu)體指針來訪問团搞。
通過指針間接的訪問是透明的严望。

func main() {
    v := Vertex{1, 2}
    p := &v
    p.X = 1e9
    fmt.Println(v)
    fmt.Println(&p)
    fmt.Println(*p)
    fmt.Println(p)
}
/*
{1000000000 2}
0xc42000c028
{1000000000 2}
&{1000000000 2}
*/

結(jié)構(gòu)體文法
結(jié)構(gòu)體文法表示通過結(jié)構(gòu)體字段的值作為列表來新分配一個(gè)結(jié)構(gòu)體。
使用 Name: 語法可以僅列出部分字段逻恐。（字段名的順序無關(guān)像吻。）
特殊的前綴 & 返回一個(gè)指向結(jié)構(gòu)體的指針峻黍。

var (
    v1 = Vertex{1, 2}  // 類型為 Vertex
    v2 = Vertex{X: 1}  // Y:0 被省略
    v3 = Vertex{}      // X:0 和 Y:0
    p  = &Vertex{1, 2} // 類型為 *Vertex
)

func main() {
    fmt.Println(v1, p, v2, v3)
}
// {1 2} &{1 2} {1 0} {0 0}

數(shù)組

類型 [n]T 是一個(gè)有 n 個(gè)類型為 T 的值的數(shù)組。
表達(dá)式

var Name [Length]Type

定義變量 a 是一個(gè)有十個(gè)整數(shù)的數(shù)組拨匆。
數(shù)組的長度是其類型的一部分姆涩，因此數(shù)組不能改變大小。 這看起來是一個(gè)制約惭每，但是請不要擔(dān)心骨饿； Go 提供了更加便利的方式來使用數(shù)組。

func main() {
    var a [2]string
    a[0] = "Hello"
    a[1] = "World"
    fmt.Println(a[0], a[1])
    fmt.Println(a)
}
/*
Hello World
[Hello World]
*/

slice
一個(gè) slice 會(huì)指向一個(gè)序列的值台腥，并且包含了長度信息宏赘。
[]T 是一個(gè)元素類型為 T 的 slice。

func main() {
    p := []int{2, 3, 5, 7, 11, 13}
    fmt.Println("p ==", p)

    for i := 0; i < len(p); i++ {
        fmt.Printf("p[%d] == %d\n", i, p[i])
    }
}
/*
p == [2 3 5 7 11 13]
p[0] == 2
p[1] == 3
p[2] == 5
p[3] == 7
p[4] == 11
p[5] == 13
*/

對 slice 切片
slice 可以重新切片黎侈，創(chuàng)建一個(gè)新的 slice 值指向相同的數(shù)組置鼻。
表達(dá)式
's[lo:hi]'
表示從 lo 到 hi-1 的 slice 元素，含兩端蜓竹。因此
's[lo:lo]'
是空的箕母，而
's[lo:lo+1]'
有一個(gè)元素。

func main() {
    p := []int{2, 3, 5, 7, 11, 13}
    fmt.Println("p ==", p)
    fmt.Println("p[1:4] ==", p[1:4])

    // 省略下標(biāo)代表從 0 開始
    fmt.Println("p[:3] ==", p[:3])

    // 省略上標(biāo)代表到 len(s) 結(jié)束
    fmt.Println("p[4:] ==", p[4:])
}
/*
p == [2 3 5 7 11 13]
p[1:4] == [3 5 7]
p[:3] == [2 3 5]
p[4:] == [11 13]
*/

構(gòu)造 slice
slice 由函數(shù) make 創(chuàng)建俱济。這會(huì)分配一個(gè)零長度的數(shù)組并且返回一個(gè) slice 指向這個(gè)數(shù)組：

a := make([]int, 5)  // len(a)=5
為了指定容量嘶是，可傳遞第三個(gè)參數(shù)到 `make`：
b := make([]int, 0, 5) // len(b)=0, cap(b)=5
b = b[:cap(b)] // len(b)=5, cap(b)=5
b = b[1:]      // len(b)=4, cap(b)=4

make(T, n) slice slice of type T with length n and capacity n
make(T, n, m) slice slice of type T with length n and capacity m

func main() {
    a := make([]int, 5)
    printSlice("a", a)
    b := make([]int, 0, 5)
    printSlice("b", b)
    c := b[:2]
    printSlice("c", c)
    d := c[2:5]
    printSlice("d", d)
}

func printSlice(s string, x []int) {
    fmt.Printf("%s len=%d cap=%d %v\n",
        s, len(x), cap(x), x)
}
/*
a len=5 cap=5 [0 0 0 0 0]
b len=0 cap=5 []
c len=2 cap=5 [0 0]
d len=3 cap=3 [0 0 0]
*/

nil slice
slice 的零值是 nil。 'var z []int'

向 slice 添加元素

向 slice 添加元素是一種常見的操作蛛碌，因此 Go 提供了一個(gè)內(nèi)建函數(shù) append聂喇。 內(nèi)建函數(shù)的文檔對 append 有詳細(xì)介紹。

func append(s []T, vs ...T) []T

append 的第一個(gè)參數(shù) s 是一個(gè)類型為 T 的數(shù)組蔚携，其余類型為 T 的值將會(huì)添加到 slice希太。
append 的結(jié)果是一個(gè)包含原 slice 所有元素加上新添加的元素的 slice。
如果 s 的底層數(shù)組太小酝蜒，而不能容納所有值時(shí)誊辉，會(huì)分配一個(gè)更大的數(shù)組。 返回的 slice 會(huì)指向這個(gè)新分配的數(shù)組亡脑。

func main() {
    var a []int
    printSlice("a", a)

    // append works on nil slices.
    a = append(a, 0)
    printSlice("a", a)

    // the slice grows as needed.
    a = append(a, 1)
    printSlice("a", a)

    // we can add more than one element at a time.
    a = append(a, 2, 3, 4)
    printSlice("a", a)
}

func printSlice(s string, x []int) {
    fmt.Printf("%s len=%d cap=%d %v\n",
        s, len(x), cap(x), x)
}
// cap 有一個(gè)增加算法堕澄， len單純是長度
/*
a len=0 cap=0 []
a len=1 cap=1 [0]
a len=2 cap=2 [0 1]
a len=5 cap=6 [0 1 2 3 4]
*/

range

for 循環(huán)的 range 格式可以對 slice 或者 map 進(jìn)行迭代循環(huán)。

var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}
func main() {
        // i => index, v => value
    for i, v := range pow {
        fmt.Printf("2^%d = %d\n", i, v)
    }
}
/*
2^0 = 1
2^1 = 2
2^2 = 4
2^3 = 8
2^4 = 16
2^5 = 32
2^6 = 64
2^7 = 128
*/

可以通過賦值給 _ 來忽略序號(hào)和值霉咨。
如果只需要索引值蛙紫，去掉“, value”的部分即可。

func main() {
    pow := make([]int, 10)
    for i := range pow {
        pow[i] = 1 << uint(i)
    }
    for _, value := range pow {
        fmt.Printf("%d\n", value)
    }
}

map

map 映射鍵到值途戒。
map 在使用之前必須用 make 而不是 new 來創(chuàng)建坑傅；值為 nil 的 map 是空的，并且不能賦值

type Vertex struct {
    Lat, Long float64
}

var m map[string]Vertex

func main() {
    m = make(map[string]Vertex)
    m["Bell Labs"] = Vertex{
        40.68433, -74.39967,
    }
    fmt.Println(m["Bell Labs"])
}
// {40.68433 -74.39967}

map 的文法跟結(jié)構(gòu)體文法相似喷斋，不過必須有鍵名唁毒。

var m = map[string]Vertex{
    "Bell Labs": Vertex{
        40.68433, -74.39967,
    },
    "Google": Vertex{
        37.42202, -122.08408,
    },
}

func main() {
    fmt.Println(m)
}
// map[Bell Labs:{40.68433 -74.39967} Google:{37.42202 -122.08408}]

如果頂級(jí)的類型只有類型名的話矢渊，可以在文法的元素中省略鍵名

var m = map[string]Vertex{
    "Bell Labs": {40.68433, -74.39967},
    "Google":    {37.42202, -122.08408},
}
func main() {
    fmt.Println(m)
}

修改 map
在 map m 中插入或修改一個(gè)元素：
'm[key] = elem'
獲得元素：
'elem = m[key]'
刪除元素：
'delete(m, key)'
通過雙賦值檢測某個(gè)鍵存在：
'elem, ok = m[key]'
如果 key 在 m 中，ok 為 true 枉证。否則矮男， ok 為 false，并且 elem 是 map 的元素類型的零值室谚。
同樣的毡鉴，當(dāng)從 map 中讀取某個(gè)不存在的鍵時(shí)，結(jié)果是 map 的元素類型的零值秒赤。

func main() {
    m := make(map[string]int)

    m["Answer"] = 42
    fmt.Println("The value:", m["Answer"])

    m["Answer"] = 48
    fmt.Println("The value:", m["Answer"])

    delete(m, "Answer")
    fmt.Println("The value:", m["Answer"])

    v, ok := m["Answer"]
    fmt.Println("The value:", v, "Present?", ok)
}
/*
The value: 42
The value: 48
The value: 0
The value: 0 Present? false
*/

函數(shù)

函數(shù)也是值類型猪瞬。

func main() {
    hypot := func(x, y float64) float64 {
        return math.Sqrt(x*x + y*y)
    }
    fmt.Println(hypot(3, 4))
}
// 5

函數(shù)的閉包
Go 函數(shù)可以是閉包的。閉包是一個(gè)函數(shù)值入篮，它來自函數(shù)體的外部的變量引用陈瘦。 函數(shù)可以對這個(gè)引用值進(jìn)行訪問和賦值；換句話說這個(gè)函數(shù)被“綁定”在這個(gè)變量上潮售。
例如痊项，函數(shù) adder 返回一個(gè)閉包。每個(gè)閉包都被綁定到其各自的 sum 變量上酥诽。

func adder() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}

func main() {
    pos, neg := adder(), adder()
    for i := 0; i < 10; i++ {
        fmt.Println(
            pos(i),
            neg(-2*i),
        )
    }
}
/*
0 0
1 -2
3 -6
6 -12
10 -20
15 -30
21 -42
28 -56
36 -72
45 -90
*/

閉包實(shí)現(xiàn)斐波拉契

func fibonacci() func() int {
    back1, back2 := 0, 1
    return func() int {
        back1, back2 = back2, (back1 + back2)
        return back1
    }
}

func main() {
    f := fibonacci()
    for i := 0; i < 10; i++ {
        fmt.Println(f())
    }
}