本章主要分成三個部分：第一部分包括基本語法和數據結構;第二部分討論方法和接口;第三部分介紹并發機制。 包、變量和函數 先看一個例子Packages.go：

package main  import (     "fmt"     "math/rand" )  func add(x int, y int) int {     return x + y }  func main() {     fmt.Println("My favorite number is", rand.Intn(10))     fmt.Println(add(42, 13)) } 

包：每個 Go 程序都是由包(package)組成的，程序運行的入口是包 main。

導入：這個代碼用圓括號組合了導入，這是“打包”導入語句。同樣可以編寫多個導入語句，例如：

import "fmt" import "math" 

這個程序使用并導入了包 "fmt" 和 "math/rand"。包名與導入路徑的最后一個目錄一致。例如，如果你導入了"math/rand"，那么你就可以在程序里面直接寫rand.Intn(10),但如果你導入的是"math"，那么你就得寫math.rand.Intn(10)。

函數：函數可以沒有參數或接受多個參數。在這個例子中，add 接受兩個 int 類型的參數，注意類型在變量名之后。有沒有覺得很奇怪呢，下面就詳細解釋一下go這樣做的原因。 看一個c的例子：

int (*fp)(int (*ff)(int x, int y), int b) 

我相信學過c的同學為了看懂這個都下了不少功夫吧，有沒有感覺到痛苦或者說痛苦之后的那一點點優越感。 什么？你還能看懂？那么再來一個：

int (*(*fp)(int (*)(int, int), int))(int, int);// 10s內看懂的同學給我回復下這個定義是啥，我請你吃飯。 

用go語言的話這兩個例子的定義如下：

f func(func(int,int) int, int) int f func(func(int,int) int, int) func(int, int) int 

是不是清晰多了，原來f返回的是一個函數啊。。。

函數參數： 當兩個或多個連續的函數命名參數是同一類型，則除了最后一個類型之外，其他都可以省略，比如func add(x int, y int) int可以寫為func add(x, y int) int 函數返回值：

函數可以返回任意數量的返回值，比如func swap(x, y string) (string, string)。 并且，函數的返回值還可以被命名，并且像變量那樣使用，比如

func split(sum int) (x, y int) {     x = sum * 4 / 9     y = sum - x     return } 

沒有參數的 return 語句返回結果的當前值。 變量： var 語句定義了一個變量的列表；跟函數的參數列表一樣，類型在后面，可以定義在包或函數級別。比如：

package main import "fmt" var c, python, java bool func main() {     var i int     fmt.Println(i, c, python, java) } 

變量的初始化: 變量定義可以包含初始值，每個變量對應一個。如果初始化是使用表達式，則可以省略類型；變量從初始值中獲得類型。比如：var i, j int = 1, 2或者var c, python, java = true, false, "no!" 短聲明變量：在函數中，:= 簡潔賦值語句在明確類型的地方，可以用于替代 var 定義。 函數外的每個語句都必須以關鍵字開始（var、func、等等），:= 結構不能使用在函數外。比如：

package main import "fmt" func main() {     var i, j int = 1, 2     k := 3     c, python, java := true, false, "no!"     fmt.Println(i, j, k, c, python, java) } 

Go的基本類型：這里先簡單列一下，后面再具體講

bool string int  int8  int16  int32  int64 uint uint8 uint16 uint32 uint64 uintptr byte // uint8 的別名 rune // int32 的別名// 代表一個Unicode碼 float32 float64 complex64 complex128 

零值：變量在定義時沒有明確的初始化時會賦值為零值。數值類型為 0,布爾類型為 false,字符串為 ""。 類型轉換：Go 的在不同類型之間的項目賦值時需要顯式轉換。表達式 T(v) 將值 v 轉換為類型 T。比如：

var i int = 42 var f float64 = float64(i) var u uint = uint(f) 

或者，更加簡單的形式：

i := 42 f := float64(i) u := uint(f) 

類型推導：在定義一個變量但不指定其類型時（使用沒有類型的 var 或 := 語句）， 變量的類型由右值推導得出。 var i int j := i // j 也是一個 int 但是當右邊包含了未指名類型的數字常量時，新的變量就可能是 int 、 float64 或complex128。 這取決于常量的精度：

i := 42           // int f := 3.142        // float64 g := 0.867 + 0.5i // complex128 

常量：常量的定義與變量類似，只不過使用 const 關鍵字，常量可以是字符、字符串、布爾或數字類型的值，常量不能使用 := 語法定義。 流程控制語句 for循環：Go 只有一種循環結構for循環?；镜?for 循環除了沒有了 ( ) 之外（，看起來跟 C 或者 Java 中做的一樣，而 { } 是必須的。比如：

package main import "fmt" func main() {     sum := 0     for i := 0; i < 10; i++ {         sum += i     }     fmt.Println(sum) } 

死循環：如果省略了循環條件，循環就不會結束，因此可以用更簡潔地形式表達死循環。

package main func main() {     for {     } } 

If語句：if 語句除了沒有了 ( ) 之外，看起來跟 C 或者 Java 中的一樣，而 { } 是必須的。

func sqrt(x float64) string {     if x < 0 {         return sqrt(-x) + "i"     }     return fmt.Sprint(math.Sqrt(x)) } 

可以在if條件之前執行一個簡單的語句，由這個語句定義的變量的作用域僅在 if 范圍之內,比如：

func pow(x, n, lim float64) float64 {     if v := math.Pow(x, n); v < lim {         return v     }     return lim } 

在 if 的便捷語句定義的變量同樣可以在任何對應的 else 塊中使用，比如：

