Go语言快速入门

package main

import "fmt"

func main() {
    fmt.Println("Hello World !")
}

package main

import "fmt"

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

module hello

go 1.14

require github.com/gogf/gf v1.15.3

go get -u   (没有参数)下载、更新当前包下 直接和间接的依赖的最新版本，并不会更新整个项目。
go get -u ./...  下载、更新当前项目根目录下直接或间接的依赖的最新版本，但是会排除测试包的依赖；例如将v1.2.1更新为v2.0.1
go get -u=patch ./...  下载、更新当前项目根目录下直接或间接的依赖的大版本的最新小版本，例如，将v1.2.1更新为v1.2.5
go get -u -t ./...   和  go get -u ./...  相似，但是会更新测试包的依赖
go get -d   只执行下载动作，而不执行安装动作；不再支持go get -m ,使用go get -d替代。

go list -m all   列出当前项目build时需要使用直接或间接依赖的版本。 
go list -u -m all   不仅会列出当前使用模块的版本，还会列出当前使用模块的最新小版本和最新版本。 

go mod tidy   删除不必要的依赖，添加OS, architecture, and build tags组合所需要的依赖。 
go mod vendor   可选步骤，用于建立vendor文件夹，用于vendor机制的包管理
go mod init   将go项目初始化成module-mode，使用go modules进行依赖管理。
go mod verify   校验go.sum记录的依赖信息是否正确

module hello

go 1.14

require (
    github.com/gogf/gf v1.15.3
)

package main

import (
   "fmt"
   "github.com/gogf/gf"
   "github.com/gogf/gf/crypto/gmd5"
)

func main(){
   fmt.Println("hello world!")
   fmt.Println(gf.VERSION)
   fmt.Println(gmd5.EncryptString("123456"))
}

hello world!
v1.15.3
e10adc3949ba59abbe56e057f20f883e <nil>

Process finished with exit code 0

package main

import (
    "fmt"
    "math"
    "time"
)

func main() {
    // hello world
    /**
    hello world
    */
    fmt.Println("hello world")

    fmt.Println("##################### values")
    values()

    fmt.Println("##################### variables")
    variables()

    fmt.Println("##################### constants")
    constants()

    fmt.Println("##################### forFunc")
    forFunc()

    fmt.Println("##################### ifElse")
    ifElse()

    fmt.Println("##################### switchFunc")
    switchFunc()
}

// 值
func values() {
    // 字符串拼接用 +
    fmt.Println("hello " + "world " + "!")
    // 整数和浮点数
    fmt.Println("1+2 =", 1+2)
    fmt.Println("11-1 =", 11-1)
    fmt.Println("99*99 =", 99*99)
    fmt.Println("8.0/3.0 =", 8.0/3.0)
    // 布尔型
    fmt.Println(true && false)
    fmt.Println(true || false)
    fmt.Println(!true)
}

// 变量
func variables() {
    // var 声明 1 个或者多个变量。
    var a string = "hello"
    fmt.Println(a)
    var b, c int = 3, 5
    fmt.Println(b, c)

    // 会自动推断已经初始化的变量类型。
    var d = true
    fmt.Println(d)

    // 声明变量且 初始化为0
    var e int
    fmt.Println(e)

    // := 简写会自动推断类型，只能用在初始化
    f := "short"
    fmt.Println(f)
}

// 常量
// 全局常量
const con = "const"

func constants() {
    fmt.Println(con)

    // const 语句可以出现在任何 var 语句可以出现的地方
    const num = 500 * 500 * 500
    // 常数表达式可以执行任意精度的运算
    const num2 = 4e21 / num
    fmt.Println(num2)
    // 数值型常量是没有确定的类型的，直到它们被给定了一个类型，比如说一次显示的类型转化。
    fmt.Println(int64(num2))

    // 当上下文需要时，一个数可以被给定一个类型，比如变量赋值或者函数调用。
    // 举个例子，这里的 math.Sin函数需要一个 float64 的参数。
    fmt.Println(math.Sin(num))
}

// For循环
func forFunc() {
    // 最常用的方式，带单个循环条件。
    i := 1
    for i <= 4 {
        fmt.Println(i)
        i = i + 1
    }

    // 经典的初始化/条件/后续形式 for 循环。
    for j := 6; j <= 8; j++ {
        fmt.Println(j)
    }

    // 不带条件的 for 循环将一直执行，直到在循环体内使用了 break 或者 return 来跳出循环。
    for {
        fmt.Println("for...")
        break
    }

    for n := 0; n <= 7; n++ {
        if n%2 == 0 {
            continue
        }
        fmt.Println(n)
    }
}

// if/else
func ifElse() {
    if 9%2 == 0 {
        fmt.Println("9 is even")
    } else {
        fmt.Println("9 is odd")
    }

    // 你可以不要 else 只用 if 语句。
    if 12%4 == 0 {
        fmt.Println("12 is divisible by 4")
    }

    // 在条件语句之前可以有一个语句；
    // 任何在这里声明的变量都可以在所有的条件分支中使用。
    if num := 7; num < 0 {
        fmt.Println(num, "正数")
    } else if num < 10 {
        fmt.Println(num, "小于10")
    } else {
        fmt.Println(num, "其他")
    }

    // 注意，在 Go 中，你可以不适用圆括号，但是花括号是需要的。
    // Go 里没有三目运算符，
    // 所以即使你只需要基本的条件判断，你仍需要使用完整的 if 语句。
}

