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]]

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

$ 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]]

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

 

$ 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]

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