原文：https://learnxinyminutes.com/docs/zh-cn/go-cn/

發(fā)明Go語言是出于更好地完成工作的需要。Go不是計算機科學的最新發(fā)展潮流仁堪，但它卻提供了解決現(xiàn)實問題的最新最快的方法。

Go擁有命令式語言的靜態(tài)類型各吨，編譯很快，執(zhí)行也很快袁铐，同時加入了對于目前多核CPU的并發(fā)計算支持揭蜒，也有相應(yīng)的特性來實現(xiàn)大規(guī)模編程。

Go語言有非常棒的標準庫剔桨，還有一個充滿熱情的社區(qū)屉更。

// 單行注釋
/* 多行
    注釋 */

// 導入包的子句在每個源文件的開頭。
// Main比較特殊洒缀，它用來聲明可執(zhí)行文件瑰谜，而不是一個庫。
package main

// Import語句聲明了當前文件引用的包树绩。
import (
    "fmt"       // Go語言標準庫中的包
    "io/ioutil" // 包含一些輸入輸出函數(shù)
    m "math"    // 數(shù)學標準庫萨脑，在此文件中別名為m
    "net/http"  // 一個web服務(wù)器包
    "os"        // 系統(tǒng)底層函數(shù)，如文件讀寫
    "strconv"   // 字符串轉(zhuǎn)換
)

// 函數(shù)聲明：Main是程序執(zhí)行的入口饺饭。
// 不管你喜歡還是不喜歡渤早，反正Go就用了花括號來包住函數(shù)體。
func main() {
    // 往標準輸出打印一行瘫俊。
    // 用包名fmt限制打印函數(shù)鹊杖。
    fmt.Println("天坑歡迎你!")

    // 調(diào)用當前包的另一個函數(shù)。
    beyondHello()
}

// 函數(shù)可以在括號里加參數(shù)扛芽。
// 如果沒有參數(shù)的話骂蓖，也需要一個空括號。
func beyondHello() {
    var x int   // 變量聲明川尖，變量必須在使用之前聲明登下。
    x = 3       // 變量賦值。
    // 可以用:=來偷懶叮喳，它自動把變量類型庐船、聲明和賦值都搞定了。
    y := 4
    sum, prod := learnMultiple(x, y)        // 返回多個變量的函數(shù)
    fmt.Println("sum:", sum, "prod:", prod) // 簡單輸出
    learnTypes()                            // 少于y分鐘嘲更，學的更多筐钟！
}

/* <- 快看快看我是跨行注釋_(:з」∠)_
Go語言的函數(shù)可以有多個參數(shù)和 *多個* 返回值。
在這個函數(shù)中赋朦， `x`篓冲、`y` 是參數(shù)李破，
`sum`、`prod` 是返回值的標識符（可以理解為名字）且類型為int
*/
func learnMultiple(x, y int) (sum, prod int) {
    return x + y, x * y // 返回兩個值
}