// 分支结构
func switchFunc() {
    i := 2
    switch i {
        case 1:
            fmt.Println("1")
        case 2:
            fmt.Println("2")
        case 3:
            fmt.Println("3")
    }

    // 在一个 case 语句中，你可以使用逗号来分隔多个表达式。
    // 在这个例子中，我们很好的使用了可选的default 分支。
    switch time.Now().Weekday() {
        case time.Saturday, time.Sunday:
            fmt.Println("星期天")
        default:
            fmt.Println("工作日")
    }

    // 不带表达式的 switch 是实现 if/else 逻辑的另一种方式。
    //  这里展示了 case 表达式是如何使用非常量的。
    t := time.Now()
    switch {
        case t.Hour() < 12:
            fmt.Println("12点前")
        default:
            fmt.Println("12点后，包含12点")
    }

    // 这里是一个函数变量
    whatAmI := func(i interface{}) {
        switch t := i.(type) {
            case bool:
                fmt.Println("bool")
            case int:
                fmt.Println("int")
            default:
                fmt.Printf("什么类型 %T\n", t)
        }
    }
    whatAmI(true)
    whatAmI(1)
    whatAmI("嘿")
}

package main

import "fmt"

func main() {
    // hello world
    fmt.Println("hello world")

    fmt.Println("##################### arrays")
    arrays()

    fmt.Println("##################### slice")
    slice()

    fmt.Println("##################### mapFunc")
    mapFunc()

    fmt.Println("##################### rangeFunc")
    rangeFunc()
}

// 数组
func arrays() {
    // 这里我们创建了一个数组 test1 来存放刚好 6 个 int。
    // 元素的类型和长度都是数组类型的一部分。
    // 数组默认是零值的，对于 int 数组来说也就是 0。
    var test1 [6]int
    fmt.Println("内容:", test1)
    // 我们可以使用 array[index] = value 语法来设置数组指定位置的值，或者用 array[index] 得到值。
    test1[4] = 100
    fmt.Println("设置:", test1)
    fmt.Println("获取:", test1[4])
    // 使用内置函数 len 返回数组的长度
    fmt.Println("长度:", len(test1))

    // 使用这个语法在一行内初始化一个数组
    test2 := [6]int{1, 2, 3, 4, 5, 6}
    fmt.Println("数据:", test2)

    // 数组的存储类型是单一的，但是你可以组合这些数据来构造多维的数据结构。
    var twoTest [3][4]int
    for i := 0; i < 3; i++ {
        for j := 0; j < 4; j++ {
            twoTest[i][j] = i + j
        }
    }
    // 注意，在使用 fmt.Println 来打印数组的时候，会使用[v1 v2 v3 ...] 的格式显示
    fmt.Println("二维: ", twoTest)
}

// 切片
func slice() {
    // Slice 是 Go 中一个关键的数据类型，是一个比数组更加强大的序列接口

    // 不像数组，slice 的类型仅由它所包含的元素决定（不像数组中还需要元素的个数）。
    // 要创建一个长度非零的空slice，需要使用内建的方法 make。
    // 这里我们创建了一个长度为3的 string 类型 slice（初始化为零值）。
    test1 := make([]string, 3)
    fmt.Println("数据:", test1)
    // 我们可以和数组一样设置和得到值
    test1[0] = "A"
    test1[1] = "C"
    test1[2] = "B"
    fmt.Println("数据:", test1)
    fmt.Println("获取:", test1[2])
    // 如你所料，len 返回 slice 的长度
    fmt.Println("长度:", len(test1))

    // 作为基本操作的补充，slice 支持比数组更多的操作。
    // 其中一个是内建的 append，它返回一个包含了一个或者多个新值的 slice。
    // 注意我们接受返回由 append返回的新的 slice 值。
    test1 = append(test1, "D")
    test1 = append(test1, "E", "F")
    fmt.Println("追加:", test1)

    // Slice 也可以被 copy。这里我们创建一个空的和 test1 有相同长度的 slice test2，并且将 test1 复制给 test2。
    test2 := make([]string, len(test1))
    copy(test2, test1)
    fmt.Println("拷贝:", test2)
    // Slice 支持通过 slice[low:high] 语法进行“切片”操作。例如，这里得到一个包含元素 test1[2], test1[3],test1[4] 的 slice。
    l := test1[2:5]
    fmt.Println("切片1:", l)
    // 这个 slice 从 test1[0] 到（但是不包含）test1[5]。
    l = test1[:5]
    fmt.Println("切片2:", l)
    // 这个 slice 从（包含）test1[2] 到 slice 的后一个值。
    l = test1[2:]
    fmt.Println("切片3:", l)
    // 我们可以在一行代码中声明并初始化一个 slice 变量。指定长度就是数组，没指定长度就是切片。
    t := []string{"g", "h", "i"}
    fmt.Println("数据:", t)

    // Slice 可以组成多维数据结构。内部的 slice 长度可以不同，这和多位数组不同。
    twoTest := make([][]int, 3)
    for i := 0; i < 3; i++ {
        innerLen := i + 1
        twoTest[i] = make([]int, innerLen)
        for j := 0; j < innerLen; j++ {
            twoTest[i][j] = i + j
        }
    }
    // 注意，slice 和数组不同，虽然它们通过 fmt.Println 输出差不多。
    fmt.Println("二维: ", twoTest)
}

// 键值对 key/value
func mapFunc() {
    // 要创建一个空 map，需要使用内建的 make: make(map[key-type]val-type).
    map1 := make(map[string]int)
    // 使用典型的 make[key] = val 语法来设置键值对。
    map1["k1"] = 7
    map1["k2"] = 13
    // 使用例如 Println 来打印一个 map 将会输出所有的键值对。
    fmt.Println("数据:", map1)
    // 使用 name[key] 来获取一个键的值
    v1 := map1["k1"]
    fmt.Println("值: ", v1)
    // 当对一个 map 调用内建的 len 时，返回的是键值对数目
    fmt.Println("长度:", len(map1))
    // 内建的 delete 可以从一个 map 中移除键值对
    delete(map1, "k2")
    fmt.Println("数据:", map1)
    // 当从一个 map 中取值时，可选的第二返回值指示这个键是在这个 map 中。
    // 这可以用来消除键不存在和键有零值，像 0 或者 "" 而产生的歧义。
    _, prs := map1["k2"]
    fmt.Println("是否存在:", prs)
    // 你也可以通过这个语法在同一行申明和初始化一个新的map。
    map2 := map[string]int{"F": 1, "B": 2}
    // 注意一个 map 在使用 fmt.Println 打印的时候，是以 map[k:v k:v]的格式输出的。
    fmt.Println("数据:", map2)
}

