與Go的初次見面 ｜ 青訓營筆記
theme: nico
這是我參與「第五屆青訓營 」伴學筆記創作活動的第 1 天
前言
記錄加入青訓營的每一天的日筆記
本文總共分為：介紹、關鍵字、資料型別的定義、內建基礎型別、array/slice/map、零值
Go介紹
Go 是在設計時考慮了系統程式設計的通用型程式語言。它是強型別，有垃圾回收機制並原生支援併發程式設計。Go 程式由一個或多個 package 組成，這樣可以高效的管理依賴。
Go 的語法簡潔且有規則，這讓自動化工具可以很容易的分析程式碼，例如：整合開發環境。
Go一些規則
Go之所以會那麼簡潔，是因為它有一些預設的行為：
- 大寫字母開頭的變數是可匯出的，也就是其它包可以讀取的，是公有變數；小寫字母開頭的就是不可匯出的，是私有變數。
- 大寫字母開頭的函式也是一樣，相當於
class中的帶public關鍵詞的公有函式；小寫字母開頭的就是有private關鍵詞的私有函式。
關鍵字
var和const是 Go語言基礎裡面的變數和常量申明package和import用於分包和匯入func用於定義函式和方法return用於從函式返回defer用於類似解構函式go用於併發select用於選擇不同型別的通訊interface用於定義介面struct用於定義抽象資料型別break、case、continue、for、fallthrough、else、if、switch、goto、default用於流程控制chan用於channel通訊type用於宣告自定義型別map用於宣告map型別資料range用於讀取slice、map、channel資料
資料型別的定義
變數
Go對於已宣告但未使用的變數會在編譯階段報錯。
Go語言裡面定義變數有多種方式。使用var關鍵字是Go最基本的定義變數方式，與C語言不同的是Go把變數型別放在變數名後面。
//定義一個名稱為“variableName”，型別為"type"的變數
var variableName type
//定義三個型別都是“type”的變數
var vname1, vname2, vname3 type
//初始化“variableName”的變數為“value”值，型別是“type”
var variableName type = value
/*
定義三個型別都是"type"的變數,並且分別初始化為相應的值
vname1為v1，vname2為v2，vname3為v3
*/
var vname1, vname2, vname3 type= v1, v2, v3
/*
定義三個變數，它們分別初始化為相應的值
vname1為v1，vname2為v2，vname3為v3
然後Go會根據其相應值的型別來初始化它們
*/
var vname1, vname2, vname3 = v1, v2, v3
/*
定義三個變數，它們分別初始化為相應的值
vname1為v1，vname2為v2，vname3為v3
編譯器會根據初始化的值自動推匯出相應的型別
*/
vname1, vname2, vname3 := v1, v2, v3
/*
:=這個符號直接取代了var和type,這種形式叫做簡短宣告。
不過它有一個限制，那就是它只能用在函式內部；在函式外部使用則會無法編譯通過，所以一般用var方式來定義全域性變數。
_（下劃線）是個特殊的變數名，任何賦予它的值都會被丟棄
*/
_, b := 34, 35
常量
Go 常量和一般程式語言不同的是，可以指定相當多的小數位數(例如200位)，若指定給
float32自動縮短為32bit，指定給float64自動縮短為64bit
所謂常量，也就是在程式編譯階段就確定下來的值，而程式在執行時無法改變該值。在Go程式中，常量可定義為數值、布林值或字串等型別。
const constantName = value
//如果需要，也可以明確指定常量的型別：
const Pi float32 = 3.1415926
//下面是一些常量宣告的例子
const Pi = 3.1415926
const i = 10000
const MaxThread = 10
const prefix = "astaxie_"
內建基礎型別
布林型別
在Go中，布林值的型別為bool，值是true或false，預設為false。
數值型別
整數型別有無符號和帶符號兩種。Go同時支援int和uint，這兩種型別的長度相同，但具體長度取決於不同編譯器的實現。
Go裡面也有直接定義好位數的型別：rune, int8, int16, int32, int64和byte, uint8, uint16, uint32, uint64。其中rune是int32的別稱，byte是uint8的別稱。
需要注意的一點是，這些型別的變數之間不允許互相賦值或操作，不然會在編譯時引起編譯器報錯。
另外，儘管int的長度是32 bit, 但int 與 int32並不可以互用。
浮點數的型別有
float32和float64兩種（沒有float型別），預設是float64。
字串
Go中的字串都是採用UTF-8字符集編碼。字串是用一對雙引號（""）或反引號（`）括起來定義，它的型別是string`。
//示例程式碼
var frenchHello string // 宣告變數為字串的一般方法
var emptyString string = "" // 聲明瞭一個字串變數，初始化為空字串
func test() {
no, yes, maybe := "no", "yes", "maybe" // 簡短宣告，同時宣告多個變數
japaneseHello := "Konichiwa" // 同上
frenchHello = "Bonjour" // 常規賦值
}
在Go中字串是不可變的，但可以通過切片形式進行修改
s := "hello"
c := []byte(s) // 將字串 s 轉換為 []byte 型別
c[0] = 'c'
s2 := string(c) // 再轉換回 string 型別
fmt.Printf("%s\n", s2)
錯誤型別
Go內建有一個error型別，專門用來處理錯誤資訊，Go的package裡面還專門有一個包errors來處理錯誤
err := errors.New("emit macho dwarf: elf header corrupted")
if err != nil {
fmt.Print(err)
}
iota列舉
Go裡面有一個關鍵字iota，這個關鍵字用來宣告enum的時候採用，它預設開始值是0，const中每增加一行加1
package main
import (
"fmt"
)
const (
x = iota // x == 0
y = iota // y == 1
z = iota // z == 2
w // 常量宣告省略值時，預設和之前一個值的字面相同。這裡隱式地說w = iota，因此w == 3。其實上面y和z可同樣不用"= iota"
)
const v = iota // 每遇到一個const關鍵字，iota就會重置，此時v == 0
const (
h, i, j = iota, iota, iota //h=0,i=0,j=0 iota在同一行值相同
)
const (
a = iota //a=0
b = "B"
c = iota //c=2
d, e, f = iota, iota, iota //d=3,e=3,f=3
g = iota //g = 4
)
func main() {
fmt.Println(a, b, c, d, e, f, g, h, i, j, x, y, z, w, v)
}
array、slice、map
array
array就是陣列，它的定義方式如下：
var arr [n]type
[n]type中，n表示陣列的長度，type表示儲存元素的型別。對陣列的操作和其它語言類似，都是通過[]來進行讀取或賦值：
var arr [10]int // 聲明瞭一個int型別的陣列
arr[0] = 42 // 陣列下標是從0開始的
arr[1] = 13 // 賦值操作
fmt.Printf("The first element is %d\n", arr[0]) // 獲取資料，返回42
fmt.Printf("The last element is %d\n", arr[9]) //返回未賦值的最後一個元素，預設返回0
由於長度也是陣列型別的一部分，因此[3]int與[4]int是不同的型別，陣列也就不能改變長度。陣列之間的賦值是值的賦值，即當把一個數組作為引數傳入函式的時候，傳入的其實是該陣列的副本，而不是它的指標。
陣列可以使用另一種:=來宣告
a := [3]int{1, 2, 3} // 聲明瞭一個長度為3的int陣列
b := [10]int{1, 2, 3} // 聲明瞭一個長度為10的int陣列，其中前三個元素初始化為1、2、3，其它預設為0
c := [...]int{4, 5, 6} // 可以省略長度而採用`...`的方式，Go會自動根據元素個數來計算長度
Go支援巢狀陣列，即多維陣列。比如下面的程式碼就聲明瞭一個二維陣列：
// 聲明瞭一個二維陣列，該陣列以兩個陣列作為元素，其中每個陣列中又有4個int型別的元素
doubleArray := [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}}
// 上面的宣告可以簡化，直接忽略內部的型別
easyArray := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}
slice
在很多應用場景中，陣列並不能滿足需求。在初始定義陣列時，並不知道需要多大的陣列，因此就需要“動態陣列”。在Go裡面這種資料結構叫slice
slice並不是真正意義上的動態陣列，而是一個引用型別。slice總是指向一個底層array，slice的宣告也可以像array一樣，只是不需要長度。
// 和宣告array一樣，只是少了長度
var fslice []int
// 接下來可以宣告一個slice，並初始化資料
slice := []byte {'a', 'b', 'c', 'd'}
slice可以從一個數組或一個已經存在的slice中再次宣告。slice通過array[i:j]來獲取，其中i是陣列的開始位置，j是結束位置，但不包含array[j]，它的長度是j-i。
// 宣告一個含有10個元素元素型別為byte的陣列
var ar = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
// 宣告兩個含有byte的slice
var a, b []byte
// a指向陣列的第3個元素開始，併到第五個元素結束，
a = ar[2:5]
//現在a含有的元素: ar[2]、ar[3]和ar[4]
// b是陣列ar的另一個slice
b = ar[3:5]
// b的元素是：ar[3]和ar[4]
slice和陣列在宣告時的區別：宣告陣列時，方括號內寫明瞭陣列的長度或使用
...自動計算長度，而宣告slice時，方括號內沒有任何字元。
slice的一些簡便操作
slice的預設開始位置是0，ar[:n]等價於ar[0:n]slice的第二個序列預設是陣列的長度，ar[n:]等價於ar[n:len(ar)]- 如果從一個數組裡面直接獲取
slice，可以這樣ar[:]，因為預設第一個序列是0，第二個是陣列的長度，即等價於ar[0:len(ar)]
// 宣告一個數組
var array = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
// 宣告兩個slice
var aSlice, bSlice []byte
// 演示一些簡便操作
aSlice = array[:3] // 等價於aSlice = array[0:3] aSlice包含元素: a,b,c
aSlice = array[5:] // 等價於aSlice = array[5:10] aSlice包含元素: f,g,h,i,j
aSlice = array[:] // 等價於aSlice = array[0:10] 這樣aSlice包含了全部的元素
// 從slice中獲取slice
aSlice = array[3:7] // aSlice包含元素: d,e,f,g，len=4，cap=7
bSlice = aSlice[1:3] // bSlice 包含aSlice[1], aSlice[2] 也就是含有: e,f
bSlice = aSlice[:3] // bSlice 包含 aSlice[0], aSlice[1], aSlice[2] 也就是含有: d,e,f
bSlice = aSlice[0:5] // 對slice的slice可以在cap範圍內擴充套件，此時bSlice包含：d,e,f,g,h
bSlice = aSlice[:] // bSlice包含所有aSlice的元素: d,e,f,g
slice是引用型別，所以當引用改變其中元素的值時，其它的所有引用都會改變該值，例如上面的aSlice和bSlice，如果修改了aSlice中元素的值，那麼bSlice相對應的值也會改變。
從概念上面來說slice像一個結構體，這個結構體包含了三個元素：
- 一個指標，指向陣列中
slice指定的開始位置 - 長度，即
slice的長度 - 最大長度，也就是
slice開始位置到陣列的最後位置的長度
slice有幾個有用的內建函式
len獲取slice的長度cap獲取slice的最大容量append向slice裡面追加一個或者多個元素，然後返回一個和slice一樣型別的slicecopy函式copy從源slice的src中複製元素到目標dst，並且返回複製的元素的個數
append函式會改變slice所引用的陣列的內容，從而影響到引用同一陣列的其它slice。
但當slice中沒有剩餘空間（即(cap-len) == 0）時，此時將動態分配新的陣列空間。返回的slice陣列指標將指向這個空間，而原陣列的內容將保持不變；其它引用此陣列的slice則不受影響。
map
map
也就是Python中字典的概念，它的格式為map[keyType]valueType
map的讀取和設定也類似slice一樣，通過key來操作，只是slice的index只能是｀int｀型別，而map多了很多型別，可以是int，可以是string及所有完全定義了==與!=操作的型別。
// 宣告一個key是字串，值為int的字典,這種方式的宣告需要在使用之前使用make初始化
var numbers map[string]int
// 另一種map的宣告方式
numbers = make(map[string]int)
numbers["one"] = 1 //賦值
numbers["ten"] = 10 //賦值
numbers["three"] = 3
fmt.Println("第三個數字是: ", numbers["three"]) // 讀取資料
// 打印出來如:第三個數字是: 3
這個map就像平常看到的表格一樣，左邊列是key，右邊列是值
使用map過程中需要注意的幾點：
map是無序的，每次打印出來的map都會不一樣，它不能通過index獲取，而必須通過key獲取map的長度是不固定的，也就是和slice一樣，也是一種引用型別- 內建的
len函式同樣適用於map，返回map擁有的key的數量 map的值可以很方便的修改，通過numbers["one"]=11可以很容易的把key為one的字典值改為11map和其他基本型別不同，它不是thread-safe，在多個go-routine存取時，必須使用mutex lock機制
map的初始化可以通過key:val的方式初始化值，同時map內建有判斷是否存在key的方式
通過delete刪除map的元素：
// 初始化一個字典
rating := map[string]float32{"C":5, "Go":4.5, "Python":4.5, "C++":2 }
// map有兩個返回值，第二個返回值，如果不存在key，那麼ok為false，如果存在ok為true
csharpRating, ok := rating["C#"]
if ok {
fmt.Println("C# is in the map and its rating is ", csharpRating)
} else {
fmt.Println("We have no rating associated with C# in the map")
}
delete(rating, "C") // 刪除key為C的元素
map也是一種引用型別，如果兩個map同時指向一個底層，那麼一個改變，另一個也相應的改變：
m := make(map[string]string)
m["Hello"] = "Bonjour"
m1 := m
m1["Hello"] = "Salut" // 現在m["hello"]的值已經是Salut了
make、new操作
make用於內建型別（map、slice 和channel）的記憶體分配。new用於各種型別的記憶體分配。
內建函式new本質上說跟其它語言中的同名函式功能一樣：new(T)分配了零值填充的T型別的記憶體空間，並且返回其地址，即一個*T型別的值。用Go的術語說，它返回了一個指標，指向新分配的型別T的零值。有一點非常重要：
new返回指標。
內建函式make(T, args)與new(T)有著不同的功能，make只能建立slice、map和channel，並且返回一個有初始值(非零)的T型別，而不是*T。本質來講，導致這三個型別有所不同的原因是指向資料結構的引用在使用前必須被初始化。例如，一個slice，是一個包含指向資料（內部array）的指標、長度和容量的三項描述符；在這些專案被初始化之前，slice為nil。對於slice、map和channel來說，make初始化了內部的資料結構，填充適當的值。
make返回初始化後的（非零）值。
零值
關於“零值”，所指並非是空值，而是一種“變數未填充前”的預設值，通常為0。