// 內(nèi)置變量類型和關(guān)鍵詞
func learnTypes() {
    // 短聲明給你所想壹将。
    str := "少說話多讀書!" // String類型

    s2 := `這是一個
可以換行的字符串` // 同樣是String類型

    // 非ascii字符嗤攻。Go使用UTF-8編碼。
    g := 'Σ' // rune類型诽俯，int32的別名妇菱，使用UTF-8編碼

    f := 3.14195 // float64類型，IEEE-754 64位浮點數(shù)
    c := 3 + 4i  // complex128類型暴区，內(nèi)部使用兩個float64表示

    // Var變量可以直接初始化闯团。
    var u uint = 7  // unsigned 無符號變量，但是實現(xiàn)依賴int型變量的長度
    var pi float32 = 22. / 7

    // 字符轉(zhuǎn)換
    n := byte('\n') // byte是uint8的別名

    // 數(shù)組（Array）類型的大小在編譯時即確定
    var a4 [4] int              // 有4個int變量的數(shù)組仙粱，初始為0
    a3 := [...]int{3, 1, 5}     // 有3個int變量的數(shù)組房交，同時進行了初始化

    // Array和slice各有所長，但是slice可以動態(tài)的增刪伐割，所以更多時候還是使用slice候味。
    s3 := []int{4, 5, 9}    // 回去看看 a3 ，是不是這里沒有省略號隔心？
    s4 := make([]int, 4)    // 分配4個int大小的內(nèi)存并初始化為0
    var d2 [][]float64      // 這里只是聲明白群，并未分配內(nèi)存空間
    bs := []byte("a slice") // 進行類型轉(zhuǎn)換

    // 切片（Slice）的大小是動態(tài)的，它的長度可以按需增長
    // 用內(nèi)置函數(shù) append() 向切片末尾添加元素
    // 要增添到的目標是 append 函數(shù)第一個參數(shù)硬霍，
    // 多數(shù)時候數(shù)組在原內(nèi)存處順次增長川抡，如
    s := []int{1, 2, 3}     // 這是個長度3的slice
    s = append(s, 4, 5, 6)  // 再加仨元素，長度變?yōu)?了
    fmt.Println(s) // 更新后的數(shù)組是 [1 2 3 4 5 6]

    // 除了向append()提供一組原子元素（寫死在代碼里的）以外须尚，我們
    // 還可以用如下方法傳遞一個slice常量或變量崖堤，并在后面加上省略號，
    // 用以表示我們將引用一個slice耐床、解包其中的元素并將其添加到s數(shù)組末尾密幔。
    s = append(s, []int{7, 8, 9}...) // 第二個參數(shù)是一個slice常量
    fmt.Println(s)  // 更新后的數(shù)組是 [1 2 3 4 5 6 7 8 9]

    p, q := learnMemory()       // 聲明p,q為int型變量的指針
    fmt.Println(*p, *q)         // * 取值

    // Map是動態(tài)可增長關(guān)聯(lián)數(shù)組，和其他語言中的hash或者字典相似撩轰。
    m := map[string]int{"three": 3, "four": 4}
    m["one"] = 1

    // 在Go語言中未使用的變量在編譯的時候會報錯胯甩，而不是warning。
    // 下劃線 _ 可以使你“使用”一個變量堪嫂，但是丟棄它的值偎箫。
    _, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a3, s4, bs
    // 通常的用法是，在調(diào)用擁有多個返回值的函數(shù)時皆串，
    // 用下劃線拋棄其中的一個參數(shù)淹办。下面的例子就是一個臟套路，
    // 調(diào)用os.Create并用下劃線變量扔掉它的錯誤代碼恶复。
    // 因為我們覺得這個文件一定會成功創(chuàng)建怜森。
    file, _ := os.Create("output.txt")
    fmt.Fprint(file, "這句代碼還示范了如何寫入文件呢")
    file.Close()

    // 輸出變量
    fmt.Println(s, c, a4, s3, d2, m)

    learnFlowControl() // 回到流程控制
}

// 和其他編程語言不同的是速挑，go支持有名稱的變量返回值。
// 聲明返回值時帶上一個名字允許我們在函數(shù)內(nèi)的不同位置
// 只用寫return一個詞就能將函數(shù)內(nèi)指定名稱的變量返回
func learnNamedReturns(x, y int) (z int) {
    z = x * y
    return // z is implicit here, because we named it earlier.
}

// Go全面支持垃圾回收副硅。Go有指針姥宝，但是不支持指針運算。
// 你會因為空指針而犯錯恐疲，但是不會因為增加指針而犯錯腊满。
func learnMemory() (p, q *int) {
    // 返回int型變量指針p和q
    p = new(int)    // 內(nèi)置函數(shù)new分配內(nèi)存
    // 自動將分配的int賦值0，p不再是空的了培己。
    s := make([]int, 20)    // 給20個int變量分配一塊內(nèi)存
    s[3] = 7                // 賦值
    r := -2                 // 聲明另一個局部變量
    return &s[3], &r        // & 取地址
}

func expensiveComputation() int {
    return 1e6
}

func learnFlowControl() {
    // If需要花括號碳蛋，括號就免了
    if true {
        fmt.Println("這句話肯定被執(zhí)行")
    }
    // 用go fmt 命令可以幫你格式化代碼，所以不用怕被人吐槽代碼風格了漱凝，
    // 也不用容忍別人的代碼風格疮蹦。
    if false {
        // pout
    } else {
        // gloat
    }
    // 如果太多嵌套的if語句诸迟，推薦使用switch
    x := 1
    switch x {
    case 0:
    case 1:
        // 隱式調(diào)用break語句茸炒，匹配上一個即停止
    case 2:
        // 不會運行
    }
    // 和if一樣，for也不用括號
    for x := 0; x < 3; x++ { // ++ 自增
        fmt.Println("遍歷", x)
    }
    // x在這里還是1阵苇。為什么壁公？

    // for 是go里唯一的循環(huán)關(guān)鍵字，不過它有很多變種
    for { // 死循環(huán)
        break    // 騙你的
        continue // 不會運行的
    }

    // 用range可以枚舉 array绅项、slice紊册、string、map快耿、channel等不同類型
    // 對于channel囊陡，range返回一個值，
    // array掀亥、slice撞反、string、map等其他類型返回一對兒
    for key, value := range map[string]int{"one": 1, "two": 2, "three": 3} {
        // 打印map中的每一個鍵值對
        fmt.Printf("索引：%s, 值為：%d\n", key, value)
    }
    // 如果你只想要值搪花，那就用前面講的下劃線扔掉沒用的
    for _, name := range []string{"Bob", "Bill", "Joe"} {
        fmt.Printf("你是遏片。。 %s\n", name)
    }

    // 和for一樣撮竿，if中的:=先給y賦值吮便，然后再和x作比較。
    if y := expensiveComputation(); y > x {
        x = y
    }
    // 閉包函數(shù)
    xBig := func() bool {
        return x > 100 // x是上面聲明的變量引用
    }
    fmt.Println("xBig:", xBig()) // true （上面把y賦給x了）
    x /= 1e5                     // x變成10
    fmt.Println("xBig:", xBig()) // 現(xiàn)在是false

    // 除此之外幢踏，函數(shù)體可以在其他函數(shù)中定義并調(diào)用髓需，
    // 滿足下列條件時，也可以作為參數(shù)傳遞給其他函數(shù)：
    //   a) 定義的函數(shù)被立即調(diào)用
    //   b) 函數(shù)返回值符合調(diào)用者對類型的要求
    fmt.Println("兩數(shù)相加乘二: ",
        func(a, b int) int {
            return (a + b) * 2
        }(10, 2)) // Called with args 10 and 2
    // => Add + double two numbers: 24

    // 當你需要goto的時候房蝉，你會愛死它的授账！
    goto love
love:

    learnFunctionFactory() // 返回函數(shù)的函數(shù)多棒啊
    learnDefer()      // 對defer關(guān)鍵字的簡單介紹
    learnInterfaces() // 好東西來了枯跑！
}