// Range 遍历
func rangeFunc() {
    // 这里我们使用 range 来统计一个 slice 的元素个数。数组也可以采用这种方法。
    array1 := []int{2, 3, 4}
    sum := 0
    for _, num := range array1 {
        sum += num
    }
    fmt.Println("求和:", sum)

    // range 在数组和 slice 中都同样提供每个项的索引和值。
    // 上面我们不需要索引，所以我们使用 空值定义符_ 来忽略它。
    // 有时候我们实际上是需要这个索引的。
    for i, num := range array1 {
        if num == 3 {
            fmt.Println("索引:", i)
        }
    }

    // range 在 map 中迭代键值对。
    map1 := map[string]string{"A": "苹果", "B": "香蕉"}
    for k, v := range map1 {
        fmt.Printf("%s -> %s\n", k, v)
    }
    for k := range map1 {
        fmt.Println("键:", k)
    }

    // range 在字符串中迭代 unicode 编码。
    // 第一个返回值是rune 的起始字节位置，然后第二个是 rune 自己。
    for i, c := range "abA" {
        fmt.Println(i, c)
    }
}

package main

import "fmt"

func main() {
    // hello world
    fmt.Println("hello world")

    // 1. 加法
    res := plus(1, 2)
    fmt.Println("1+2 =", res)
    res = plusPlus(1, 2, 3)
    fmt.Println("1+2+3 =", res)

    // 2. 多值返回
    // 这里我们通过多赋值 操作来使用这两个不同的返回值。
    a, b := vals()
    fmt.Println(a)
    fmt.Println(b)
    // 如果你仅仅想返回值的一部分的话，你可以使用空白定义符 _。
    _, c := vals()
    fmt.Println(c)

    // 3. 可变参数
    // 变参函数使用常规的调用方式，除了参数比较特殊，变参函数的参数本质上是一个切片，所以可以直接传切片。
    sum(1, 2)
    sum(1, 2, 3)
    // 如果你的 slice 已经有了多个值，想把它们作为变参使用，你要这样调用 func(slice...)。
    nums := []int{1, 2, 3, 4}
    sum(nums...)

    // 4. 闭包
    // 我们调用 intSeq 函数，将返回值（也是一个函数）赋给nextInt。
    // 这个函数的值包含了自己的值 i，这样在每次调用 nextInt 时都会更新 i 的值。
    nextInt := intSeq()
    // 通过多次调用 nextInt 来看看闭包的效果。
    fmt.Println(nextInt())
    fmt.Println(nextInt())
    fmt.Println(nextInt())
    // 为了确认这个状态对于这个特定的函数是唯一的，我们重新创建并测试一下。
    newInts := intSeq()
    fmt.Println(newInts())

    // 5. 递归
    fmt.Println(fact(7))
}

// 函数
// 这里是一个函数，接受两个 int 并且以 int 返回它们的和
func plus(a int, b int) int {
    // Go 需要明确的返回值，例如，它不会自动返回最后一个表达式的值
    return a + b
}

func plusPlus(a, b, c int) int {
    return a + b + c
}

// 多返回值函数
// (int, int) 在这个函数中标志着这个函数返回 2 个 int。
func vals() (int, int) {
    return 3, 7
}

// 变参函数，nums本质上是一个切片
func sum(nums ...int) {
    fmt.Print(nums, " ")
    total := 0
    for _, num := range nums {
        total += num
    }
    fmt.Println(total)
}

// 闭包
// 这个 intSeq 函数返回另一个在 intSeq 函数体内定义的匿名函数。
// 这个返回的函数使用闭包的方式 隐藏 变量 i。
func intSeq() func() int {
    i := 0
    return func() int {
        i += 1
        return i
    }
}

// 递归
// face 函数在到达 face(0) 前一直调用自身。
func fact(n int) int {
    if n == 0 {
        return 1
    }
    return n * fact(n-1)
}

var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 */

package main

import "fmt"

// 我们将通过两个函数：val 和 ptr 来比较指针和值类型的不同。
// val 有一个 int 型参数，所以使用值传递。
// val 将从调用它的那个函数中得到一个 val1 形参的拷贝。
func val(val1 int) {
    val1 = 0
}

// ptr 有一和上面不同的 *int 参数，意味着它用了一个 int指针。
// 函数体内的 *iptr 接着解引用 这个指针，从它内存地址得到这个地址对应的当前值。
// 对一个解引用的指针赋值将会改变这个指针引用的真实地址的值。
func ptr(iptr *int) {
    *iptr = 0
}

func main() {
    test := 1
    fmt.Println("initial:", test)
    val(test)
    fmt.Println("val:", test)
    // 通过 &test 语法来取得 test 的内存地址，例如一个变量i 的指针。
    ptr(&test)
    fmt.Println("ptr:", test)
    // 指针也是可以被打印的。
    fmt.Println("pointer:", &test)
    // val 在 main 函数中不能改变 test 的值，但是ptr 可以，因为它有一个这个变量的内存地址的引用。
    fmt.Println("pointer:", *&test)
}

package main

import "fmt"

// 这里的 person 结构体包含了 name 和 age 两个字段。
type person struct {
    name string
    age  int
}

