02 Golang 基礎簡介

一、標識符

標識符是指定義的具有特殊意義的詞，例如變數、常量、函數名等等，任何一門語言中都對自己的標識符有特殊定義的規則。在 Go 語言中，標識符由字母數字和下劃線組成，並且只能以字母和下劃線開頭，例如：

• 數字、字母和下劃線組成：123、abc _

• 只能以字母和下劃線開頭：abc123、_sysVar、123abc

• 標識符區分大小寫：name、Name、NAME

二、關鍵字和保留字

關鍵字和保留字是指編程語言中預先定義好的具有特殊含義的標識符。 關鍵字和保留字都不建議用作變數名，會引起混亂和衝突。

1. GO中的關鍵字

    break        default      func         interface    select
    case         defer        go           map          struct
    chan         else         goto         package      switch
    const        fallthrough  if           range        type
    continue     for          import       return       var

2. GO中的保留字

 Constants:    true  false  iota  nil
​
     Types:    int  int8  int16  int32  int64  
               uint  uint8  uint16  uint32  uint64  uintptr
               float32  float64  complex128  complex64
               bool  byte  rune  string  error
​
  Functions:   make  len  cap  new  append  copy  close  delete
               complex  real  imag
               panic  recover

三、命名規範

由於Go語言是一門區分大小寫的語言，因此Go從語法層面進行了以下限定：任何需要對外暴露的名字必須以大寫字母開頭，不需要對外暴露的則應該以小寫字母開頭。

當命名（包括常量、變數、類型、函數名、結構欄位等等）以一個大寫字母開頭，如：GetUserName，那麼使用這種形式的標識符的對象就可以被外部包的代碼所使用（程式需要先導入這個包），這被稱為導出（類似面向對象語言中的公共屬性）； 命名如果以小寫字母開頭，則對包外是不可見的，但是他們在整個包的內部是可見並且可用的（類似面向對象語言中的私有屬性 ）。

Go語言中各類情形的建議命名規則如下：

• 變數命名

變數名稱一般遵循駝峰法，首字母根據訪問控制原則大寫或者小寫

1 var userName string
2 var isExist bool

• 常量命名

常量均需使用全部大寫字母組成，並使用下劃線分詞

const SITE_URL = "http://www.chendacheng.com"

• 結構體命名

採用駝峰命名法，首字母根據訪問控制大寫或者小寫

1 type UserInfo struct {
2     Name string,
3     age  int,
4 }

• 介面命名

命名規則基本和上面的結構體類型，單個函數的結構名以er作為尾碼

1 type Reader interface {
2      Read(p []byte) (n int, err error)
3 }

• 錯誤處理

錯誤處理的原則就是不能丟棄任何有返回err的調用，不要使用_丟棄，必須全部處理。接收到錯誤，要麼返回err，或者使用log記錄下來儘早return。一旦有錯誤發生，馬上返回，儘量不要使用panic，除非你知道你在做什麼，錯誤描述如果是英文必須為小寫，不需要標點結尾，採用獨立的錯誤流進行處理。

1 if err != nil {
2     // 錯誤處理
3     return // 或者繼續
4 }
5 // 正常代碼

• 包命名

儘量保持和目錄保持一致，採取有意義的包名，簡短且不要和標準庫不要衝突。包名應該為小寫單詞，不要使用下劃線或者混合大小寫。

1 package dao
2 package service
3 package main

• 文件命名

儘量採取簡短且有意義的文件名，應該為小寫單詞，使用下劃線分隔各個單詞。

1 customer_dao.go
2 user_manage.go

• 單元測試

單元測試文件名要以 _test.go結尾，測試文件中的測試用例的函數名稱必須以 Test 開頭。

四、變數

變數的作用是存儲數據，不同的變數保存的數據類型可能會不一樣。Go 語言中的每一個變數都有自己的類型，變數必須經過聲明才能開始使用，且同一作用域內不支持重覆聲明。

1. 變數的作用域

1.1 全局變數和局部變數

變數可以定義在函數內部（函數外的每個語句都必須以關鍵字開始，如：var、const、func等），也可以定義在函數內部。定義在函數外部的變數稱為 全局變數，定義在函數內部的變數稱為 局部變數 。在 GO 語言中，定義的局部變數必須使用，否則編譯代碼的時候將不被通過，定義的全局變數可以不使用。

1 package main
2 ​
3 var name string = "cdc" // 定義一個全局變數
4 ​
5 func main() {
6 ​
7 }

直接編譯通過：