func learnFunctionFactory() {
    // 空行分割的兩個寫法是相同的，不過第二個寫法比較實用
    fmt.Println(sentenceFactory("原諒")("當然選擇", "她白热！"))

    d := sentenceFactory("原諒")
    fmt.Println(d("當然選擇", "她敛助！"))
    fmt.Println(d("你怎么可以", "她？"))
}

// Decorator在一些語言中很常見屋确，在go語言中纳击，
// 接受參數(shù)作為其定義的一部分的函數(shù)是修飾符的替代品
func sentenceFactory(mystring string) func(before, after string) string {
    return func(before, after string) string {
        return fmt.Sprintf("%s %s %s", before, mystring, after) // new string
    }
}

func learnDefer() (ok bool) {
    // defer表達式在函數(shù)返回的前一刻執(zhí)行
    defer fmt.Println("defer表達式執(zhí)行順序為后進先出（LIFO）")
    defer fmt.Println("\n這句話比上句話先輸出，因為")
    // 關(guān)于defer的用法攻臀，例如用defer關(guān)閉一個文件焕数，
    // 就可以讓關(guān)閉操作與打開操作的代碼更近一些
    return true
}

// 定義Stringer為一個接口類型，有一個方法String
type Stringer interface {
    String() string
}

// 定義pair為一個結(jié)構(gòu)體刨啸，有x和y兩個int型變量堡赔。
type pair struct {
    x, y int
}

// 定義pair類型的方法，實現(xiàn)Stringer接口设联。
func (p pair) String() string { // p被叫做“接收器”
    // Sprintf是fmt包中的另一個公有函數(shù)善已。
    // 用 . 調(diào)用p中的元素。
    return fmt.Sprintf("(%d, %d)", p.x, p.y)
}

func learnInterfaces() {
    // 花括號用來定義結(jié)構(gòu)體變量离例，:=在這里將一個結(jié)構(gòu)體變量賦值給p换团。
    p := pair{3, 4}
    fmt.Println(p.String()) // 調(diào)用pair類型p的String方法
    var i Stringer          // 聲明i為Stringer接口類型
    i = p                   // 有效！因為p實現(xiàn)了Stringer接口（類似java中的塑型）
    // 調(diào)用i的String方法宫蛆，輸出和上面一樣
    fmt.Println(i.String())

    // fmt包中的Println函數(shù)向?qū)ο笠鼈兊膕tring輸出艘包，實現(xiàn)了String方法就可以這樣使用了。
    // （類似java中的序列化）
    fmt.Println(p) // 輸出和上面一樣耀盗，自動調(diào)用String函數(shù)想虎。
    fmt.Println(i) // 輸出和上面一樣。

    learnVariadicParams("great", "learning", "here!")
}

// 有變長參數(shù)列表的函數(shù)
func learnVariadicParams(myStrings ...interface{}) {
    // 枚舉變長參數(shù)列表的每個參數(shù)值
    // 下劃線在這里用來拋棄枚舉時返回的數(shù)組索引值
    for _, param := range myStrings {
        fmt.Println("param:", param)
    }

    // 將可變參數(shù)列表作為其他函數(shù)的參數(shù)列表
    fmt.Println("params:", fmt.Sprintln(myStrings...))

    learnErrorHandling()
}