func main() {
    // 使用这个语法创建了一个新的结构体元素。
    fmt.Println(person{"Bob", 20})
    // 你可以在初始化一个结构体元素时指定字段名字。
    fmt.Println(person{name: "Alice", age: 30})
    // 省略的字段将被初始化为零值。
    fmt.Println(person{name: "Fred"})
    // & 前缀生成一个结构体指针。
    fmt.Println(&person{name: "Ann", age: 40})
    // 使用点来访问结构体字段。
    s := person{name: "Sean", age: 50}
    fmt.Println(s.name)
    // 也可以对结构体指针使用. - 指针会被自动解引用。
    sp := &s
    fmt.Println(sp.age)
    // 结构体是可变的。
    sp.age = 51
    fmt.Println(sp.age)
}

package main

import "fmt"

type rectangle struct {
    width, height int
}

// 这里的 area 方法有一个接收器类型 rect
// 方法是建立在结构体指针上的，说明函数内可以改变结构体中的变量值，关于这一点，这里可以反复对比琢磨下
func (r *rectangle) area() int {
    r.width = 1
    return r.width * r.height
}

// 可以为值类型或者指针类型的接收器定义方法。这里是一个值类型接收器的例子。
func (r rectangle) perim() int {
    return 2*r.width + 2*r.height
}

func main() {
    r := rectangle{width: 10, height: 5}
    // 这里我们调用上面为结构体定义的两个方法。
    fmt.Println("area: ", r.area())
    fmt.Println("perim:", r.perim())
    // Go 自动处理方法调用时的值和指针之间的转化。
    // 你可以使用指针来调用方法来避免在方法调用时产生一个拷贝，或者让方法能够改变接受的数据。
    rp := &r
    fmt.Println("area: ", rp.area())
    fmt.Println("perim:", rp.perim())
}

package main

import "fmt"
import "math"

// 这里是一个几何体的基本接口。
type geometry interface {
    area() float64
    perim() float64
}

// 在我们的例子中，我们将让 rect 和 circle 实现这个接口
type rect struct {
    width, height float64
}
type circle struct {
    radius float64
}

// 要在 Go 中实现一个接口，我们只需要实现接口中的所有方法。
// 这里我们让 rect 实现了 geometry 接口。
func (r rect) area() float64 {
    return r.width * r.height
}
func (r rect) perim() float64 {
    return 2*r.width + 2*r.height
}

// circle 的实现。
func (c circle) area() float64 {
    return math.Pi * c.radius * c.radius
}
func (c circle) perim() float64 {
    return 2 * math.Pi * c.radius
}

// 如果一个变量的是接口类型，那么我们可以调用这个被命名的接口中的方法。
// 这里有一个一通用的 measure 函数，利用这个特性，它可以用在任何 geometry 上。
func measure(g geometry) {
    fmt.Println(g)
    fmt.Println(g.area())
    fmt.Println(g.perim())
}

func main() {
    r := rect{width: 3, height: 4}
    c := circle{radius: 5}
    // 结构体类型 circle 和 rect 都实现了 geometry接口，
    // 所以我们可以使用它们的实例作为 measure 的参数。
    measure(r)
    measure(c)
}

type error interface {
    Error() string
}

func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New("math: square root of negative number")
    }
    // 实现
}

package main

import "errors"
import "fmt"

// 按照惯例，错误通常是最后一个返回值并且是 error 类型，一个内建的接口。
func f1(arg int) (int, error) {
    // errors.New 构造一个使用给定的错误信息的基本error 值。
    if arg == 42 {
        return -1, errors.New("can't work with 42")
    }
    // 返回错误值为 nil 代表没有错误。
    return arg + 3, nil
}

// 通过实现 Error 方法来自定义 error 类型是可以的。
// 这里使用自定义错误类型来表示上面的参数错误。
type argError struct {
    arg  int
    prob string
}

func (e *argError) Error() string {
    return fmt.Sprintf("%d - %s", e.arg, e.prob)
}
// 指明返回 int 和 error 类型
func f2(arg int) (int, error) {
    if arg == 42 {
        // 在这个例子中，我们使用 &argError 语法来建立一个新的结构体，并提供了 arg 和 prob 这个两个字段的值。
        return -1, &argError{arg, "can't work with it"}
    }
    return arg + 3, nil
}
func main() {
    // 下面的两个循环测试了各个返回错误的函数。
    //  注意在 if行内的错误检查代码，在 Go 中是一个普遍的用法。
    for _, i := range []int{7, 42} {
        if r, e := f1(i); e != nil {
            fmt.Println("f1 失败:", e)
        } else {
            fmt.Println("f1 工作:", r)
        }
    }
    for _, i := range []int{7, 42} {
        if r, e := f2(i); e != nil {
            fmt.Println("f2 失败:", e)
        } else {
            fmt.Println("f2 工作:", r)
        }
    }
    // 你如果想在程序中使用一个自定义错误类型中的数据，你需要通过类型断言来得到这个错误类型的实例。
    _, e := f2(42)
    if ae, ok := e.(*argError); ok {
        fmt.Println(ae.arg)
        fmt.Println(ae.prob)
    }
}

package main

import (
    "fmt"
    "os"
)

func main() {
    // 我们将在这个网站中使用 panic 来检查预期外的错误。这个是唯一一个为 panic 准备的例子。
    panic("一个异常")

    // panic 的一个基本用法就是在一个函数返回了错误值，但是我们并不知道（或者不想）处理时终止运行。
    // 这里是一个在创建一个新文件时返回异常错误时的panic 用法。
    fmt.Println("继续")
    _, err := os.Create("/tmp/file")
    if err != nil {
        panic(err)
    }
    // 运行程序将会引起 panic，输出一个错误消息和 Go 运行时栈信息，并且返回一个非零的状态码。
}

package main

import "fmt"

