一文速览 Go 语法（长文预警）

// 单行注释
/* 多行
注释 
*/

package main            // 每一个源文件以包名开始，main 包比较特殊，用于声明一个可执行文件而不是库

import (        // import 语句声明了当前文件引用的包
    "fmt"       // 一个 Go 语言的标准包
    "io/ioutil" // 这个包实现了一些 IO 操作
    m "math"    // Math 包，别名为 m
    "net/http"  // 网络服务包
    "os"        // 系统操作函数，比如文件的读写
    "strconv"   // 字符串转化
)

// 函数定义，main() 函数比较特殊，是整个程序执行的入口。
// 函数使用 {} 包住函数体。
func main() {

    // 使用 fmt 包提供的函数打印字符串。
    fmt.Println("Hello world!")

    // 调用当前包里的另一个函数。
    beyondHello()
}


// 函数可以在 () 里带参数，如果没有参数，() 也是必须的。 
func beyondHello() {
    var x int // 变量声明，变量在使用之前必须声明
    x = 3     // 变量赋值

    y := 4    // 短变量声明，编译器自动推断变量的类型
    sum, prod := learnMultiple(x, y)        // 函数可以有多个返回值
    fmt.Println("sum:", sum, "prod:", prod) // 打印字符
    learnTypes()                            // 函数调用
}


/*
函数可以带参数，且可以有多个返回值，比如这里的 `x`, `y` 是参数，`sum`, `prod` 是返回值，注意 `sum`, `prod` 的类型是 int。
*/
func learnMultiple(x, y int) (sum, prod int) {
    return x + y, x * y // Return two values.
}

// 一些内置类型和字面量
func learnTypes() {
   
    str := "Learn Go!" // 字符串类型

    s2 := `A "raw" string literal
can include line breaks.` // 同样是字符串类型

    // 非 ASCII 字符，Go 使用 UTF-8 编码
    g := 'Σ' // rune 类型，int32 的别称，存储 unicode 码点

    f := 3.14195 // float64
    c := 3 + 4i  // complex128 复数类型

    // var 关键字用于变量初始化
    var u uint = 7 // Unsigned 无符号整型
    var pi float32 = 22. / 7  // float32 类型

    // 字符转化
    n := byte('\n') // byte 是 uint8 的别名

    // 数组的大小在编译是已经确定
    var a4 [4]int           // 大小为 4 的数组，元素类型为 int，初始值都是 0
    a5 := [...]int{3, 1, 5, 10, 100} // 数组大小固定的数组，大小为 5，元素值分别是 3, 1, 5, 10, and 100

    // 数组具有值语义 
    a4_cpy := a4            // a4_cpy 是 a4 的副本
    a4_cpy[0] = 25          // 只有 a4_cpy 改变了，a4 保持不变
    fmt.Println(a4_cpy[0] == a4[0]) // false

    // 切片的大小是动态变化的，数组和切片各有优点，但是大多数情况下使用切片比较多
    s3 := []int{4, 5, 9}    // 与 a5 对比下，s3 没有省略号
    s4 := make([]int, 4)    // 切片大小为 4，元素类型为 int，初始值都为 0
    var d2 [][]float64      // 仅仅是声明，也没有分配内存
    bs := []byte("a slice") // 类型转换

    // 切片，与 map、channel 一样都是引用语义
    s3_cpy := s3            // s3_cpy 和 s3 都指向同一个切片的底层数组
    s3_cpy[0] = 0           // 底层数组发生改变
    fmt.Println(s3_cpy[0] == s3[0]) // true 

    // 切片的大小是动态的，它的长度可以按需增长
    // 可以使用内置函数 append() 向切片的末尾添加元素，第一个参数是待增加的切片
    s := []int{1, 2, 3}     // s 是大小为 3 的切片
    s = append(s, 4, 5, 6)  // 增加 3 个元素，切片的大小变为 6
    fmt.Println(s)          // 更新后的切片变为 [1 2 3 4 5 6]

    // 除了像上面一样使用元素列表给切片添加元素，使用 ... 操作符给切片添加元素，就像下面这样
    s = append(s, []int{7, 8, 9}...) // 第二个参数是切片字面量
    fmt.Println(s)  // 更新后的切片: [1 2 3 4 5 6 7 8 9]

    p, q := learnMemory() // p, q 声明为 *int 类型的指针
    fmt.Println(*p, *q)   // 打印 p、q 指针指向的内存存储的值

    // map 是动态可增长关联数组，和其他语言中的 hash 或者字典很相似
    m := map[string]int{"three": 3, "four": 4}
    m["one"] = 1

    // Go语言里面，未使用的变量编译的时候是会报错的，但是可以使用下划线 _ 忽略，以免报错
    _, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a5, s4, bs、

    // 通常的使用方法是用它来忽略掉函数返回值
    // 比如，你可以忽略 os.Create 的错误返回值，认为 file 总是可以创建成功
    file, _ := os.Create("output.txt")
    fmt.Fprint(file, "This is how you write to a file, by the way")
    file.Close()

    fmt.Println(s, c, a4, s3, d2, m)   // 输出变量

    learnFlowControl() // 学习控制语句
}