func pow(x, n, lim float64) float64 {     if v := math.Pow(x, n); v < lim {         return v     } else {         fmt.Printf("%g >= %g\n", v, lim)     }     // 這里開始就不能使用 v 了     return lim } 

Switch語句：switch 的條件從上到下的執行，當匹配成功的時候停止，除非以 fallthrough 語句結束，否則分支會自動終止。比如：

switch i { case 0: case f(): } 

當 i==0 時不會調用 f。沒有條件的 switch 同 switch true 一樣，這一構造使得可以用更清晰的形式來編寫長的 if-then-else 鏈。

func main() {     t := time.Now()     switch {     case t.Hour() < 12:         fmt.Println("Good morning!")     case t.Hour() < 17:         fmt.Println("Good afternoon.")     default:         fmt.Println("Good evening.")     } } 

Defer語句：defer 語句會延遲函數的執行直到上層函數返回，延遲調用的參數會立刻生成，但是在上層函數返回前函數都不會被調用。比如打印hello world：

func main() {     defer fmt.Println("world")     fmt.Println("hello") } 

延遲的函數調用被壓入一個棧中。當函數返回時， 會按照后進先出的順序調用被延遲的函數調用。

func main() {     fmt.Println("counting")     for i := 0; i < 10; i++ {         defer fmt.Println(i)     }     fmt.Println("done") } 

輸出

counting done 9 8 7 6 5 4 3 2 1 0 

這個功能用來做清理工作非常清晰且強大，可以用結構化編程的思路處理面向對象編程中類似析構函數的功能。舉一個實際點的例子：

func CopyFile(dstName, srcName string) (written int64, err error) {     src, err := os.Open(srcName)     if err != nil {         return     }     defer src.Close()      dst, err := os.Create(dstName)     if err != nil {         return     }     defer dst.Close()      return io.Copy(dst, src) } 

復雜類型 指針：Go 具有指針。 指針保存了變量的內存地址，類型 T 是指向類型 T 的值的指針。其零值是 nil，& 符號會生成一個指向其作用對象的指針， 符號表示指針指向的底層的值。

var p *int i := 42 p = &i fmt.Println(*p) // 通過指針 p 讀取 i *p = 21         // 通過指針 p 設置 i 

與 C 不同，Go 沒有指針運算。 結構體：一個結構體（struct）就是一個字段的集合，跟C類似，結構體字段使用點號來訪問，結構體字段可以通過結構體指針來訪問。

type Vertex struct {     X int     Y int }  func main() {     fmt.Println(Vertex{1, 2})     v.X = 4     fmt.Println(v.X)     p := &v     p.X = 1e9 } 

結構體文法：結構體文法表示通過結構體字段的值作為列表來新分配一個結構體。使用 Name: 語法可以僅列出部分字段。（字段名的順序無關。）特殊的前綴 & 返回一個指向結構體的指針。

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

數組：類型 [n]T 是一個有 n 個類型為 T 的值的數組，數組的長度是其類型的一部分，因此數組不能改變大小。 Slice：一個 slice 會指向一個序列的值，并且包含了長度信息，[]T 是一個元素類型為 T 的 slice。slice 可以重新切片，創建一個新的 slice 值指向相同的數組。s[lo:hi] 表示從 lo 到 hi-1 的 slice 元素，含兩端，因此s[lo:lo] 是空的。下標從0開始。

package main import "fmt"  func main() {     p := []int{2, 3, 5, 7, 11, 13}     fmt.Println("p ==", p)     fmt.Println("p[1:4] ==", p[1:4])      // 省略下標代表從 0 開始     fmt.Println("p[:3] ==", p[:3])      // 省略上標代表到 len(s) 結束     fmt.Println("p[4:] ==", p[4:]) } 

構造slice：slice 由函數 make 創建。這會分配一個零長度的數組并且返回一個 slice 指向這個數組，比如：

a := make([]int, 5)  // len(a)=5 

為了指定容量，可傳遞第三個參數到 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 

slice 的零值是 nil，一個 nil 的 slice 的長度和容量是 0。 向slice添加元素： func append(s []T, vs ...T) []T append 的第一個參數 s 是一個類型為 T 的數組，append 的結果是一個包含原 slice 所有元素加上新添加的元素的 slice，如果 s 的底層數組太小，而不能容納所有值時，會分配一個更大的數組，返回的 slice 會指向這個新分配的數組。 range： for 循環的 range 格式可以對 slice 或者 map 進行迭代循環。

package main import "fmt"  var pow = []int{1, 2, 4, 8, 16, 32, 64, 128} func main() {     for i, v := range pow {         fmt.Printf("2**%d = %d\n", i, v)     } } 

可以通過賦值給 _ 來忽略序號和值,如果只需要索引值，去掉“, 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 在使用之前必須用 make 而不是 new 來創建；值為 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"]) } 

map 的文法跟結構體文法相似，不過必須有鍵名。

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

如果頂級的類型只有類型名的話，可以在文法的元素中省略鍵名。

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

修改 map： 在 map m 中插入或修改一個元素：m[key] = elem 獲得元素：elem = m[key] 刪除元素：delete(m, key) 通過雙賦值檢測某個鍵存在：elem, ok = m[key] 如果 key 在 m 中，ok 為 true 。否則， ok 為 false，并且 elem 是 map 的元素類型的零值，同樣的，當從 map 中讀取某個不存在的鍵時，結果是 map 的元素類型的零值。

函數值：函數也是值。

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

函數的閉包：這個意思簡單點就是以函數作為返回值。 Go 函數可以是閉包的。閉包是一個函數值，它來自函數體的外部的變量引用。 函數可以對這個引用值進行訪問和賦值；換句話說這個函數被“綁定”在這個變量上。

package main  import "fmt"  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),         )     } }