func main() {
    // 这里我们对异常进行了捕获
    defer func() {
        if p := recover(); p != nil {
            err := fmt.Errorf("internal error: %v", p)
            if err != nil {
                fmt.Println(err)
            }
        }
    }()

    // 我们将在这个网站中使用 panic 来检查预期外的错误。这个是唯一一个为 panic 准备的例子。
    panic("一个异常")

}

package main

import "fmt"

func f(from string) {
    for i := 0; i < 3; i++ {
        fmt.Println(from, ":", i)
    }
}

func main() {
    // 假设我们有一个函数叫做 f(s)。
    // 我们使用一般的方式调并同时运行。
    f("direct")
    // 使用 go f(s) 在一个 Go 协程中调用这个函数。
    // 这个新的 Go 协程将会并行的执行这个函数调用。
    go f("goroutine")
    // 你也可以为匿名函数启动一个 Go 协程。
    go func(msg string) {
        fmt.Println(msg)
    }("going")

    // 现在这两个 Go 协程在独立的 Go 协程中异步的运行，所以我们需要等它们执行结束。
    // 这里的 Scanln 代码需要我们在程序退出前按下任意键结束。提前输入，直接结束，将看不到协程输出的结果。
    var input string
    fmt.Scanln(&input)
    fmt.Println("done")
    // 当我们运行这个程序时，将首先看到阻塞式调用的输出，然后是两个 Go 协程的交替输出。
    // 这种交替的情况表示 Go 运行时是以异步的方式运行协程的。
}

package main

import (
    "fmt"
)

// 通道 是连接多个 Go 协程的管道。
// 你可以从一个 Go 协程将值发送到通道，然后在别的 Go 协程中接收。
func main() {
    // 使用 make(chan val-type) 创建一个新的通道。
    // 通道类型就是他们需要传递值的类型。
    messages := make(chan string)
    // 使用 channel <- 语法 发送 一个新的值到通道中。
    // 这里我们在一个新的 Go 协程中发送 "ping" 到上面创建的messages 通道中。
    go func() {
        messages <- "ping"
    }()
    // 使用 <-channel 语法从通道中 接收 一个值。
    // 这里将接收我们在上面发送的 "ping" 消息并打印出来。
    msg := <-messages
    fmt.Println(msg)
    // 我们运行程序时，通过通道，消息 "ping" 成功的从一个 Go 协程传到另一个中。
    // 默认发送和接收操作是阻塞的，直到发送方和接收方都准备完毕。
    // 这个特性允许我们，不使用任何其它的同步操作，来在程序结尾等待消息 "ping"。
}

package main

import "fmt"

// 默认通道是 无缓冲 的，这意味着只有在对应的接收（<- chan）通道准备好接收时，才允许进行发送（chan <-）。
// 可缓存通道允许在没有对应接收方的情况下，缓存限定数量的值。
func main() {
    // 这里我们 make 了一个通道，最多允许缓存 2 个值。
    messages := make(chan string, 2)
    // 因为这个通道是有缓冲区的，即使没有一个对应的并发接收方，我们仍然可以发送这些值。
    messages <- "buffered"
    messages <- "channel"
    // 然后我们可以像前面一样接收这两个值。
    fmt.Println(<-messages)
    fmt.Println(<-messages)
}

package main

import "fmt"
import "time"

// 我们可以使用通道来同步 Go 协程间的执行状态。
// 这里是一个使用阻塞的接受方式来等待一个 Go 协程的运行结束。
func worker(done chan bool) {
    // 这是一个我们将要在 Go 协程中运行的函数。
    // done 通道将被用于通知其他 Go 协程这个函数已经工作完毕。
    fmt.Print("working...")
    time.Sleep(time.Second)
    fmt.Println("done")
    // 发送一个值来通知我们已经完工啦。
    done <- true
}
func main() {
    // 运行一个 worker Go协程，并给予用于通知的通道。
    done := make(chan bool, 1)
    go worker(done)
    // 程序将在接收到通道中 worker 发出的通知前一直阻塞。
    <-done
    // 如果你把 <- done 这行代码从程序中移除，程序甚至会在 worker还没开始运行时就结束了。
}

package main

import "fmt"

// 当使用通道作为函数的参数时，你可以指定这个通道是不是只用来发送或者接收值。
// 这个特性提升了程序的类型安全性。
func ping(pings chan <- string, msg string) {
    // ping 函数定义了一个只允许发送数据的通道。
    // 尝试使用这个通道来接收数据将会得到一个编译时错误。
    pings <- msg
}
func pong(pings <-chan string, pongs chan <- string) {
    // pong 函数允许通道（pings）来接收数据，另一通道（pongs）来发送数据。
    msg := <-pings
    pongs <- msg
}
func main() {
    pings := make(chan string, 1)
    pongs := make(chan string, 1)
    ping(pings, "passed message")
    pong(pings, pongs)
    fmt.Println(<-pongs)
}

select {
    case <-ch1:
        // ...
    case x := <-ch2:
        // ...use x...
    case ch3 <- y:
        // ...
    default:
        // ...
}

package main

import "time"
import "fmt"

// Go 的通道选择器 让你可以同时等待多个通道操作。
// Go 协程和通道以及选择器的结合是 Go 的一个强大特性。
func main() {
    // 在我们的例子中，我们将从两个通道中选择。
    c1 := make(chan string)
    c2 := make(chan string)
    // 各个通道将在若干时间后接收一个值，这个用来模拟例如并行的 Go 协程中阻塞的 RPC 操作
    go func() {
        time.Sleep(time.Second * 1)
        c1 <- "one"
    }()
    go func() {
        time.Sleep(time.Second * 2)
        c2 <- "two"
    }()

    // 我们使用 select 关键字来同时等待这两个值，并打印各自接收到的值。
    for i := 0; i < 2; i++ {
        select {
            case msg1 := <-c1:
                fmt.Println("received", msg1)
            case msg2 := <-c2:
                fmt.Println("received", msg2)
        }
    }
    // 我们首先接收到值 "one"，然后就是预料中的 "two"了。
    // 注意从第一次和第二次 Sleeps 并发执行，总共仅运行了两秒左右。
}