// 不像其他语言，Go 语言里函数的返回值是可以命名的
// 函数声明过程中，为返回类型指定名称，我们就可以在函数中直接返回而不用指定变量
func learnNamedReturns(x, y int) (z int) {
    z = x * y
    return //  相当于 return z    这里是隐式的，返回值 z 定义过
}

// Go 支持垃圾回收
// Go 有指针但不支持指针运算
func learnMemory() (p, q *int) {
    // 命名返回值都是 *int 类型的指针
    p = new(int) // new() 是为变量分配内存的函数

    s := make([]int, 20) // 给 20 个 int 型分配一块内存
    s[3] = 7             // 将索引为 3 的元素赋值为 7
    r := -2              // 分配一个本地变量
    return &s[3], &r     // & 取值操作
}

// 通过 math 库的别名调用方法（别名见程序 imports 部分）
func expensiveComputation() float64 {
    return m.Exp(10)
}

func learnFlowControl() {
    // if 语句块使用 {} 括起来，但是 if 后面的判断部分不需要 () 中括号
    if true {
        fmt.Println("told ya")
    }
    // 用 go fmt 命令可以帮助我们格式化代码
    if false {
        // Pout.
    } else {
        // Gloat.
    }
    // 如果 if 语句分支过多，推荐使用 switch 语句
    x := 42.0
    switch x {
    case 0:
    case 1, 2: // 可以匹配多个值
    case 42:  // 执行到这里，switch 语句就算是结束了；如果还想执行下一个 case 语句，可以使用 fall through
    case 43:
        // 不会执行到这里
    default:  // Default 语句是可选
    }

    // Type switch 可以对接口变量的值类型做判断
    var data interface{}
    data = ""
    switch c := data.(type) {
    case string:
        fmt.Println(c, "is a string")
    case int64:
        fmt.Printf("%d is an int64\n", c)
    default:    // 其他情况
    }

    // 与 if 一样，for 语句也不用括号
    // if 和 for 语句里面声明的变量都属于局部变量
    for x := 0; x < 3; x++ { // ++ 自增
        fmt.Println("iteration", x)
    }
    // x == 42 仍然是 42

    // for 是 Go 语言唯一的循环语句，但它有其他不同形式
    for { // Infinite loop.
        break    // Just kidding.
        continue // Unreached.
    }

    // 可以使用 for-range 迭代 array、slice、字符串、map 或者 channel
    // for-range 返回一个值(channel)或者两个值(array、slice、string 和 map)
    for key, value := range map[string]int{"one": 1, "two": 2, "three": 3} {
        fmt.Printf("key=%s, value=%d\n", key, value)    // 输出键值
    }
    // 可以使用下划线 _ 忽略键，当然也可以用来忽略值，不过值一般都是我们需要的
    for _, name := range []string{"Bob", "Bill", "Joe"} {
        fmt.Printf("Hello, %s\n", name)
    }

    // 和 for 一样，if 语句中的 := 表示声明和赋值
    // 先计算得到 y，再测试 y 是否大于 x
    if y := expensiveComputation(); y > x {
        x = y
    }
    // 函数字面量属于闭包
    xBig := func() bool {
        return x > 10000 // 这里的 x 是上面 switch 语句里声明的 x 的引用
    }
    x = 99999
    fmt.Println("xBig:", xBig()) // true
    x = 1.3e3                    // x == 1300
    fmt.Println("xBig:", xBig()) // false now.

    // 除此之外，函数字面量可以定义并作为参数调用，只要符合以下条件：
    // a) 函数字面量被立即调用； 
    // b) 函数返回值符合作为参数的条件；
    fmt.Println("Add + double two numbers: ",
        func(a, b int) int {
            return (a + b) * 2
        }(10, 2)) // 调用函数，参数是 10、2
    // 结果是 24

    goto love     // goto 语句
love:

    learnFunctionFactory() //  演示函数的返回值是函数
    learnDefer()      // defer 语句的简单使用
    learnInterfaces() // 接口的使用
}

func learnFunctionFactory() {
    // 下面这两种方式是一样的，不过第二种更常用
    fmt.Println(sentenceFactory("summer")("A beautiful", "day!"))

    d := sentenceFactory("summer")
    fmt.Println(d("A beautiful", "day!"))
    fmt.Println(d("A lazy", "afternoon!"))
}


// 装饰器在其他语言里面很常见，Go 语言里面可以这样实现，通过函数字面量接收参数的方式实现
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 语句会将待执行函数推送到一个 list 里，待调用函数返回时按照先进后出的顺序执行 list 里的函数
    defer fmt.Println("deferred statements execute in reverse (LIFO) order.")
    defer fmt.Println("\nThis line is being printed first because")

    // defer 常用在关闭一个文件等场景，比如在打开一个文件的下一行便调用 defer 关闭文件函数
    return true
}