1 package main
2 ​
3 func main() {
4     name := "cdc"  // 聲明並初始化了一個局部變數，但是未使用
5 }

直接編譯未通過，報錯：

1.2 作用域

• 函數內可以使用全局的變數，但是在全局無法使用局部的變數

 1 var name = "cdc"
 2 ​
 3 func main() {
 4     fmt.Printf("%v\n", name)  // cdc
 5 }
 6 func demo() {
 7     var name = "cdc"
 8 }
 9 ​
10 func main() {
11     fmt.Printf("%v\n", name) // undefined: namet
12 ​
13 }

• 代碼執行時，先從函數內部尋找局部變數，找不到再去找全局的變數

 1 package main
 2 ​
 3 import "fmt"
 4 ​
 5 var name = "cdc"
 6 var age = 22
 7 ​
 8 func main() {
 9 ​
10     var name = "ctt"
11     
12 ​
13     fmt.Printf("%v\n", name) // ctt
14     fmt.Printf("%v\n", age)  // 22
15 }

2. 變數的聲明

2.1 標準聲明方式

變數聲明以關鍵字 var 開頭，變數類型放在變數的後面，行尾無需分號。

1 var name string
2 var age int
3 var isOk bool

2.2 批量聲明

1 var (
2     a string
3     b int
4     c bool
5     d float32
6 )

註意：在沒有初始化變數之前，不同數據類型的變數會有一個預設值，值為該數據類型對應的0值：

 1 package main
 2 ​
 3 import "fmt"
 4 ​
 5 func main() {
 6     var (
 7         a string
 8         b int
 9         c bool
10         d float32
11     )
12 ​
13     fmt.Println(a) // ""
14     fmt.Println(b) // 0
15     fmt.Println(c) // false
16     fmt.Println(d) // 0
17 }

3. 變數初始化

3.1 標準初始化格式

1 var name string = "cdc"
2 var age int = 18
3 ​
4 // 一次聲明多個變數
5 var age, isOk = 18, true

3.2 類型推導

有時候我們會將變數的類型省略，這個時候編譯器會根據等號右邊的值來推導變數的類型完成初始化

 1 package main
 2 ​
 3 import "fmt"
 4 ​
 5 func main() {
 6     var name = "cdc" // 編譯器會根據 “cdc” 推導出變數 name 是一個字元串類型
 7     var age = 18
 8 ​
 9     fmt.Printf("%T\n", name) // string
10     fmt.Printf("%T\n", age)  // int
11 }

3.3 短變數聲明

短變數聲明方式只能用於函數內部

 1 package main
 2 ​
 3 import "fmt"
 4 ​
 5 // 全局變數m
 6 var m = 100
 7 ​
 8 func main() {
 9     n := 10
10     m := 200 // 此處聲明局部變數m
11     fmt.Println(m, n)
12 }

3.4 匿名變數

對於聲明的局部變數必須要使用，否則編譯無法通過。如果想要忽略某個值，我們可以使用 匿名變數 來接收該值 。匿名變數用一個下劃線表示，它不占用命名空間，不會分配記憶體，所以匿名變數之間不存在重覆聲明，例如：

 1 package main
 2 ​
 3 import "fmt"
 4 ​
 5 func function1() (string, int) {
 6     return "cdc", 18
 7 }
 8 ​
 9 func main() {
10     var name, _ = function1()
11     fmt.Printf("My name is %s", name)
12 }

匿名變數 _ 並未使用，但是編譯可以通過

五、常量

常量是指恆定不變的值，多用於定義程式運行期間不會改變的那些值，一旦定義了常量後就無法修改。

1. 標準聲明格式

1 const PI = 3.1415
2 const E = 2.7182

2. 批量聲明

1 const (
2     STATUS_OK = 200
3     NOT_FOUND = 404
4 )

批量聲明常量時，如果某一行聲明之後沒有賦值，那麼後面的常量就預設和上一行一致

 1 package main
 2 ​
 3 import "fmt"
 4 ​
 5 const (
 6     n1 = 100
 7     n2 = 200
 8     n3
 9     n4
10 )
11 ​
12 func main() {
13     fmt.Printf("n1:%v\n", n1)
14     fmt.Printf("n2:%v\n", n2)
15     fmt.Printf("n3:%v\n", n3)
16     fmt.Printf("n4:%v\n", n4)
17 }

編譯執行結果如下，n3、n4 的值都為 200：

3. iota

iota 是go語言的常量計數器，只能在常量的表達式中使用。iota 在 const 關鍵字出現時將被重置為0，const 中每新增一行常量聲明將使 iota 計數一次。可以直接理解 iota 其實就是每一行代碼的索引值。