package main

import "time"
import "fmt"

// 超时 对于一个连接外部资源，或者其它一些需要花费执行时间的操作的程序而言是很重要的。
// 得益于通道和 select，在 Go中实现超时操作是简洁而优雅的。
func main() {
    c1 := make(chan string, 1)
    // 在我们的例子中，假如我们执行一个外部调用，并在 2 秒后通过通道 c1 返回它的执行结果。
    go func() {
        time.Sleep(time.Second * 2)
        c1 <- "result 1"
    }()

    // 这里是使用 select 实现一个超时操作。res := <- c1 等待结果，<-Time.After 等待超时时间 1 秒后发送的值。
    // 由于 select 默认处理第一个已准备好的接收操作，如果这个操作超过了允许的 1 秒的话，将会执行超时 case。
    select {
        case res := <-c1:
            fmt.Println(res)
        case <-time.After(time.Second * 1):
            fmt.Println("timeout 1")
    }

    // 如果我允许一个长一点的超时时间 3 秒，将会成功的从 c2接收到值，并且打印出结果。
    c2 := make(chan string, 1)
    go func() {
        time.Sleep(time.Second * 2)
        c2 <- "result 2"
    }()

    select {
        case res := <-c2:
            fmt.Println(res)
        case <-time.After(time.Second * 3):
            fmt.Println("timeout 2")
    }
    // 运行这个程序，首先显示运行超时的操作，然后是成功接收的。
    // 使用这个 select 超时方式，需要使用通道传递结果。
    // 这对于一般情况是个好的方式，因为其他重要的 Go 特性是基于通道和select 的。
}

package main

import (
    "fmt"
)

// 常规的通过通道发送和接收数据是阻塞的。
// 然而，我们可以使用带一个 default 子句的 select 来实现非阻塞 的发送、接收，甚至是非阻塞的多路 select。
func main() {
    messages := make(chan string)
    signals := make(chan bool)
    // 这里是一个非阻塞接收的例子。
    // 如果在 messages 中存在，然后 select 将这个值带入 <-messages case中。
    // 如果不是，就直接到 default 分支中。
    select {
        case msg := <-messages:
            fmt.Println("received message", msg)
        default:
            fmt.Println("no message received")
    }

    // 一个非阻塞发送的实现方法和上面一样。
    msg := "hi"
    select {
        case messages <- msg:
            fmt.Println("sent message", msg)
        default:
            fmt.Println("no message sent")
    }

    // 我们可以在 default 前使用多个 case 子句来实现一个多路的非阻塞的选择器。
    // 这里我们试图在 messages和 signals 上同时使用非阻塞的接受操作。
    select {
        case msg := <-messages:
            fmt.Println("received message", msg)
        case sig := <-signals:
            fmt.Println("received signal", sig)
        default:
            fmt.Println("no activity")
    }
}

package main

import s "strings"
import "fmt"
// 我们给 fmt.Println 一个短名字的别名，我们随后将会经常用到。
var p = fmt.Println

// 标准库的 strings 包提供了很多有用的字符串相关的函数。
// 这里是一些用来让你对这个包有个初步了解的例子。
func main() {
    // 这是一些 strings 中的函数例子。
    // 注意他们都是包中的函数，不是字符串对象自身的方法，这意味着我们需要考虑在调用时传递字符作为第一个参数进行传递。
    p("Contains:  ", s.Contains("test", "es"))
    p("Count:     ", s.Count("test", "t"))
    p("HasPrefix: ", s.HasPrefix("test", "te"))
    p("HasSuffix: ", s.HasSuffix("test", "st"))
    p("Index:     ", s.Index("test", "e"))
    p("Join:      ", s.Join([]string{"a", "b"}, "-"))
    p("Repeat:    ", s.Repeat("a", 5))
    p("Replace:   ", s.Replace("foo", "o", "0", -1))
    p("Replace:   ", s.Replace("foo", "o", "0", 1))
    p("Split:     ", s.Split("a-b-c-d-e", "-"))
    p("ToLower:   ", s.ToLower("TEST"))
    p("ToUpper:   ", s.ToUpper("test"))
    // 你可以在 strings包文档中找到更多的函数
    p()
    // 虽然不是 strings 的一部分，但是仍然值得一提的是获取字符串长度和通过索引获取一个字符的机制。
    p("Len: ", len("hello"))
    p("Char:", "hello"[1])
}

package main

import "fmt"
import "os"

type point struct {
    x, y int
}