func learnErrorHandling() {
    // ", ok"用來判斷有沒有正常工作
    m := map[int]string{3: "three", 4: "four"}
    if x, ok := m[1]; !ok { // ok 為false叛拷，因為m中沒有1
        fmt.Println("別找了真沒有")
    } else {
        fmt.Print(x) // 如果x在map中的話舌厨，x就是那個值嘍。
    }
    // 錯誤可不只是ok胡诗，它還可以給出關(guān)于問題的更多細節(jié)邓线。
    if _, err := strconv.Atoi("non-int"); err != nil { // _ discards value
        // 輸出"strconv.ParseInt: parsing "non-int": invalid syntax"
        fmt.Println(err)
    }
    // 待會再說接口吧。同時煌恢，
    learnConcurrency()
}

// c是channel類型骇陈，一個并發(fā)安全的通信對象。
func inc(i int, c chan int) {
    c <- i + 1 // <-把右邊的發(fā)送到左邊的channel瑰抵。
}

// 我們將用inc函數(shù)來并發(fā)地增加一些數(shù)字你雌。
func learnConcurrency() {
    // 用make來聲明一個slice，make會分配和初始化slice，map和channel婿崭。
    c := make(chan int)
    // 用go關(guān)鍵字開始三個并發(fā)的goroutine拨拓，如果機器支持的話，還可能是并行執(zhí)行氓栈。
    // 三個都被發(fā)送到同一個channel渣磷。
    go inc(0, c) // go is a statement that starts a new goroutine.
    go inc(10, c)
    go inc(-805, c)
    // 從channel中讀取結(jié)果并打印。
    // 打印出什么東西是不可預(yù)知的授瘦。
    fmt.Println(<-c, <-c, <-c) // channel在右邊的時候醋界，<-是讀操作。

    cs := make(chan string)       // 操作string的channel
    cc := make(chan chan string)  // 操作channel的channel
    go func() { c <- 84 }()       // 開始一個goroutine來發(fā)送一個新的數(shù)字
    go func() { cs <- "wordy" }() // 發(fā)送給cs
    // Select類似于switch提完，但是每個case包括一個channel操作形纺。
    // 它隨機選擇一個準備好通訊的case。
    select {
    case i := <-c: // 從channel接收的值可以賦給其他變量
        fmt.Println("這是……", i)
    case <-cs: // 或者直接丟棄
        fmt.Println("這是個字符串徒欣！")
    case <-cc: // 空的逐样，還沒作好通訊的準備
        fmt.Println("別瞎想")
    }
    // 上面c或者cs的值被取到，其中一個goroutine結(jié)束打肝，另外一個一直阻塞脂新。

    learnWebProgramming() // Go很適合web編程，我知道你也想學闯睹！
}

// http包中的一個簡單的函數(shù)就可以開啟web服務(wù)器戏羽。
func learnWebProgramming() {
    // ListenAndServe第一個參數(shù)指定了監(jiān)聽端口担神，第二個參數(shù)是一個接口楼吃，特定是http.Handler。
    go func() {
        err := http.ListenAndServe(":8080", pair{})
        fmt.Println(err) // 不要無視錯誤妄讯。
    }()

    requestServer()
}

// 使pair實現(xiàn)http.Handler接口的ServeHTTP方法孩锡。
func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 使用http.ResponseWriter返回數(shù)據(jù)
    w.Write([]byte("Y分鐘golang速成!"))
}

func requestServer() {
    resp, err := http.Get("http://localhost:8080")
    fmt.Println(err)
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf("\n服務(wù)器消息： `%s`", string(body))
}

更進一步

關(guān)于Go的一切你都可以在Go官方網(wǎng)站找到。
在那里你可以獲得教程參考亥贸，在線試用躬窜，和更多的資料。
在簡單的嘗試過后炕置，在官方文檔那里你會得到你所需要的所有資料荣挨、關(guān)于編寫代碼的規(guī)范、庫和命令行工具的文檔與Go的版本歷史朴摊。

強烈推薦閱讀語言定義部分默垄，很簡單而且很簡潔！（趕時髦Ｉ醺佟）

你還可以前往Go在線體驗中心進口锭，在瀏覽器里修改并運行這些代碼，一定要試一試哦介杆！你可以將https://play.golang.org當作一個REPL鹃操，在那里體驗語言特性或運行自己的代碼韭寸，連環(huán)境都不用配！

學習Go還要閱讀Go標準庫的源代碼荆隘，全部文檔化了恩伺，可讀性非常好，可以學到go椰拒，go style和go idioms莫其。在文檔中點擊函數(shù)名，源代碼就出來了耸三！

Go by example也是一個學習的好地方乱陡。

Go Mobile添加了對移動平臺的支持（Android and iOS）。你可以完全用go語言來創(chuàng)造一個app或編寫一個可以從Java或Obj-C調(diào)用的函數(shù)庫仪壮，敬請參考Go Mobile page憨颠。