• 示例1：

 1 package main
 2 ​
 3 import "fmt"
 4 ​
 5 const (
 6     a1 = iota
 7     a2 = iota
 8     a3 = iota
 9     a4 = iota
10 )
11 ​
12 func main() {
13     fmt.Printf("a1:%d\n", a1)
14     fmt.Printf("a2:%d\n", a2)
15     fmt.Printf("a3:%d\n", a3)
16     fmt.Printf("a4:%d\n", a4)
17 }

分析：出現了 const 關鍵字，所以 a1 對應的 iota 的值為 0；後面每新增一行常量的聲明，iota 的值就累加1，所以最後列印的結果為：

• 示例2，省略 iota：

 1 package main
 2 ​
 3 import "fmt"
 4 ​
 5 const (
 6     b1 = iota
 7     b2
 8     b3
 9     b4
10 )
11 ​
12 func main() {
13     fmt.Printf("b1:%d\n", b1)
14     fmt.Printf("b2:%d\n", b2)
15     fmt.Printf("b3:%d\n", b3)
16     fmt.Printf("b4:%d\n", b4)
17 }

分析：出現了 const 關鍵字，所以 b1 對應的 iota 的值為 0；由於常量批量聲明的規則，當某一行聲明之後沒有賦值，那麼後面的常量就預設和上一行一致，所以理論上 b2 的值應該也為 iota，每新增一行常量的聲明，iota 的值就累加1，所以 b2 的值應該為1，以此類推，最後列印的結果為：

• 示例3，使用 _ 跳過某些值：

 1 package main
 2 ​
 3 import "fmt"
 4 ​
 5 func main() {
 6     const (
 7         n1 = iota
 8         n2
 9         _
10         n4
11     )
12 ​
13     fmt.Printf("n1: %d\n", n1)
14     fmt.Printf("n2: %d\n", n2)
15     fmt.Printf("n4: %d\n", n4)
16 }

分析：出現了 const 關鍵字，所以 n1 對應的 iota 的值為 0；由於常量批量聲明的規則，當某一行聲明之後沒有賦值，那麼後面的常量就預設和上一行一致，所以理論上 n2 的值應該也為 iota，每新增一行常量的聲明，iota 的值就累加1，所以 n2 的值應該為1；雖然匿名變數會被跳過，但是也是作為一個常量聲明的，也會遵循只要新增一行常量聲明 iota 就累加1的規則，所以匿名變數對應的值應該是2，以此類推，最後編譯列印的結果為：

• 示例4，iota 聲明中間插隊：

 1 package main
 2 ​
 3 import "fmt"
 4 ​
 5 func main() {
 6     const (
 7         n1 = iota
 8         n2 = 100
 9         n3 = iota
10         n4
11     )
12 ​
13     fmt.Printf("n1: %d\n", n1)
14     fmt.Printf("n3: %d\n", n2)
15     fmt.Printf("n4: %d\n", n4)
16 }

分析：出現了 const 關鍵字，所以 n1 對應的 iota 的值為 0；雖然 n2 沒有使用到 iota，但是 iota 是對當前批量聲明的常量做統計的，只要新增了一行常量聲明，值就累加 1 ，因此聲明 n2 時，iota 還是會加 1，以此類推，最後編譯列印的結果為：

• 示例5，多個iota定義在一行

 1 package main
 2 ​
 3 import "fmt"
 4 ​
 5 func main() {
 6     const (
 7         n1, n2 = iota + 1, iota + 2
 8         n3, n4 = iota + 1, iota + 2
 9     )
10 ​
11     fmt.Printf("n1: %d\n", n1)
12     fmt.Printf("n2: %d\n", n2)
13     fmt.Printf("n3: %d\n", n3)
14     fmt.Printf("n4: %d\n", n4)
15 }

分析：只要每新增了一行常量聲明，iota 值就累加 1 ，但是 n1 和 n2 是在一行聲明的，所以對於 n1 和 n2 ，iota 的值都為 0；到聲明 n3 和 n4 的時候才是新增了一行聲明，這時的 iota 的值才會累加 1，編譯運行的結果如下：

• 示例6，使用 iota 定義數量級

1 const (
2         _  = iota
3         KB = 1 << (10 * iota)
4         MB = 1 << (10 * iota)
5         GB = 1 << (10 * iota)
6         TB = 1 << (10 * iota)
7         PB = 1 << (10 * iota)
8 )