func main() {
    // Go 为常规 Go 值的格式化设计提供了多种打印方式。例如，这里打印了 point 结构体的一个实例。
    p := point{1, 2}
    fmt.Printf("%v\n", p)
    // 如果值是一个结构体，%+v 的格式化输出内容将包括结构体的字段名。
    fmt.Printf("%+v\n", p)
    // %#v 形式则输出这个值的 Go 语法表示。例如，值的运行源代码片段。
    fmt.Printf("%#v\n", p)
    // 需要打印值的类型，使用 %T。
    fmt.Printf("%T\n", p)
    // 格式化布尔值是简单的。
    fmt.Printf("%t\n", true)
    // 格式化整形数有多种方式，使用 %d进行标准的十进制格式化。
    fmt.Printf("%d\n", 123)
    // 这个输出二进制表示形式。
    fmt.Printf("%b\n", 14)
    // 这个输出给定整数的对应字符。
    fmt.Printf("%c\n", 33)
    // %x 提供十六进制编码。
    fmt.Printf("%x\n", 456)
    // 对于浮点型同样有很多的格式化选项。使用 %f 进行最基本的十进制格式化。
    fmt.Printf("%f\n", 78.9)
    // %e 和 %E 将浮点型格式化为（稍微有一点不同的）科学技科学记数法表示形式。
    fmt.Printf("%e\n", 123400000.0)
    fmt.Printf("%E\n", 123400000.0)
    // 使用 %s 进行基本的字符串输出。
    fmt.Printf("%s\n", "\"string\"")
    // 像 Go 源代码中那样带有双引号的输出，使用 %q。
    fmt.Printf("%q\n", "\"string\"")
    // 和上面的整形数一样，%x 输出使用 base-16 编码的字符串，每个字节使用 2 个字符表示。
    fmt.Printf("%x\n", "hex this")
    // 要输出一个指针的值，使用 %p。
    fmt.Printf("%p\n", &p)
    // 当输出数字的时候，你将经常想要控制输出结果的宽度和精度，可以使用在 % 后面使用数字来控制输出宽度。
    // 默认结果使用右对齐并且通过空格来填充空白部分。
    fmt.Printf("|%6d|%6d|\n", 12, 345)
    // 你也可以指定浮点型的输出宽度，同时也可以通过 宽度.精度 的语法来指定输出的精度。
    fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)
    // 要左对齐，使用 - 标志。
    fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45)
    // 你也许也想控制字符串输出时的宽度，特别是要确保他们在类表格输出时的对齐。
    // 这是基本的右对齐宽度表示。
    fmt.Printf("|%6s|%6s|\n", "foo", "b")
    // 要左对齐，和数字一样，使用 - 标志。
    fmt.Printf("|%-6s|%-6s|\n", "foo", "b")
    // 到目前为止，我们已经看过 Printf了，它通过 os.Stdout输出格式化的字符串。
    // Sprintf 则格式化并返回一个字符串而不带任何输出。
    s := fmt.Sprintf("a %s", "string")
    fmt.Println(s)
    // 你可以使用 Fprintf 来格式化并输出到 io.Writers而不是 os.Stdout。
    fmt.Fprintf(os.Stderr, "an %s\n", "error")
}

package main

import "strconv"
import "fmt"

// 从字符串中解析数字在很多程序中是一个基础常见的任务，在Go 中是这样处理的。
func main() {
    // 内置的 strconv 包提供了数字解析功能。
    // 使用 ParseFloat 解析浮点数，这里的 64 表示表示解析的数的位数。
    f, _ := strconv.ParseFloat("1.234", 64)
    fmt.Println(f)
    // 在使用 ParseInt 解析整形数时，例子中的参数 0 表示自动推断字符串所表示的数字的进制。
    // 64 表示返回的整形数是以 64 位存储的。
    i, _ := strconv.ParseInt("123", 0, 64)
    fmt.Println(i)
    // ParseInt 会自动识别出十六进制数。
    d, _ := strconv.ParseInt("0x1c8", 0, 64)
    fmt.Println(d)
    // ParseUint 也是可用的。
    u, _ := strconv.ParseUint("789", 0, 64)
    fmt.Println(u)
    // Atoi 是一个基础的 10 进制整型数转换函数。
    k, _ := strconv.Atoi("135")
    fmt.Println(k)
    // 在输入错误时，解析函数会返回一个错误。
    _, e := strconv.Atoi("wat")
    fmt.Println(e)
}

package main

import "fmt"
import "time"

func main() {
    p := fmt.Println
    // 得到当前时间。
    now := time.Now()
    p(now)
    // 通过提供年月日等信息，你可以构建一个 time。时间总是关联着位置信息，例如时区。
    then := time.Date(2009, 11, 17, 20, 34, 58, 651387237, time.UTC)
    p(then)
    // 你可以提取出时间的各个组成部分。
    p(then.Year())
    p(then.Month())
    p(then.Day())
    p(then.Hour())
    p(then.Minute())
    p(then.Second())
    p(then.Nanosecond())
    p(then.Location())
    // 输出是星期一到日的 Weekday 也是支持的。
    p(then.Weekday())
    // 这些方法来比较两个时间，分别测试一下是否是之前，之后或者是同一时刻，精确到秒。
    p(then.Before(now))
    p(then.After(now))
    p(then.Equal(now))
    // 方法 Sub 返回一个 Duration 来表示两个时间点的间隔时间。
    diff := now.Sub(then)
    p(diff)
    // 我们计算出不同单位下的时间长度值。
    p(diff.Hours())
    p(diff.Minutes())
    p(diff.Seconds())
    p(diff.Nanoseconds())
    // 你可以使用 Add 将时间后移一个时间间隔，或者使用一个 - 来将时间前移一个时间间隔。
    p(then.Add(diff))
    p(then.Add(-diff))

    p("################")
    // 格式化
    // 这里是一个基本的按照 RFC3339 进行格式化的例子，使用对应模式常量。
    t := time.Now()
    p(t.Format(time.RFC3339))
    // 时间解析使用同 Format 相同的形式值。
    t1, e := time.Parse(time.RFC3339, "2012-11-01T22:08:41+00:00")
    p(t1)
    // Format 和 Parse 使用基于例子的形式来决定日期格式，
    // 一般你只要使用 time 包中提供的模式常量就行了，但是你也可以实现自定义模式。
    // 模式必须使用时间 Mon Jan 2 15:04:05 MST 2006来指定给定时间/字符串的格式化/解析方式。
    // 时间一定要按照如下所示：2006为年，15 为小时，Monday 代表星期几，等等。
    p(t.Format("3:04PM"))
    p(t.Format("Mon Jan _2 15:04:05 2006"))
    p(t.Format("2006-01-02T15:04:05.999999-07:00"))
    form := "3 04 PM"
    t2, e := time.Parse(form, "8 41 PM")
    p(t2)
    // 对于纯数字表示的时间，你也可以使用标准的格式化字符串来提出出时间值得组成。
    fmt.Printf("%d-%02d-%02dT%02d:%02d:%02d-00:00\n",
        t.Year(), t.Month(), t.Day(),
        t.Hour(), t.Minute(), t.Second()
    )
    // Parse 函数在输入的时间格式不正确是会返回一个错误。
    ansic := "Mon Jan _2 15:04:05 2006"
    _, e = time.Parse(ansic, "8:41PM")
    p(e)
}

