之前試著看了一會兒GPL聖經，看不下去，感覺這個Go by Example更輕鬆一些，蕪湖，起飛~

1. Hello World

go run 直接執行
go build變異成二進位制檔案直接執行

2. 值

字串可以通過 + 連線

3. 變數

定義一個新變數， 可以像python那樣一次定義多個, 不賦值會有預設值， int是0， string是""空字串

//這三種等效
var a int = 1
var b = 1
c := 1
var d int

4. 常量

const 語句可以出現在任何 var 語句可以出現的地方
可以執行任意精度的運算
常量沒確定型別，在需要數字的地方都可以用，會自動轉換成float64之類的型別

5. For 迴圈

格式是

for initialization; condition; post {
    // zero or more statements
}
// a traditional "while" loop
for condition {
    // ...
}
// a traditional infinite loop
for {
    // ...
}

常見的demo如下， 列印奇數：

for n := 0; n <= 5; n++ {
     if n%2 == 0 {
         continue
     }
     fmt.Println(n)
 }

6. If/Else 分支

demo如下

if num := 9; num < 0 {
    fmt.Println(num, "is negative")
} else if num < 10 {
    fmt.Println(num, "has 1 digit")
} else {
    fmt.Println(num, "has multiple digits")
}

相比java，go的if條件不需要括號（也可以加），而且在判斷條件之前可以加一句執行語句，用；隔開就行，感覺沒啥用。
Go 沒有三目運算子， 即使是基本的條件判斷，依然需要使用完整的 if 語句。

7. Switch 分支結構

基本的switch和java一樣，
在switch-case的case裡， 可以用逗號來取多個條件， 比如

switch time.Now().Weekday() {
    case time.Saturday, time.Sunday:
        fmt.Println("It's the weekend")
    default:
        fmt.Println("It's a weekday")
    }

還可以switch後面不跟任何東西， 這樣就類似於一個if-esle了；
還有一個叫type switch的東西，可以用來獲取到型別：

    whatAmI := func(i interface{}) {
        switch t := i.(type) {
        case bool:
            fmt.Println("I'm a bool")
        case int:
            fmt.Println("I'm an int")
        default:
            fmt.Printf("Don't know type %T\n", t)
        }
    }

8.陣列

定義一個陣列用

var a [5]int
var twoD [2][3]int

具體訪問的時候和C語言一樣的，比如twoD[1][1]
預設初始化都是0

9. 切片

Slice切片很類似於陣列，用make來定義

s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s[2] = "c"

有一個append方法是用來向後面插元素的，返回值是新slice，這裡如果slice的容量足夠，會直接返回當前slice，如果容量不夠會申請一個新的slice；

t := append(s, "d")
fmt.Println(t)
fmt.Println(s)
// [a b c d]
// [a b c]

可以用copy(c, s)來複制；
可以用s[2:5]來切片，這裡的left和right都是可以省略的，比如s[:5]
可以定義二維slice， 這麼玩兒的twoD := make([][]int, 3)

10. Map

建立一個map可以這麼做：

m := make(map[string]int)

插入和刪除操作如下：

m["k2"] = 2
delete(m, "k2")

這裡的delete是沒有返回值的
要取出來一個值是這樣做：

x1, x2 := m["k2"]

x1是取出來的值，x2表示map 中是否存在這個鍵；
如果map中沒有這個key，就會返回0或者預設值；

直接初始化map可以這麼做：

n := map[string]int{"foo": 1, "bar": 2}

這裡要注意一個問題，不能向下面這樣初始化一個map

var a map[string]string
a["b"] = "c"//這樣會報錯的，要先初始化記憶體
a = make(map[string]string)
a["b"] = "c"//這樣才不會錯

所以一般應該是用make來初始化map比較好；

11. Range 遍歷

感覺是一個增強版的python的range，可以用來遍歷一些資料結構，比如：

// 遍歷陣列
nums := []int{2, 3, 4}
for index, value:= range nums {
}
// 遍歷map
kvs := map[string]string{"a": "apple", "b": "banana"}
for k, v := range kvs {
	fmt.Printf("%s -> %s\n", k, v)
}
// 返回鍵的range
for k := range kvs {
    fmt.Println("key:", k)
}
// 返回 位置和字元，這裡的字元是ascii碼
// output:
// 0 103
// 1 111
for i, c := range "go" {
    fmt.Println(i, c)
}

12. 函式

func add(a int, b int) int {
	return a+b
}

這裡的入參部分可以省略成 a, b int

13. 多返回值

go原生支援多返回值，可以這麼玩兒：

func vals() (int, int) {
	return 3, 7
}

func main() {
	_, x := vals()
	fmt.Println(x)
}

14. 變參函式

入引數量可以不固定，這麼寫：

func sum(nums ...int) {
	
}

這裡注意，如果入參是一個切片，需要這麼寫func(slice...)：

nums := []int{1, 2, 3, 4}
sum(nums...)