// 定义 Stringer，是一个接口类型，包含一个 String() 方法
type Stringer interface {
    String() string
}

// Define pair as a struct with two fields, ints named x and y.
// 定义了一个结构体 pair，包含两个成员 x 和 y，都是 int 类型
type pair struct {
    x, y int
}

// 定义了一个 pair 类型的方法，pair 实现了接口 Stringer，因为它实现了接口里面定义的方法
func (p pair) String() string { // p 是接受者
    return fmt.Sprintf("(%d, %d)", p.x, p.y)   // Sprintf 是 fmt 包里面的一个公共方法；
}

func learnInterfaces() {
    p := pair{3, 4}   // 声明并初始化结构体变量 p
    fmt.Println(p.String()) // 调用 String 方法
    var i Stringer          // 声明一个 Stringer 接口类型的变量 i 
    i = p                   // 因为 pair 类型实现了接口 Stringer，所以可以将变量 p 赋值给接口变量 i
    fmt.Println(i.String()) // 通过变量 i 调用 String() 方法，与上面的输出相同

    // 如果类型定义了 String() 方法，调用 fmt 包里的函数输出时会自动调用类型的 String() 方法
    fmt.Println(p) // 输出与上面相同，Println() 会自动调用 String() 方法
    fmt.Println(i) // 输出与上面相同

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

// 函数允许可变参数，即参数的个数可变
func learnVariadicParams(myStrings ...interface{}) {
    // 使用 for range 迭代可变参数
    // 使用 _ 下划线忽略数组的索引
    for _, param := range myStrings {
        fmt.Println("param:", param)
    }

    // 将可变参数值作为可变参数传递
    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，因为 map 不包含键 1
        fmt.Println("no one there")
    } else {
        fmt.Print(x) // x 是值
    }
    // 一个错误类型的值还可以包含更多的错误信息
    if _, err := strconv.Atoi("non-int"); err != nil { // _ 下划线忽略返回值
        fmt.Println(err)   // 输出 'strconv.ParseInt: parsing "non-int": invalid syntax'
    }

    learnConcurrency()
}

// c 是 channel 变量，一个并发安全的类型
func inc(i int, c chan int) {
    c <- i + 1      // <- 是发送操作
}

// 我们将使用 inc() 函数实现并发自增操作
func learnConcurrency() {
    // 内置的 make() 函数用于初始化 slice、map 和 channel
    c := make(chan int)

    // 开启 3 个协程并发执行，3个数字会发送到同一个 channel
    go inc(0, c)        // go 关键字用于开启新的协程
    go inc(10, c)
    go inc(-805, c)

    // 3 次读取 channel 并打印，但不知道读取的顺序是怎么样的
    fmt.Println(<-c, <-c, <-c) // <- 是读取操作

    cs := make(chan string)       // 定义一个 channel，处理 string 类型
    ccs := make(chan chan string) // 定义一个 channel，类型是 channel string
    go func() { c <- 84 }()       // 开启一个协程，发送值 84
    go func() { cs <- "wordy" }() // 开启一个协程，发送字符串 wordy

    // Select 的语法类似于 switch，但 Select 是用于 channel 操作，会随机选择一个准备好的 channel 执行
    select {
    case i := <-c:                  // 读取到的值赋给变量 i
        fmt.Printf("it's a %T", i)
    case <-cs:                      //  忽略读取的值
        fmt.Println("it's a string")
    case <-ccs:                     // ccs 是一个空的 channel，永远也不会执行到这里
        fmt.Println("didn't happen.")
    }

    // 执行到这的话，将会从 c 或 cs 读取到值，对应的 goroutine 将完成并自动退出，另一个 goroutine 将会阻塞

    learnWebProgramming()
}

// 调用 http.ListenAndServe 开启一个 web server
func learnWebProgramming() {
    go func() {
        err := http.ListenAndServe(":8080", pair{})   // 参数 1 是监听的 TCP 地址，参数 2 是 http.Handler 类型的接口变量
        fmt.Println(err) // 输出错误
    }()

    requestServer()
}


// pair 类型实现接口 http.Handler 里定义的方法 ServeHTTP()
func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("You learned Go in Y minutes!"))   // 传输数据
}

func requestServer() {
    resp, err := http.Get("http://localhost:8080")
    fmt.Println(err)
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Printf("\nWebserver said: `%s`", string(body))
}

---------------------------我是分割线--------------------------------

你好，我是 Seekload，你情商，也可以叫我四哥。

前 PHPer，自学并成功上岸 Go 语言，乐于分享 Go 相关知识，欢迎加 VX：seekload01 学习交流，拉你进学习群，学习氛围好，并为你准备了以下资料：

1、最新版 Go 知识图谱及学习、成长路线图；
2、入门、进阶 Go 语言必看书籍；
3、价值 5000 大洋的视频资料，内含实战项目（不外传）；

另外还有四哥精编的 《Go语言面试题》(pdf)，含解析。