package main

import "encoding/json"
import "fmt"
import "os"

// 下面我们将使用这两个结构体来演示自定义类型的编码和解码。
type Response1 struct {
    Page   int
    Fruits []string
}
type Response2 struct {
    Page   int      `json:"page"`
    Fruits []string `json:"fruits"`
}

func main() {
    // 首先我们来看一下基本数据类型到 JSON 字符串的编码过程。这里是一些原子值的例子。
    bolB, _ := json.Marshal(true)
    fmt.Println(string(bolB))
    intB, _ := json.Marshal(1)
    fmt.Println(string(intB))
    fltB, _ := json.Marshal(2.34)
    fmt.Println(string(fltB))
    strB, _ := json.Marshal("gopher")
    fmt.Println(string(strB))
    // 这里是一些切片和 map 编码成 JSON 数组和对象的例子。
    slcD := []string{"apple", "peach", "pear"}
    slcB, _ := json.Marshal(slcD)
    fmt.Println(string(slcB))
    mapD := map[string]int{"apple": 5, "lettuce": 7}
    mapB, _ := json.Marshal(mapD)
    fmt.Println(string(mapB))
    // JSON 包可以自动的编码你的自定义类型。
    // 编码仅输出可导出的字段，并且默认使用他们的名字作为 JSON 数据的键。
    res1D := &Response1{
        Page:   1,
        Fruits: []string{"apple", "peach", "pear"}}
    res1B, _ := json.Marshal(res1D)
    fmt.Println(string(res1B))
    // 你可以给结构字段声明标签来自定义编码的 JSON 数据键名称。
    // 在上面 Response2 的定义可以作为这个标签这个的一个例子。
    res2D := &Response2{
        Page:   1,
        Fruits: []string{"apple", "peach", "pear"}}
    res2B, _ := json.Marshal(res2D)
    fmt.Println(string(res2B))
    // 现在来看看解码 JSON 数据为 Go 值的过程。
    // 这里是一个普通数据结构的解码例子。
    byt := []byte(`{"num":6.13,"strs":["a","b"]}`)
    // 我们需要提供一个 JSON 包可以存放解码数据的变量。
    // 这里的 map[string]interface{} 将保存一个 string 为键，值为任意值的map。
    var dat map[string]interface{}
    // 这里就是实际的解码和相关的错误检查。
    if err := json.Unmarshal(byt, &dat); err != nil {
        panic(err)
    }
    fmt.Println(dat)
    // 为了使用解码 map 中的值，我们需要将他们进行适当的类型转换。
    // 例如这里我们将 num 的值转换成 float64类型。
    num := dat["num"].(float64)
    fmt.Println(num)
    // 访问嵌套的值需要一系列的转化。
    strs := dat["strs"].([]interface{})
    str1 := strs[0].(string)
    fmt.Println(str1)
    // 我们也可以解码 JSON 值到自定义类型。
    // 这个功能的好处就是可以为我们的程序带来额外的类型安全加强，并且消除在访问数据时的类型断言。
    str := `{"page": 1, "fruits": ["apple", "peach"]}`
    res := Response2{}
    json.Unmarshal([]byte(str), &res)
    fmt.Println(res)
    fmt.Println(res.Fruits[0])
    // 在上面的例子中，我们经常使用 byte 和 string 作为使用标准输出时数据和 JSON 表示之间的中间值。
    // 我们也可以和os.Stdout 一样，直接将 JSON 编码直接输出至 os.Writer流中，或者作为 HTTP 响应体。
    enc := json.NewEncoder(os.Stdout)
    d := map[string]int{"apple": 5, "lettuce": 7}
    enc.Encode(d)
}

package main

import (
    "bufio"
    "fmt"
    "io/ioutil"
    "os"
)

// Go 写文件和我们前面看过的读操作有着相似的方式。
// 读取文件需要经常进行错误检查，这个帮助方法可以精简下面的错误检查过程。
func check(e error) {
    if e != nil {
        panic(e)
    }
}
func main() {
    d1 := []byte("hello\ngo\n")
    // 开始，这里是展示如写入一个字符串（或者只是一些字节）到一个文件。
    err := ioutil.WriteFile("D:/study/dat1", d1, 0644)
    check(err)
    
    // 对于更细粒度的写入，先打开一个文件。
    f, err := os.Create("D:/study/dat2")
    check(err)
    // 打开文件后，习惯立即使用 defer 调用文件的 Close操作。
    defer f.Close()
    // 你可以写入你想写入的字节切片
    d2 := []byte{115, 111, 109, 101, 10}
    n2, err := f.Write(d2)
    check(err)
    fmt.Printf("wrote %d bytes\n", n2)
    // WriteString 也是可用的。
    n3, err := f.WriteString("writes\n")
    fmt.Printf("wrote %d bytes\n", n3)
    // 调用 Sync 来将缓冲区的信息写入磁盘。
    f.Sync()
    // bufio 提供了和我们前面看到的带缓冲的读取器一样的带缓冲的写入器。
    w := bufio.NewWriter(f)
    n4, err := w.WriteString("buffered\n")
    fmt.Printf("wrote %d bytes\n", n4)
    // 使用 Flush 来确保所有缓存的操作已写入底层写入器。
    w.Flush()

}