Go高级编程详解

一、数据操作 1、读取用户的输入

我们如何读取用户的键盘（控制台）输入呢？从键盘和标准输入 os.Stdin 读取输入，最简单的办法是使用 fmt 包提供的 Scan 和 Sscan 开头的函数。请看以下程序：

示例： readinput1.go：

// 从控制台读取输入:
package main
import "fmt"

var (
   firstName, lastName, s string
   i int
   f float32
   input = "56.12 / 5212 / Go"
   format = "%f / %d / %s"
)

func main() {
   fmt.Println("Please enter your full name: ")
   fmt.Scanln(&firstName, &lastName)
   // fmt.Scanf("%s %s", &firstName, &lastName)
   fmt.Printf("Hi %s %s!\n", firstName, lastName) // Hi Chris Naegels
   fmt.Sscanf(input, format, &f, &i, &s)
   fmt.Println("From the string we read: ", f, i, s)
    // 输出结果: From the string we read: 56.12 5212 Go
}

Scanln 扫描来自标准输入的文本，将空格分隔的值依次存放到后续的参数内，直到碰到换行。Scanf 与其类似，除了Scanf 的第一个参数用作格式字符串，用来决定如何读取。Sscan 和以 Sscan 开头的函数则是从字符串读取，除此之外，与 Scanf 相同。如果这些函数读取到的结果与您预想的不同，您可以检查成功读入数据的个数和返回的错误。

您也可以使用 bufio 包提供的缓冲读取（buffered reader）来读取数据，正如以下例子所示：

示例： readinput2.go：

package main
import (
    "fmt"
    "bufio"
    "os"
)

var inputReader *bufio.Reader
var input string
var err error

func main() {
    inputReader = bufio.NewReader(os.Stdin)
    fmt.Println("Please enter some input: ")
    input, err = inputReader.ReadString('\n')
    if err == nil {
        fmt.Printf("The input was: %s\n", input)
    }
}

inputReader 是一个指向 bufio.Reader 的指针。inputReader := bufio.NewReader(os.Stdin) 这行代码，将会创建一个读取器，并将其与标准输入绑定。

bufio.NewReader() 构造函数的签名为：func NewReader(rd io.Reader) *Reader

该函数的实参可以是满足 io.Reader 接口的任意对象（任意包含有适当的 Read() 方法的对象），函数返回一个新的带缓冲的 io.Reader 对象，它将从指定读取器（例如 os.Stdin）读取内容。

返回的读取器对象提供一个方法 ReadString(delim byte)，该方法从输入中读取内容，直到碰到 delim 指定的字符，然后将读取到的内容连同 delim 字符一起放到缓冲区。

ReadString 返回读取到的字符串，如果碰到错误则返回 nil。如果它一直读到文件结束，则返回读取到的字符串和io.EOF。如果读取过程中没有碰到 delim 字符，将返回错误 err != nil。

在上面的例子中，我们会读取键盘输入，直到回车键（\n）被按下。

屏幕是标准输出 os.Stdout；os.Stderr 用于显示错误信息，大多数情况下等同于 os.Stdout。

一般情况下，我们会省略变量声明，而使用 :=，例如：

inputReader := bufio.NewReader(os.Stdin)
input, err := inputReader.ReadString('\n')

我们将从现在开始使用这种写法。

第二个例子从键盘读取输入，使用了 switch 语句：

示例： switch_input.go：

package main
import (
    "fmt"
    "os"
    "bufio"
)

func main() {
    inputReader := bufio.NewReader(os.Stdin)
    fmt.Println("Please enter your name:")
    input, err := inputReader.ReadString('\n')

    if err != nil {
        fmt.Println("There were errors reading, exiting program.")
        return
    }

    fmt.Printf("Your name is %s", input)
    // For Unix: test with delimiter "\n", for Windows: test with "\r\n"
    switch input {
    case "Philip\r\n":  fmt.Println("Welcome Philip!")
    case "Chris\r\n":   fmt.Println("Welcome Chris!")
    case "Ivo\r\n":     fmt.Println("Welcome Ivo!")
    default: fmt.Printf("You are not welcome here! Goodbye!")
    }

    // version 2:   
    switch input {
    case "Philip\r\n":  fallthrough
    case "Ivo\r\n":     fallthrough
    case "Chris\r\n":   fmt.Printf("Welcome %s\n", input)
    default: fmt.Printf("You are not welcome here! Goodbye!\n")
    }

    // version 3:
    switch input {
    case "Philip\r\n", "Ivo\r\n":   fmt.Printf("Welcome %s\n", input)
    default: fmt.Printf("You are not welcome here! Goodbye!\n")
    }
}

注意：Unix和Windows的行结束符是不同的！

2、读文件

在 Go 语言中，文件使用指向 os.File 类型的指针来表示的，也叫做文件句柄。我们在前面章节使用到过标准输入os.Stdin 和标准输出 os.Stdout，他们的类型都是 *os.File。让我们来看看下面这个程序：

示例： fileinput.go：

package main
import (
    "bufio"
    "fmt"
    "io"
    "os"
)

func main() {
    inputFile, inputError := os.Open("input.dat")
    if inputError != nil {
        fmt.Printf("An error occurred on opening the inputfile\n" +
            "Does the file exist?\n" +
            "Have you got acces to it?\n")
        return // exit the function on error
    }
    defer inputFile.Close()

    inputReader := bufio.NewReader(inputFile)
    for {
        inputString, readerError := inputReader.ReadString('\n')
        if readerError == io.EOF {
            return
        }
        fmt.Printf("The input was: %s", inputString)
    }
}

变量 inputFile 是 *os.File 类型的。该类型是一个结构，表示一个打开文件的描述符（文件句柄）。然后，使用 os包里的 Open 函数来打开一个文件。该函数的参数是文件名，类型为 string。在上面的程序中，我们以只读模式打开 input.dat 文件。

如果文件不存在或者程序没有足够的权限打开这个文件，Open函数会返回一个错误：inputFile, inputError = os.Open("input.dat")。如果文件打开正常，我们就使用 defer.Close() 语句确保在程序退出前关闭该文件。然后，我们使用 bufio.NewReader 来获得一个读取器变量。

通过使用 bufio 包提供的读取器（写入器也类似），如上面程序所示，我们可以很方便的操作相对高层的 string 对象，而避免了去操作比较底层的字节。

接着，我们在一个无限循环中使用 ReadString('\n') 或 ReadBytes('\n') 将文件的内容逐行（行结束符 '\n'）读取出来。

注意： 

在之前的例子中，我们看到，Unix和Linux的行结束符是 \n，而Windows的行结束符是 \r\n。在使用 ReadString 和ReadBytes 方法的时候，我们不需要关心操作系统的类型，直接使用 \n 就可以了。另外，我们也可以使用 ReadLine()方法来实现相同的功能。

一旦读取到文件末尾，变量 readerError 的值将变成非空（事实上，常亮 io.EOF 的值是 true），我们就会执行 return语句从而退出循环。

其他类似函数：

1）将整个文件的内容读到一个字符串里：

如果您想这么做，可以使用 io/ioutil 包里的 ioutil.ReadFile() 方法，该方法第一个返回值的类型是 []byte，里面存放读取到的内容，第二个返回值是错误，如果没有错误发生，第二个返回值为 nil。请看下面示例。类似的，函数WriteFile() 可以将 []byte 的值写入文件。

示例： read_write_file1.go：

package main
import (
    "fmt"
    "io/ioutil"
    "os"
)

func main() {
    inputFile := "products.txt"
    outputFile := "products_copy.txt"
    buf, err := ioutil.ReadFile(inputFile)
    if err != nil {
        fmt.Fprintf(os.Stderr, "File Error: %s\n", err)
        // panic(err.Error())
        }
    fmt.Printf("%s\n", string(buf))
    err = ioutil.WriteFile(outputFile, buf, 0x644)
    if err != nil {
        panic(err. Error())
    }
}

2）带缓冲的读取

在很多情况下，文件的内容是不按行划分的，或者干脆就是一个二进制文件。在这种情况下，ReadString()就无法使用了，我们可以使用 bufio.Reader 的 Read()，它只接收一个参数：

buf := make([]byte, 1024)
...
n, err := inputReader.Read(buf)
if (n == 0) { break}

变量 n 的值表示读取到的字节数.

3）按列读取文件中的数据

如果数据是按列排列并用空格分隔的，你可以使用 fmt 包提供的以 FScan 开头的一系列函数来读取他们。请看以下程序，我们将 3 列的数据分别读入变量 v1、v2 和 v3 内，然后分别把他们添加到切片的尾部。

示例： read_file2.go：

package main
import (
    "fmt"
    "os"
)

func main() {
    file, err := os.Open("products2.txt")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    var col1, col2, col3 []string
    for {
        var v1, v2, v3 string
        _, err := fmt.Fscanln(file, &v1, &v2, &v3)
        // scans until newline
        if err != nil {
            break
        }
        col1 = append(col1, v1)
        col2 = append(col2, v2)
        col3 = append(col3, v3)
    }

    fmt.Println(col1)
    fmt.Println(col2)
    fmt.Println(col3)
}

输出结果：

[ABC FUNC GO]
[40 56 45]
[150 280 356]

注意：path 包里包含一个子包叫 filepath，这个子包提供了跨平台的函数，用于处理文件名和路径。例如 Base() 函数用于获得路径中的最后一个元素（不包含后面的分隔符）：

import "path/filepath"
filename := filepath.Base(path)

关于解析 CSV 文件，encoding/csv 包提供了相应的功能。具体请参考 http://golang.org/pkg/encoding/csv/

compress包：读取压缩文件

compress包提供了读取压缩文件的功能，支持的压缩文件格式为：bzip2、flate、gzip、lzw 和 zlib。

下面的程序展示了如何读取一个 gzip 文件。

示例： gzipped.go：

package main

import (
    "fmt"
    "bufio"
    "os"
    "compress/gzip"
)

func main() {
    fName := "MyFile.gz"
    var r *bufio.Reader
    fi, err := os.Open(fName)
    if err != nil {
        fmt.Fprintf(os.Stderr, "%v, Can't open %s: error: %s\n", os.Args[0], fName,
            err)
        os.Exit(1)
    }
    fz, err := gzip.NewReader(fi)
    if err != nil {
        r = bufio.NewReader(fi)
    } else {
        r = bufio.NewReader(fz)
    }

    for {
        line, err := r.ReadString('\n')
        if err != nil {
            fmt.Println("Done reading file")
            os.Exit(0)
        }
        fmt.Println(line)
    }
}

3、写文件

请看以下程序：

示例 fileoutput.go：

package main

import (
    "os"
    "bufio"
    "fmt"
)

func main () {
    // var outputWriter *bufio.Writer
    // var outputFile *os.File
    // var outputError os.Error
    // var outputString string
    outputFile, outputError := os.OpenFile("output.dat", os.O_WRONLY|os.O_CREATE, 0666)
    if outputError != nil {
        fmt.Printf("An error occurred with file opening or creation\n")
        return  
    }
    defer outputFile.Close()

    outputWriter := bufio.NewWriter(outputFile)
    outputString := "hello world!\n"

    for i:=0; i 1 {
        who += strings.Join(os.Args[1:], " ")
    }
    fmt.Println("Good Morning", who)
}

我们在IDE或编辑器中直接运行这个程序输出：Good Morning Alice

我们在命令行运行os_args or ./os_args会得到同样的结果。

但是我们在命令行加入参数，像这样：os_args John Bill Marc Luke，将得到这样的输出：Good Morning Alice John Bill Marc Luke

这个命令行参数会放置在切片os.Args[]中（以空格分隔），从索引1开始（os.Args[0]放的是程序本身的名字，在本例中是os_args）。函数strings.Join函数用来连接这些参数，以空格作为间隔。

2）flag包

flag包有一个扩展功能用来解析命令行选项。但是通常被用来替换基本常量，例如，在某些情况下我们希望在命令行给常量一些不一样的值。

在flag包中一个Flag被定义成一个含有如下字段的结构体：

type Flag struct {
    Name     string // name as it appears on command line
    Usage    string // help message
    Value    Value  // value as set
    DefValue string // default value (as text); for usage message
}

下面的程序echo.go模拟了Unix的echo功能：

package main

import (
    "flag" // command line option parser
    "os"
)

var NewLine = flag.Bool("n", false, "print newline") // echo -n flag, of type *bool

const (
    Space   = " "
    Newline = "\n"
)

func main() {
    flag.PrintDefaults()
    flag.Parse() // Scans the arg list and sets up flags
    var s string = ""
    for i := 0; i < flag.NArg(); i++ {
        if i > 0 {
            s += " "
            if *NewLine { // -n is parsed, flag becomes true
                s += Newline
            }
        }
        s += flag.Arg(i)
    }
    os.Stdout.WriteString(s)
}

flat.Parse()扫描参数列表（或者常量列表）并设置flag, flag.Arg(i)表示第i个参数。Parse()之后所有flag.Arg(i)全部可用，flag.Arg(0)就是第一个真实的flag，而不是像os.Args(o)放置程序的名字。

flag.Narg()返回参数的数量。解析后flag或常量就可用了。flag.Bool()定义了一个默认值是false的flag：当在命令行出现了第一个参数（这里是"n"），flag被设置成'true'（NewLine是*bool类型）。如果*NewLine表示对flag解引用，所以当值是true时将添加一个newline。

flag.PrintDefaults()打印flag的使用帮助信息，本例中打印的是：

    -n=false: print newline

flag.VisitAll(fn func(*Flag))是另一个有用的功能：按照字典顺序遍历flag，并且对每个标签调用fn。

当在命令行（Windows）中执行：echo.exe A B C，将输出：A B C；执行echo.exe -n A B C，将输出：

A
B
C

每个字符的输出都新起一行，每次都在输出的数据前面打印使用帮助信息：-n=false: print newline

对于flag.Bool你可以设置布尔型flag来测试你的代码，例如定义一个flag processedFlag：

    var processedFlag = flag.Bool(“proc”, false, “nothing processed yet”)

在后面用如下代码来测试：

    if *processedFlag { // found flag -proc
        r = process()
    }

要给flag定义其它类型，可以使用flag.Int()，flag.Float64，flag.String()。

6、用buffer读取文件

在下面的例子中，我们联合使用了缓冲读取文件和命令行flag解析这两项技术。如果不加参数，那么你输入什么屏幕就打印什么。

参数被认为是文件名，如果文件存在的话就打印文件内容到屏幕。命令行执行cat test测试输出。

示例  cat.go：

package main

import (
    "bufio"
    "flag"
    "fmt"
    "io"
    "os"
)

func cat(r *bufio.Reader) {
    for {
        buf, err := r.ReadBytes('\n')
        if err == io.EOF {
            break
        }
        fmt.Fprintf(os.Stdout, "%s", buf)
    }
    return
}

func main() {
    flag.Parse()
    if flag.NArg() == 0 {
        cat(bufio.NewReader(os.Stdin))
    }
    for i := 0; i < flag.NArg(); i++ {
        f, err := os.Open(flag.Arg(i))
        if err != nil {
            fmt.Fprintf(os.Stderr, "%s:error reading from %s: %s\n", os.Args[0], flag.Arg(i), err.Error())
            continue
        }
        cat(bufio.NewReader(f))
    }
}

7、用切片读写文件

切片提供了 Go 中处理 I/O 缓冲的标准方式，下面 cat 函数的第二版中，在一个切片缓冲内使用无限 for 循环（直到文件尾部 EOF）读取文件，并写入到标准输出（os.Stdout）。

func cat(f *os.File) {
    const NBUF = 512
    var buf [NBUF]byte
    for {
        switch nr, err := f.Read(buf[:]); true {
        case nr < 0:
            fmt.Fprintf(os.Stderr, "cat: error reading: %s\n", err.Error())
            os.Exit(1)
        case nr == 0: // EOF
            return
        case nr > 0:
            if nw, ew := os.Stdout.Write(buf[0:nr]); nw != nr {
                fmt.Fprintf(os.Stderr, "cat: error writing: %s\n", ew.Error())
            }
        }
    }
}

下面的代码来自于 cat2.go，使用了 os 包中的 os.file 和 Read 方法；cat2.go 与 cat.go 具有同样的功能。

示例 cat2.go：

package main

import (
    "flag"
    "fmt"
    "os"
)

func cat(f *os.File) {
    const NBUF = 512
    var buf [NBUF]byte
    for {
        switch nr, err := f.Read(buf[:]); true {
        case nr < 0:
            fmt.Fprintf(os.Stderr, "cat: error reading: %s\n", err.Error())
            os.Exit(1)
        case nr == 0: // EOF
            return
        case nr > 0:
            if nw, ew := os.Stdout.Write(buf[0:nr]); nw != nr {
                fmt.Fprintf(os.Stderr, "cat: error writing: %s\n", ew.Error())
            }
        }
    }
}

func main() {
    flag.Parse() // Scans the arg list and sets up flags
    if flag.NArg() == 0 {
        cat(os.Stdin)
    }
    for i := 0; i < flag.NArg(); i++ {
        f, err := os.Open(flag.Arg(i))
        if f == nil {
            fmt.Fprintf(os.Stderr, "cat: can't open %s: error %s\n", flag.Arg(i), err)
            os.Exit(1)
        }
        cat(f)
        f.Close()
    }
}

8、用 defer 关闭文件

defer 关键字对于在函数结束时关闭打开的文件非常有用，例如下面的代码片段：

func data(name string) string {
    f := os.Open(name, os.O_RDONLY, 0)
    defer f.Close() // idiomatic Go code!
    contents := io.ReadAll(f)
    return contents
}

在函数 return 后执行了 f.Close()。

9、使用接口的实际例子：fmt.Fprintf

例子程序 io_interfaces.go 很好的阐述了 io 包中的接口概念。

示例 io_interfaces.go：

// interfaces being used in the GO-package fmt
package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    // unbuffered
    fmt.Fprintf(os.Stdout, "%s\n", "hello world! - unbuffered")
    // buffered: os.Stdout implements io.Writer
    buf := bufio.NewWriter(os.Stdout)
    // and now so does buf.
    fmt.Fprintf(buf, "%s\n", "hello world! - buffered")
    buf.Flush()
}

输出：

hello world! - unbuffered
hello world! - buffered

下面是 fmt.Fprintf() 函数的实际签名：

func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) 

其不是写入一个文件，而是写入一个 io.Writer 接口类型的变量，下面是 Writer 接口在 io 包中的定义：

type Writer interface {
    Write(p []byte) (n int, err error)
}

fmt.Fprintf() 依据指定的格式向第一个参数内写入字符串，第一参数必须实现了 io.Writer 接口。Fprintf() 能够写入任何类型，只要其实现了 Write 方法，包括 os.Stdout,文件（例如 os.File），管道，网络连接，通道等等，同样的也可以使用 bufio 包中缓冲写入。bufio 包中定义了 type Writer struct{...}

bufio.Writer 实现了 Write 方法：

func (b *Writer) Write(p []byte) (nn int, err error)

它还有一个工厂函数：传给它一个 io.Writer 类型的参数，它会返回一个缓冲的 bufio.Writer 类型的 io.Writer：

func NewWriter(wr io.Writer) (b *Writer)

其适合任何形式的缓冲写入。

在缓冲写入的最后千万不要忘了使用 Flush()，否则最后的输出不会被写入。

我们将介绍 fmt.Fprint 函数向 http.ResponseWriter 写入，其同样实现了 io.Writer 接口。

10、Json 数据格式

数据结构要在网络中传输或保存到文件，就必须对其编码和解码；目前存在很多编码格式：JSON，XML，gob，Google 缓冲协议等等。Go 语言支持所有这些编码格式；在后面的章节，我们将讨论前三种格式。

结构可能包含二进制数据，如果将其作为文本打印，那么可读性是很差的。另外结构内部可能包含匿名字段，而不清楚数据的用意。

通过把数据转换成纯文本，使用命名的字段来标注，让其具有可读性。这样的数据格式可以通过网络传输，而且是与平台无关的，任何类型的应用都能够读取和输出，不与操作系统和编程语言的类型相关。

下面是一些术语说明：

• 数据结构 --> 指定格式 = 序列化 或 编码（传输之前）
• 指定格式 --> 数据格式 = 反序列化 或 解码（传输之后）

序列化是在内存中把数据转换成指定格式（data -> string），反之亦然（string -> data structure）

编码也是一样的，只是输出一个数据流（实现了 io.Writer 接口）；解码是从一个数据流（实现了 io.Reader）输出到一个数据结构。

我们都比较熟悉 XML 格式；但有些时候 JSON（JavaScript Object Notation，参阅 http://json.org）被作为首选，主要是由于其格式上非常简洁。通常 JSON 被用于 web 后端和浏览器之间的通讯，但是在其它场景也同样的有用。

这是一个简短的 JSON 片段：

{
    "Person": {
        "FirstName": "Laura",
        "LastName": "Lynn"
    }
}

尽管 XML 被广泛的应用，但是 JSON 更加简洁、轻量（占用更少的内存、磁盘及网络带宽）和更好的可读性，这也说明它越来越受欢迎。

Go 语言的 json 包可以让你在程序中方便的读取和写入 JSON 数据。

我们将在下面的例子里使用 json 包，并使用练习 vcard.go 中一个简化版本的 Address 和 VCard 结构（为了简单起见，我们忽略了很多错误处理，不过在实际应用中你必须要合理的处理这些错误）

示例 json.go：

// json.go.go
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "os"
)

type Address struct {
    Type    string
    City    string
    Country string
}

type VCard struct {
    FirstName string
    LastName  string
    Addresses []*Address
    Remark    string
}

func main() {
    pa := &Address{"private", "Aartselaar", "Belgium"}
    wa := &Address{"work", "Boom", "Belgium"}
    vc := VCard{"Jan", "Kersschot", []*Address{pa, wa}, "none"}
    // fmt.Printf("%v: \n", vc) // {Jan Kersschot [0x126d2b80 0x126d2be0] none}:
    // JSON format:
    js, _ := json.Marshal(vc)
    fmt.Printf("JSON format: %s", js)
    // using an encoder:
    file, _ := os.OpenFile("vcard.json", os.O_CREATE|os.O_WRONLY, 0)
    defer file.Close()
    enc := json.NewEncoder(file)
    err := enc.Encode(vc)
    if err != nil {
        log.Println("Error in encoding json")
    }
}

json.Marshal() 的函数签名是 func Marshal(v interface{}) ([]byte, error)，下面是数据编码后的 JSON 文本（实际上是一个 []bytes）：

{
    "FirstName": "Jan",
    "LastName": "Kersschot",
    "Addresses": [{
        "Type": "private",
        "City": "Aartselaar",
        "Country": "Belgium"
    }, {
        "Type": "work",
        "City": "Boom",
        "Country": "Belgium"
    }],
    "Remark": "none"
}

出于安全考虑，在 web 应用中最好使用 json.MarshalforHTML() 函数，其对数据执行HTML转码，所以文本可以被安全地嵌在 HTML 标签中。

JSON 与 Go 类型对应如下：

• bool 对应 JSON 的 booleans
• float64 对应 JSON 的 numbers
• string 对应 JSON 的 strings
• nil 对应 JSON 的 null

不是所有的数据都可以编码为 JSON 类型：只有验证通过的数据结构才能被编码：

• JSON 对象只支持字符串类型的 key；要编码一个 Go map 类型，map 必须是 map[string]T（T是 json 包中支持的任何类型）
• Channel，复杂类型和函数类型不能被编码
• 不支持循环数据结构；它将引起序列化进入一个无限循环
• 指针可以被编码，实际上是对指针指向的值进行编码（或者指针是 nil）

反序列化

UnMarshal() 的函数签名是 func Unmarshal(data []byte, v interface{}) error 把 JSON 解码为数据结构。

我们首先创建一个结构 Message 用来保存解码的数据：var m Message 并调用 Unmarshal()，解析 []byte 中的 JSON 数据并将结果存入指针 m 指向的值

虽然反射能够让 JSON 字段去尝试匹配目标结构字段；但是只有真正匹配上的字段才会填充数据。字段没有匹配不会报错，而是直接忽略掉。

解码任意的数据

json 包使用 map[string]interface{} 和 []interface{} 储存任意的 JSON 对象和数组；其可以被反序列化为任何的 JSON blob 存储到接口值中。

来看这个 JSON 数据，被存储在变量 b 中：

b == []byte({"Name": "Wednesday", "Age": 6, "Parents": ["Gomez", "Morticia"]})

不用理解这个数据的结构，我们可以直接使用 Unmarshal 把这个数据编码并保存在接口值中：

var f interface{}
err := json.Unmarshal(b, &f)

f指向的值是一个 map，key 是一个字符串，value 是自身存储作为空接口类型的值：

map[string]interface{} {
    "Name": "Wednesday",
    "Age":  6,
    "Parents": []interface{} {
        "Gomez",
        "Morticia",
    },
}

要访问这个数据，我们可以使用类型断言

m := f.(map[string]interface{})

我们可以通过 for range 语法和 type switch 来访问其实际类型：

for k, v := range m {
    switch vv := v.(type) {
    case string:
        fmt.Println(k, "is string", vv)
    case int:
        fmt.Println(k, "is int", vv)

    case []interface{}:
        fmt.Println(k, "is an array:")
        for i, u := range vv {
            fmt.Println(i, u)
        }
    default:
        fmt.Println(k, "is of a type I don’t know how to handle")
    }
}

通过这种方式，你可以处理未知的 JSON 数据，同时可以确保类型安全。

解码数据到结构

如果我们事先知道 JSON 数据，我们可以定义一个适当的结构并对 JSON 数据反序列化。下面的例子中，我们将定义：

type FamilyMember struct {
    Name    string
    Age     int
    Parents []string
}

并对其反序列化：

var m FamilyMember
err := json.Unmarshal(b, &m)

程序实际上是分配了一个新的切片。这是一个典型的反序列化引用类型（指针、切片和 map）的例子。

编码和解码流

json 包提供 Decoder 和 Encoder 类型来支持常用 JSON 数据流读写。NewDecoder 和 NewEncoder 函数分别封装了 io.Reader 和 io.Writer 接口。

func NewDecoder(r io.Reader) *Decoder
func NewEncoder(w io.Writer) *Encoder

要想把 JSON 直接写入文件，可以使用 json.NewEncoder 初始化文件（或者任何实现 io.Writer 的类型），并调用 Encode()；反过来与其对应的是使用 json.Decoder 和 Decode() 函数：

func NewDecoder(r io.Reader) *Decoder
func (dec *Decoder) Decode(v interface{}) error

来看下接口是如何对实现进行抽象的：数据结构可以是任何类型，只要其实现了某种接口，目标或源数据要能够被编码就必须实现 io.Writer 或 io.Reader 接口。由于 Go 语言中到处都实现了 Reader 和 Writer，因此 Encoder 和 Decoder 可被应用的场景非常广泛，例如读取或写入 HTTP 连接、websockets 或文件。

11、XML 数据格式

XML案例：

    Laura
    Lynn

如同 json 包一样，也有 Marshal() 和 UnMarshal() 从 XML 中编码和解码数据；但这个更通用，可以从文件中读取和写入（或者任何实现了 io.Reader 和 io.Writer 接口的类型）

和 JSON 的方式一样，XML 数据可以序列化为结构，或者从结构反序列化为 XML 数据；这些可以在例子 15.8（twitter_status.go）中看到。

encoding/xml 包实现了一个简单的 XML 解析器（SAX），用来解析 XML 数据内容。下面的例子说明如何使用解析器：

示例  xml.go：

// xml.go
package main

import (
    "encoding/xml"
    "fmt"
    "strings"
)

var t, token xml.Token
var err error

func main() {
    input := "LauraLynn"
    inputReader := strings.NewReader(input)
    p := xml.NewDecoder(inputReader)

    for t, err = p.Token(); err == nil; t, err = p.Token() {
        switch token := t.(type) {
        case xml.StartElement:
            name := token.Name.Local
            fmt.Printf("Token name: %s\n", name)
            for _, attr := range token.Attr {
                attrName := attr.Name.Local
                attrValue := attr.Value
                fmt.Printf("An attribute is: %s %s\n", attrName, attrValue)
                // ...
            }
        case xml.EndElement:
            fmt.Println("End of token")
        case xml.CharData:
            content := string([]byte(token))
            fmt.Printf("This is the content: %v\n", content)
            // ...
        default:
            // ...
        }
    }
}

/* Output:
Token name: Person
Token name: FirstName
This is the content: Laura
End of token
Token name: LastName
This is the content: Lynn
End of token
End of token
*/

包中定义了若干 XML 标签类型：StartElement，Chardata（这是从开始标签到结束标签之间的实际文本），EndElement，Comment，Directive 或 ProcInst。

包中同样定义了一个结构解析器：NewParser 方法持有一个 io.Reader（这里具体类型是 strings.NewReader）并生成一个解析器类型的对象。还有一个 Token() 方法返回输入流里的下一个 XML token。在输入流的结尾处，会返回（nil，io.EOF）

XML 文本被循环处理直到 Token() 返回一个错误，因为已经到达文件尾部，再没有内容可供处理了。通过一个 type-switch 可以根据一些 XML 标签进一步处理。Chardata 中的内容只是一个 []byte，通过字符串转换让其变得可读性强一些。

12、用 Gob 传输数据

Gob 是 Go 自己的以二进制形式序列化和反序列化程序数据的格式；可以在 encoding 包中找到。这种格式的数据简称为 Gob （即 Go binary 的缩写）。类似于 Python 的 "pickle" 和 Java 的 "Serialization"。

Gob 通常用于远程方法调用（RPCs）参数和结果的传输，以及应用程序和机器之间的数据传输。 它和 JSON 或 XML 有什么不同呢？Gob 特定地用于纯 Go 的环境中，例如，两个用 Go 写的服务之间的通信。这样的话服务可以被实现得更加高效和优化。 Gob 不是可外部定义，语言无关的编码方式。因此它的首选格式是二进制，而不是像 JSON 和 XML 那样的文本格式。 Gob 并不是一种不同于 Go 的语言，而是在编码和解码过程中用到了 Go 的反射。

Gob 文件或流是完全自描述的：里面包含的所有类型都有一个对应的描述，并且总是可以用 Go 解码，而不需要了解文件的内容。

只有可导出的字段会被编码，零值会被忽略。在解码结构体的时候，只有同时匹配名称和可兼容类型的字段才会被解码。当源数据类型增加新字段后，Gob 解码客户端仍然可以以这种方式正常工作：解码客户端会继续识别以前存在的字段。并且还提供了很大的灵活性，比如在发送者看来，整数被编码成没有固定长度的可变长度，而忽略具体的 Go 类型。

假如在发送者这边有一个有结构 T：

type T struct { X, Y, Z int }
var t = T{X: 7, Y: 0, Z: 8}

而在接收者这边可以用一个结构体 U 类型的变量 u 来接收这个值：

type U struct { X, Y *int8 }
var u U

在接收者中，X 的值是7，Y 的值是0（Y的值并没有从 t 中传递过来，因为它是零值）

和 JSON 的使用方式一样，Gob 使用通用的 io.Writer 接口，通过 NewEncoder() 函数创建 Encoder 对象并调用Encode()；相反的过程使用通用的 io.Reader 接口，通过 NewDecoder() 函数创建 Decoder 对象并调用 Decode。

我们把示例的信息写进名为 vcard.gob 的文件作为例子。这会产生一个文本可读数据和二进制数据的混合，当你试着在文本编辑中打开的时候会看到。

在下面示例中你会看到一个编解码，并且以字节缓冲模拟网络传输的简单例子：

示例  gob1.go：

// gob1.go
package main

import (
    "bytes"
    "fmt"
    "encoding/gob"
    "log"
)

type P struct {
    X, Y, Z int
    Name    string
}

type Q struct {
    X, Y *int32
    Name string
}

func main() {
    // Initialize the encoder and decoder.  Normally enc and dec would be      
    // bound to network connections and the encoder and decoder would      
    // run in different processes.      
    var network bytes.Buffer   // Stand-in for a network connection      
    enc := gob.NewEncoder(&network) // Will write to network.      
    dec := gob.NewDecoder(&network) // Will read from network.      
    // Encode (send) the value.      
    err := enc.Encode(P{3, 4, 5, "Pythagoras"})
    if err != nil {
        log.Fatal("encode error:", err)
    }
    // Decode (receive) the value.      
    var q Q
    err = dec.Decode(&q)
    if err != nil {
        log.Fatal("decode error:", err)
    }
    fmt.Printf("%q: {%d,%d}\n", q.Name, *q.X, *q.Y)
}
// Output:   "Pythagoras": {3,4}

示例  gob2.go 编码到文件：

// gob2.go
package main

import (
    "encoding/gob"
    "log"
    "os"
)

type Address struct {
    Type             string
    City             string
    Country          string
}

type VCard struct {
    FirstName   string
    LastName    string
    Addresses   []*Address
    Remark      string
}

var content string

func main() {
    pa := &Address{"private", "Aartselaar","Belgium"}
    wa := &Address{"work", "Boom", "Belgium"}
    vc := VCard{"Jan", "Kersschot", []*Address{pa,wa}, "none"}
    // fmt.Printf("%v: \n", vc) // {Jan Kersschot [0x126d2b80 0x126d2be0] none}: 
    // using an encoder:
    file, _ := os.OpenFile("vcard.gob", os.O_CREATE|os.O_WRONLY, 0)
    defer file.Close()
    enc := gob.NewEncoder(file)
    err := enc.Encode(vc)
    if err != nil {
        log.Println("Error in encoding gob")
    }
}

13、Go 中的密码学

通过网络传输的数据必须加密，以防止被 hacker（黑客）读取或篡改，并且保证发出的数据和收到的数据检验和一致。 鉴于 Go 母公司的业务，我们毫不惊讶地看到 Go 的标准库为该领域提供了超过 30 个的包：

• hash 包：实现了 adler32、crc32、crc64 和 fnv 校验；
• crypto 包：实现了其它的 hash 算法，比如 md4、md5、sha1 等。以及完整地实现了aes、blowfish、rc4、rsa、xtea 等加密算法。

下面的示例用 sha1 和 md5 计算并输出了一些校验值。

示例 hash_sha1.go：

// hash_sha1.go
package main

import (
    "fmt"
    "crypto/sha1"
    "io"
    "log"
)

func main() {
    hasher := sha1.New()
    io.WriteString(hasher, "test")
    b := []byte{}
    fmt.Printf("Result: %x\n", hasher.Sum(b))
    fmt.Printf("Result: %d\n", hasher.Sum(b))
    //
    hasher.Reset()
    data := []byte("We shall overcome!")
    n, err := hasher.Write(data)
    if n!=len(data) || err!=nil {
        log.Printf("Hash write error: %v / %v", n, err)
    }
    checksum := hasher.Sum(b)
    fmt.Printf("Result: %x\n", checksum)
}
/* Output: 
Result: a94a8fe5ccb19ba61c4c0873d391e987982fbbd3
Result: [169 74 143 229 204 177 155 166 28 76 8 115 211 145 233 135 152 47 187 211]
Result: e2222bfc59850bbb00a722e764a555603bb59b2a
*/

通过调用 sha1.New() 创建了一个新的 hash.Hash 对象，用来计算 SHA1 校验值。Hash 类型实际上是一个接口，它实现了 io.Writer 接口：

type Hash interface {
    // Write (via the embedded io.Writer interface) adds more data to the running hash.
    // It never returns an error.
    io.Writer

    // Sum appends the current hash to b and returns the resulting slice.
    // It does not change the underlying hash state.
    Sum(b []byte) []byte

    // Reset resets the Hash to its initial state.
    Reset()

    // Size returns the number of bytes Sum will return.
    Size() int

    // BlockSize returns the hash's underlying block size.
    // The Write method must be able to accept any amount
    // of data, but it may operate more efficiently if all writes
    // are a multiple of the block size.
    BlockSize() int
}

通过 io.WriteString 或 hasher.Write 计算给定字符串的校验值。

14、Go操作Mysql数据库

下载依赖：

go get -u github.com/go-sql-driver/mysql

使用Mysql驱动:

func Open(driverName, dataSourceName string) (*DB, error)

• Open方法打开一个指定的数据库.
• driverName为驱动名称，例mysql
• dataSourceName为数据库连接信息
• 返回DB和error

demo1：

func main() {
    // dsn: Data Source Name
    // 用户名为root，密码为123456，数据库为test
    dsn := "root:123456@tcp(127.0.0.1:3306)/test"
    
    // Open()方法对dsn的一个格式校验，并没有实际连接到数据库
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        panic(err)
    }
    defer db.Close()
}

Mysql Demo：

// 定义一个全局变量
var db *sql.DB
​
// 定义初始化mysql的方法
func initMysql() (err error) {
    // dsn: Data Source Name
    // 用户名为root，密码为123456，数据库为test
    dsn := "root:123456@tcp(127.0.0.1:3306)/test"
​
    // Open()方法对dsn的一个格式校验，并没有实际连接到数据库
    db, err = sql.Open("mysql", dsn)
    if err != nil {
        panic(err)
    }
​
    // 与数据库建立连接
    err = db.Ping()
    if err != nil {
        fmt.Printf("connect to db failed, err:%v\n", err)
        return
    }
    return
}
​
func main() {
    if err := initMysql(); err != nil {
        panic(err)
    }
    defer db.Close()
    fmt.Println("connected to db...")
}

单行查询

单行查询db.QueryRow()执行一次查询，并期望返回最多一行结果（即Row）。QueryRow总是返回非nil的值，直到返回值的Scan方法被调用时，才会返回被延迟的错误。

func (db *DB) QueryRow(query string, args ...interface{}) *Row

代码示例：

// 单行查询
func queryRowDemo() {
    // sql语句
    sqlStr := "select id, name, age from user where id=?"
    var u user
    err := db.QueryRow(sqlStr, 1).Scan(&u.id, &u.name, &u.age)
    if err != nil {
        fmt.Printf("scan failed, err:%v\n", err)
        return
    }
    fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
}

多行查询

多行查询db.Query()执行一次查询，返回多行结果（即Rows），一般用于执行select命令。参数args表示query中的占位参数。

func (db *DB) Query(query string, args ...interface{}) (*Rows, error)

代码示例：

// 多行查询
func queryMultiRowDemo() {
    sqlStr := "select id, name, age from user where id > ?"
    rows, err := db.Query(sqlStr, 0)
    if err != nil {
        fmt.Printf("query failed, err:%v\n", err)
        return
    }
    // 关闭rows释放持有的数据库链接
    defer rows.Close()
​
    // 循环读取结果集中的数据
    for rows.Next() {
        var u user
        err := rows.Scan(&u.id, &u.name, &u.age)
        if err != nil {
            fmt.Printf("scan failed, err:%v\n", err)
            return
        }
        fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
    }
}

插入数据

插入、更新和删除操作都使用Exec方法。

func (db *DB) Exec(query string, args ...interface{}) (Result, error)

Exec执行一次命令（包括查询、删除、更新、插入等），返回的Result是对已执行的SQL命令的总结。参数args表示query中的占位参数。

代码示例：

// 插入数据
func insertRowDemo(name string, age int) {
    sqlStr := "insert into user(name, age) values (?,?)"
    result, err := db.Exec(sqlStr, name, age)
    if err != nil {
        fmt.Printf("insert failed, err:%v\n", err)
        return
    }
    // RowsAffected()方法，表示影响的行数
    // num, err := result.RowsAffected()
    lastId, err := result.LastInsertId() // 新插入数据的id
    if err != nil {
        fmt.Printf("get lastinsert ID failed, err:%v\n", err)
        return
    }
    fmt.Printf("insert successfully, the id is %d.\n", lastId)
}

更新数据

// 更新数据
func updateRowDemo() {
    sqlStr := "update user set age=? where id = ?"
    result, err := db.Exec(sqlStr, 23, 1)
    if err != nil {
        fmt.Printf("update data failed, err:%v\n", err)
        return
    }
    // 操作影响的行数
    num, err := result.RowsAffected()
    if err != nil {
        fmt.Printf("get RowsAffected failed, err:%v\n", err)
        return
    }
​
    fmt.Printf("update data successfully, %d rows affected\n", num)
}

删除数据

// 删除数据
func deleteRowDemo() {
    sqlStr := "delete from user where id = ?"
    result, err := db.Exec(sqlStr, 3)
    if err != nil {
        fmt.Printf("delete failed, err:%v\n", err)
        return
    }
    num, err := result.RowsAffected() // 操作影响的行数
    if err != nil {
        fmt.Printf("get RowsAffected failed, err:%v\n", err)
        return
    }
    fmt.Printf("delete success, affected rows:%d\n", num)
}

Go实现Mysql预处理

为什么要预处理？

1. 优化MySQL服务器重复执行SQL的方法，可以提升服务器性能，提前让服务器编译，一次编译多次执行，节省后续编译的成本。

2. 避免SQL注入问题

database/sql中使用下面的Prepare方法来实现预处理操作。

func (db *DB) Prepare(query string) (*Stmt, error)

// 预处理
func prepareQueryDemo() {
    sqlStr := "select id, name, age from user where id > ?"
    stmt, err := db.Prepare(sqlStr)
    if err != nil {
        fmt.Printf("prepare failed, err:%v\n", err)
        return
    }
    defer stmt.Close()
    rows, err := stmt.Query(0)
    if err != nil {
        fmt.Printf("query failed, err:%v\n", err)
        return
    }
    defer rows.Close()
    // 循环读取结果集中的数据
    for rows.Next() {
        var u user
        err := rows.Scan(&u.id, &u.name, &u.age)
        if err != nil {
            fmt.Printf("scan failed, err:%v\n", err)
            return
        }
        fmt.Printf("id:%d name:%s age:%d\n", u.id, u.name, u.age)
    }
}

Go实现Mysql事务

Go语言中使用以下三个方法实现MySQL中的事务操作。

开始事务：

func (db *DB) Begin() (*Tx, error)

提交事务：

func (tx *Tx) Commit() error

回滚事务：

func (tx *Tx) Rollback() error

示例代码：

// 事务操作
func transactionDemo() {
    tx, err := db.Begin() // 开启事务
    if err != nil {
        if tx != nil {
            tx.Rollback() // 回滚
        }
        fmt.Printf("begin trans failed, err:%v\n", err)
        return
    }
    sqlStr1 := "update user set age=30 where id=?"
    result1, err := tx.Exec(sqlStr1, 1)
    if err != nil {
        tx.Rollback() // 回滚
        fmt.Printf("exec sql failed, err:%v\n", err)
        return
    }
    num1, err := result1.RowsAffected()
    if err != nil {
        tx.Rollback() // 回滚
        fmt.Printf("exec result.RowsAffected failed, err:%v\n", err)
        return
    }
​
    sqlStr2 := "update user set age=30 where id=?"
    result2, err := tx.Exec(sqlStr2, 2)
    if err != nil {
        tx.Rollback() // 回滚
        fmt.Printf("exec sql failed, err:%v\n", err)
        return
    }
    num2, err := result2.RowsAffected()
    if err != nil {
        tx.Rollback() // 回滚
        fmt.Printf("exec result.RowsAffected failed, err:%v\n", err)
        return
    }
​
    fmt.Println(num1, num2)
    if num1 == 1 && num2 == 1 {
        fmt.Println("事务提交啦。。。")
        tx.Commit()
    } else {
        tx.Rollback()
        fmt.Println("事务回滚啦。。。")
    }
    fmt.Println("exec trans success!")
}

15、Go操作redis

安装redis：

go get -u github.com/go-redis/redis

连接redis：

// 声明全局变量
var rdb *redis.Client

func initRedis() (err error) {
   rdb = redis.NewClient(&redis.Options{
      Addr: "192.168.0.141:6379",
      Password: "",
      DB: 0,
   })

   // 检查是否连接上了redis
   _, err = rdb.Ping().Result()
   if err != nil {
      return err
   }
   return nil
}

func main() {
   err := initRedis()
   if err != nil {
      fmt.Printf("init redis failed, err:%v\n", err)
      return
   }
   defer rdb.Close()

   fmt.Println("Connected to redis....")
}

16、mongo-driver

安装mongo-driver：

go get go.mongodb.org/mongo-driver

连接mongodb：

func main() {
   clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
   client, err := mongo.Connect(context.TODO(), clientOptions)
   if err != nil {
      log.Fatal(err)
   }

   err = client.Ping(context.TODO(), nil)

   if err != nil {
      log.Fatal(err)
   }

   fmt.Println("connected to MongoDB!")
}

关闭连接：

err = client.Disconnect(context.TODO())

if err != nil {
   log.Fatal(err)
}
fmt.Println("Connection to MongoDB closed.")

插入文档

// 插入一条
func InsertOne(u User) {
   insertResult, err := collection.InsertOne(context.TODO(), u)
   if err != nil {
      log.Fatal(err)
   }
   fmt.Println("Inserted a single document: ", insertResult.InsertedID)
}

// 插入多条
func InsertMany(userList []interface{}) {
   insertManyResult, err := collection.InsertMany(context.TODO(), userList)
   if err != nil {
      log.Fatal(err)
   }
   fmt.Println("Inserted many documents: ",insertManyResult.InsertedIDs)
}

更新文档

func UpdateOne() {

   filter := bson.D{{"name", "Alice"}}
   update := bson.D{
      {"$inc", bson.D{
         {"age", 101},
      }},
   }
   updateResult, err := collection.UpdateOne(context.TODO(), filter, update)
   if err != nil {
      log.Fatal(err)
   }

   fmt.Printf("Matched %v documents and updated %v documents.\n", updateResult.MatchedCount, updateResult.ModifiedCount)
}

查找文档

// 查找单个
func FindOne() {
   var user User
   filter := bson.D{{"name", "Alice"}}

   err := collection.FindOne(context.TODO(), filter).Decode(&user)
   if err != nil {
      log.Fatal(err)
   }
   fmt.Printf("Found a single document: %+v\n", user)
}

// 查找多个
```
func FindMany() {
   findOptions := options.Find()
   findOptions.SetLimit(2)

   var user []*User

   cur, err := collection.Find(context.TODO(), bson.D{{}}, findOptions)
   if err != nil {
      log.Fatal(err)
   }

   for cur.Next(context.TODO()) {
      var u User
      err := cur.Decode(&u)
      if err != nil {
         log.Fatal(err)
      }

      user = append(user, &u)
   }

   if err := cur.Err(); err != nil {
      log.Fatal(err)
   }

   cur.Close(context.TODO())

   fmt.Printf("Found multiple documents (array of pointers): %+v\n", user)

   for _, v := range user {
      fmt.Println(*v)
   }
}

删除文档

collection.DeleteOne()collection.DeleteMany() 删除单个、多个 Collection.Drop() 删除整个集合

示例：

func main() {

   uri := "mongodb://localhost:27017"

   client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(uri))
   if err != nil {
      panic(err)
   }
   defer func() {
      if err := client.Disconnect(context.TODO()); err != nil {
         panic(err)
      }
   }()
   coll := client.Database("test").Collection("user")
   name := "Alice"
   var result bson.M
   err = coll.FindOne(context.TODO(), bson.D{{"name", name}}).Decode(&result)
   if err == mongo.ErrNoDocuments {
      fmt.Printf("No document was found with the title %s\n", name)
      return
   }
   if err != nil {
      panic(err)
   }
   jsonData, err := json.MarshalIndent(result, "", "    ")
   if err != nil {
      panic(err)
   }
   fmt.Printf("%s\n", jsonData)
}

17、sqlx库

安装sqlx：

go get github.com/jmoiron/sqlx

基本使用

连接数据库：

var db *sqlx.DB

func initDB() (err error) {
   dsn := "root:123456@tcp(127.0.0.1:3306)/test?charset=utf8mb4&parseTime=True"
   db, err = sqlx.Connect("mysql", dsn)
   if err != nil {
      fmt.Printf("connect DB failed, err:%v\n", err)
      return
   }

   db.SetMaxOpenConns(20)
   db.SetMaxIdleConns(10)
   return
}

func main() {
   err := initDB()
   if err != nil {
      fmt.Printf("init db failed, err:%v\n", err)
      return
   }
   defer db.Close()
   fmt.Println("connected to db...")
}

插入数据

// 插入数据
func insertRowDemo() {
   sqlStr := "insert into user(name, age) values (?, ?)"
   result, err := db.Exec(sqlStr, "Cindy", 23)
   if err != nil {
      fmt.Printf("insert data failed, err:%v\n", err)
      return
   }
   lastID, err := result.LastInsertId()
   if err != nil {
      fmt.Printf("get last id failed, err:%v\n", err)
      return
   }
   fmt.Printf("insert successfully, last id is %d.\n", lastID)
}

NamedExec

DB.NamedExec方法用来绑定SQL语句与结构体或map中的同名字段：

func insertUserDemo() {
   sqlStr := "insert into user(name, age) values(:name, :age)"
   db.NamedExec(sqlStr,
      map[string]interface{}{
         "name": "ddd",
         "age": 30,
      })
   fmt.Printf("insert data successfully.")
   return
}

18、msgpack

Go语言中的json包在序列化空接口存放的数字类型（整型、浮点型等）都序列化成float64类型：

func jsonDemo() {
   var s1 = s{
      data: make(map[string]interface{}, 8),
   }
   s1.data["count"] = 1
   ret, err := json.Marshal(s1.data)
   if err != nil {
      fmt.Println("marshal failed ", err)
   }
   fmt.Printf("%#v\n", string(ret))

   var s2 = s{
      data: make(map[string]interface{}, 8),
   }
   err = json.Unmarshal(ret, &s2.data)
   if err != nil {
      fmt.Println("marshal failed ", err)
   }
   fmt.Println(s2)
   for _, v := range s2.data {
      fmt.Printf("value:%v, type:%T\n", v, v)
   }
}

// 输出：
"{\"count\":1}"
{map[count:1]}
value:1, type:float64

gob序列化：

// gob序列化
func gobDemo() {
   var s1 = s{
      data: make(map[string]interface{}, 8),
   }
   s1.data["count"] = 1

   // encode
   buf := new(bytes.Buffer)
   enc := gob.NewEncoder(buf)
   err := enc.Encode(s1.data)
   if err != nil {
      fmt.Println("gob encode failed, err: ", err)
      return
   }
   b := buf.Bytes()
   fmt.Println(b)

   var s2 = s{
      data: make(map[string]interface{}, 8),
   }
   // decode
   dec := gob.NewDecoder(bytes.NewBuffer(b))
   err = dec.Decode(&s2.data)
   if err != nil {
      fmt.Println("gob encode failed, err: ", err)
      return
   }
   fmt.Println(s2.data)
   for _, v := range s2.data {
      fmt.Printf("value:%v, type:%T\n", v, v)
   }
}

msgpack序列化：

func main() {
   p1 := Person{
      Name:   "alice",
      Age:    18,
      Gender: "男",
   }
   // marshal
   b, err := msgpack.Marshal(p1)
   if err != nil {
      fmt.Printf("msgpack marshal failed, err:%v", err)
      return
   }

   // unmarshal
   var p2 Person
   err = msgpack.Unmarshal(b, &p2)
   if err != nil {
      fmt.Printf("msgpack unmarshal failed, err:%v", err)
      return
   }
   fmt.Printf("p2:%#v\n", p2)
}

// 输出：
p2:main.Person{Name:"alice", Age:18, Gender:"男"}

二、 错误处理与测试 1、错误处理

Go 有一个预先定义的 error 接口类型：

type error interface { 
    Error() string
}

errors 包中有一个 errorString 结构体实现了 error 接口。当程序处于错误状态时可以用 os.Exit(1)来中止运行。

1）定义错误

任何时候当你需要一个新的错误类型，都可以用 errors（必须先 import）包的 errors.New 函数接收合适的错误信息来创建，像下面这样：

err := errors.New(“math - square root of negative number”)

你可以看到一个简单的用例：

示例 errors.go：

// errors.go
package main

import (
    "errors"
    "fmt"
)

var errNotFound error = errors.New("Not found error")

func main() {
    fmt.Printf("error: %v", errNotFound)
}
// error: Not found error

可以把它用于计算平方根函数的参数测试：

func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New (“math - square root of negative number”)
    }
   // implementation of Sqrt
}

你可以像下面这样调用 Sqrt 函数：

if f, err := Sqrt(-1); err != nil {
    fmt.Printf(“Error: %s\n”, err)
}

由于 fmt.Printf 会自动调用 String() 方法 ，所以错误信息 “Error: math - square root of negative number” 会打印出来。通常（错误信息）都会有像 “Error:” 这样的前缀，所以你的错误信息不要以大写字母开头。

在大部分情况下自定义错误结构类型很有意义的，可以包含除了（低层级的）错误信息以外的其它有用信息，例如，正在进行的操作（打开文件等），全路径或名字。看下面例子中 os.Open 操作触发的 PathError 错误：

// PathError records an error and the operation and file path that caused it.
type PathError struct {
    Op string    // “open”, “unlink”, etc.
    Path string  // The associated file.
    Err error  // Returned by the system call.
}

func (e *PathError) String() string {
    return e.Op + “ ” + e.Path + “: “+ e.Err.Error()
}

如果有不同错误条件可能发生，那么对实际的错误使用类型断言或类型判断（type-switch）是很有用的，并且可以根据错误场景做一些补救和恢复操作。

//  err != nil
if e, ok := err.(*os.PathError); ok {
    // remedy situation
}

或：

switch err := err.(type) {
    case ParseError:
        PrintParseError(err)
    case PathError:
        PrintPathError(err)
    ... 
    default:
        fmt.Printf(“Not a special error, just %s\n”, err)
}

作为第二个例子考虑用 json 包的情况。当 json.Decode 在解析 JSON 文档发生语法错误时，指定返回一个 SyntaxError 类型的错误：

type SyntaxError struct {
    msg    string // description of error
// error occurred after reading Offset bytes, from which line and columnnr can be obtained
    Offset int64
}

func (e *SyntaxError) String() string { return e.msg }

在调用代码中你可以像这样用类型断言测试错误是不是上面的类型：

if serr, ok := err.(*json.SyntaxError); ok {
    line, col := findLine(f, serr.Offset)
    return fmt.Errorf(“%s:%d:%d: %v”, f.Name(), line, col, err)
}

包也可以用额外的方法（methods）定义特定的错误，比如 net.Errot：

package net
type Error interface {
    Timeout() bool   // Is the error a timeout?
    Temporary() bool // Is the error temporary?
}

正如你所看到的一样，所有的例子都遵循同一种命名规范：错误类型以 “Error” 结尾，错误变量以 “err” 或 “Err” 开头。

syscall 是低阶外部包，用来提供系统基本调用的原始接口。它们返回整数的错误码；类型 syscall.Errno 实现了 Error 接口。

大部分 syscall 函数都返回一个结果和可能的错误，比如：

r, err := syscall.Open(name, mode, perm)
if err != 0 {
    fmt.Println(err.Error())
}

os 包也提供了一套像 os.EINAL 这样的标准错误，它们基于 syscall 错误：

var (
    EPERM       Error = Errno(syscall.EPERM)
    ENOENT      Error = Errno(syscall.ENOENT)   
    ESRCH       Error = Errno(syscall.ESRCH)
    EINTR       Error = Errno(syscall.EINTR)
    EIO         Error = Errno(syscall.EIO)
    ... 
)

2）用 fmt 创建错误对象

通常你想要返回包含错误参数的更有信息量的字符串，例如：可以用 fmt.Errorf() 来实现：它和 fmt.Printf() 完全一样，接收有一个或多个格式占位符的格式化字符串和相应数量的占位变量。和打印信息不同的是它用信息生成错误对象。

比如在前面的平方根例子中使用：

if f < 0 {
    return 0, fmt.Errorf(“math: square root of negative number %g”, f)
}

第二个例子：从命令行读取输入时，如果加了 help 标志，我们可以用有用的信息产生一个错误：

if len(os.Args) > 1 && (os.Args[1] == “-h” || os.Args[1] == “--help”) {
    err = fmt.Errorf(“usage: %s infile.txt outfile.txt”, filepath.Base(os.Args[0]))
    return
}

2、运行时异常和panic

当发生像数组下标越界或类型断言失败这样的运行错误时，Go 运行时会触发运行时 panic，伴随着程序的崩溃抛出一个runtime.Error 接口类型的值。这个错误值有个 RuntimeError() 方法用于区别普通错误。

panic 可以直接从代码初始化：当错误条件（我们所测试的代码）很严苛且不可恢复，程序不能继续运行时，可以使用panic 函数产生一个中止程序的运行时错误。panic 接收一个做任意类型的参数，通常是字符串，在程序死亡时被打印出来。Go 运行时负责中止程序并给出调试信息。

package main

import "fmt"

func main() {
    fmt.Println("Starting the program")
    panic("A severe error occurred: stopping the program!")
    fmt.Println("Ending the program")
}

输出如下：

Starting the program
panic: A severe error occurred: stopping the program!
panic PC=0x4f3038
runtime.panic+0x99 /go/src/pkg/runtime/proc.c:1032
       runtime.panic(0x442938, 0x4f08e8)
main.main+0xa5 E:/Go/GoBoek/code examples/chapter 13/panic.go:8
       main.main()
runtime.mainstart+0xf 386/asm.s:84
       runtime.mainstart()
runtime.goexit /go/src/pkg/runtime/proc.c:148
       runtime.goexit()
---- Error run E:/Go/GoBoek/code examples/chapter 13/panic.exe with code Crashed
---- Program exited with code -1073741783

一个检查程序是否被已知用户启动的具体例子：

var user = os.Getenv(“USER”)

func check() {
    if user == “” {
        panic(“Unknown user: no value for $USER”)
    }
}

可以在导入包的 init() 函数中检查这些。

当发生错误必须中止程序时，panic 可以用于错误处理模式：

if err != nil {
    panic(“ERROR occurred:” + err.Error())
}

Go panicking：

在多层嵌套的函数调用中调用 panic，可以马上中止当前函数的执行，所有的 defer 语句都会保证执行并把控制权交还给接收到 panic 的函数调用者。这样向上冒泡直到最顶层，并执行（每层的） defer，在栈顶处程序崩溃，并在命令行中用传给 panic 的值报告错误情况：这个终止过程就是 panicking。

标准库中有许多包含 Must 前缀的函数，像 regexp.MustComplie 和 template.Must；当正则表达式或模板中转入的转换字符串导致错误时，这些函数会 panic。

不能随意地用 panic 中止程序，必须尽力补救错误让程序能继续执行。

3、从 panic 中恢复（Recover）

正如名字一样，这个（recover）内建函数被用于从 panic 或 错误场景中恢复：让程序可以从 panicking 重新获得控制权，停止终止过程进而恢复正常执行。

recover 只能在 defer 修饰的函数中使用：用于取得 panic 调用中传递过来的错误值，如果是正常执行，调用 recover 会返回 nil，且没有其它效果。

总结：panic 会导致栈被展开直到 defer 修饰的 recover() 被调用或者程序中止。

下面例子中的 protect 函数调用函数参数 g 来保护调用者防止从 g 中抛出的运行时 panic，并展示 panic 中的信息：

func protect(g func()) {
    defer func() {
        log.Println(“done”)
        // Println executes normally even if there is a panic 
        if err := recover(); err != nil {
        log.Printf(“run time panic: %v”, err)
        }
    }()
    log.Println(“start”)
    g() //   possible runtime-error
}

这跟 Java 和 .NET 这样的语言中的 catch 块类似。

log 包实现了简单的日志功能：默认的 log 对象向标准错误输出中写入并打印每条日志信息的日期和时间。除了 Println 和Printf 函数，其它的致命性函数都会在写完日志信息后调用 os.Exit(1)，那些退出函数也是如此。而 Panic 效果的函数会在写完日志信息后调用 panic；可以在程序必须中止或发生了临界错误时使用它们，就像当 web 服务器不能启动时那样。

log 包用那些方法（methods）定义了一个 Logger 接口类型，如果你想自定义日志系统的话可以参考（参见http://golang.org/pkg/log/#Logger）。

这是一个展示 panic，defer 和 recover 怎么结合使用的完整例子：

示例 panic_recover.go：

// panic_recover.go
package main

import (
    "fmt"
)

func badCall() {
    panic("bad end")
}

func test() {
    defer func() {
        if e := recover(); e != nil {
            fmt.Printf("Panicing %s\r\n", e)
        }
    }()
    badCall()
    fmt.Printf("After bad call\r\n") // =n，或者执行 runtime.GOMAXPROCS(n)，接下来协程会被分割（分散）到 n 个处理器上。更多的处理器并不意味着性能的线性提升。有这样一个经验法则，对于 n 个核心的情况设置 GOMAXPROCS 为 n-1 以获得最佳性能，也同样需要遵守这条规则：协程的数量 > 1 + GOMAXPROCS > 1。
 
所以如果在某一时间只有一个协程在执行，不要设置 GOMAXPROCS！
 
还有一些通过实验观察到的现象：在一台 1 颗 CPU 的笔记本电脑上，增加 GOMAXPROCS 到 9 会带来性能提升。在一台 32 核的机器上，设置 GOMAXPROCS=8 会达到最好的性能，在测试环境中，更高的数值无法提升性能。如果设置一个很大的 GOMAXPROCS 只会带来轻微的性能下降；设置 GOMAXPROCS=100，使用 top 命令和 H 选项查看到只有 7 个活动的线程。
 
增加 GOMAXPROCS 的数值对程序进行并发计算是有好处的；
 
请看 goroutine_select2.go
 
总结：GOMAXPROCS 等同于（并发的）线程数量，在一台核心数多于1个的机器上，会尽可能有等同于核心数的线程在并行运行。
 
4）如何用命令行指定使用的核心数量
 
使用 flags 包，如下：
 
var numCores = flag.Int("n", 2, "number of CPU cores to use")

in main()
flag.Pars()
runtime.GOMAXPROCS(*numCores)
 
协程可以通过调用runtime.Goexit()来停止，尽管这样做几乎没有必要。
 
示例 -goroutine1.go 介绍了概念：
 
package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("In main()")
    go longWait()
    go shortWait()
    fmt.Println("About to sleep in main()")
    // sleep works with a Duration in nanoseconds (ns) !
    time.Sleep(10 * 1e9)
    fmt.Println("At the end of main()")
}

func longWait() {
    fmt.Println("Beginning longWait()")
    time.Sleep(5 * 1e9) // sleep for 5 seconds
    fmt.Println("End of longWait()")
}

func shortWait() {
    fmt.Println("Beginning shortWait()")
    time.Sleep(2 * 1e9) // sleep for 2 seconds
    fmt.Println("End of shortWait()")
}
 
输出：
 
In main()
About to sleep in main()
Beginning longWait()
Beginning shortWait()
End of shortWait()
End of longWait()
At the end of main() // after 10s
 
main()，longWait() 和 shortWait() 三个函数作为独立的处理单元按顺序启动，然后开始并行运行。每一个函数都在运行的开始和结束阶段输出了消息。为了模拟他们运算的时间消耗，我们使用了 time 包中的 Sleep 函数。Sleep() 可以按照指定的时间来暂停函数或协程的执行，这里使用了纳秒（ns，符号 1e9 表示 1 乘 10 的 9 次方，e=指数）。
 
他们按照我们期望的顺序打印出了消息，几乎都一样，可是我们明白这是模拟出来的，以并行的方式。我们让 main() 函数暂停 10 秒从而确定它会在另外两个协程之后结束。如果不这样（如果我们让 main() 函数停止 4 秒），main() 会提前结束，longWait() 则无法完成。如果我们不在 main() 中等待，协程会随着程序的结束而消亡。
 
当 main() 函数返回的时候，程序退出：它不会等待任何其他非 main 协程的结束。这就是为什么在服务器程序中，每一个请求都会启动一个协程来处理，server() 函数必须保持运行状态。通常使用一个无限循环来达到这样的目的。
 
另外，协程是独立的处理单元，一旦陆续启动一些协程，你无法确定他们是什么时候真正开始执行的。你的代码逻辑必须独立于协程调用的顺序。
 
为了对比使用一个线程，连续调用的情况，移除 go 关键字，重新运行程序。
 
现在输出：
 
In main()
Beginning longWait()
End of longWait()
Beginning shortWait()
End of shortWait()
About to sleep in main()
At the end of main() // after 17 s
 
协程更有用的一个例子应该是在一个非常长的数组中查找一个元素。
 
将数组分割为若干个不重复的切片，然后给每一个切片启动一个协程进行查找计算。这样许多并行的协程可以用来进行查找任务，整体的查找时间会缩短（除以协程的数量）。
 
5）Go 协程（goroutines）和协程（coroutines）
 
（译者注：标题中的“Go协程（goroutines）” 协程指的是 Go 语言中的协程。而“协程（coroutines）”指的是其他语言中的协程概念，仅在本节出现。）
 
在其他语言中，比如 C#，Lua 或者 Python 都有协程的概念。这个名字表明它和 Go协程有些相似，不过有两点不同：
 
Go 协程意味着并行（或者可以以并行的方式部署），协程一般来说不是这样的
Go 协程通过通道来通信；协程通过让出和恢复操作来通信
Go 协程比协程更强大，也很容易从协程的逻辑复用到 Go 协程。
 
2、GMP原理 
1）协程和线程
 
协程跟线程是有区别的，线程由CPU调度是抢占式的，协程由用户态调度是协作式的，一个协程让出CPU后，才执行下一个协程。
 
1:1关系
 
 
优点：1个协程绑定1个线程，这种最容易实现，协程的调度都由CPU完成了。
 
 
缺点：协程的创建、删除和切换的代价都由CPU完成，有点略显昂贵了。
 
 
N:1关系
 
 
优点：N个协程绑定1个线程，协程在用户态线程即完成切换，不会陷入到内核态，这种切换非常的轻量快速。
 
 
缺点：1个进程的所有协程都绑定在1个线程上，某个程序用不了硬件的多核加速能力，一旦某协程阻塞，造成线程阻塞，本进程的其他协程都无法执行了，根本就没有并发的能力了。
 
 
M:N关系
 
 
优点：M个协程绑定1个线程，是N:1和1:1类型的结合，克服了以上2种模型的缺点。
 
 
缺点：实现起来最为复杂。
 
 
2）GMP模型
 
Go为了提供更容易使用的并发方法，使用了goroutine和channel。goroutine来自协程的概念，让一组可复用的函数运行在一组线程之上，即使有协程阻塞，该线程的其他协程也可以被runtime调度，转移到其他可运行的线程上。最关键的是，程序员看不到这些底层的细节，这就降低了编程的难度，提供了更容易的并发。
 
goroutine非常轻量，一个goroutine只占几KB，并且这几KB就足够goroutine运行完，这就能在有限的内存空间内支持大量goroutine，支持了更多的并发。虽然一个goroutine的栈只占几KB，但实际是可伸缩的，如果需要更多内容，runtime会自动为goroutine分配。
 
模型说明
 
G来表示Goroutine，M来表示线程，P来表示Processor：
 
 
线程是运行goroutine的实体，调度器的功能是把可运行的goroutine分配到工作线程上： 
 
 
Goroutine调度器和OS调度器是通过M结合起来的，每个M都代表了1个内核线程，OS调度器负责把内核线程分配到CPU的核上执行，对上图的解读如下：
 
 
全局队列（Global Queue）：存放等待运行的G。
 
 
P的本地队列：同全局队列类似，存放的也是等待运行的G，存的数量有限，不超过256个。新建G'时，G'优先加入到P的本地队列，如果队列满了，则会把本地队列中一半的G移动到全局队列。
 
 
P列表：所有的P都在程序启动时创建，并保存在数组中，最多有GOMAXPROCS(可配置)个。
 
 
M：线程想运行任务就得获取P，从P的本地队列获取G，P队列为空时，M也会尝试从全局队列拿一批G放到P的本地队列，或从其他P的本地队列偷一半放到自己P的本地队列。M运行G，G执行之后，M会从P获取下一个G，不断重复下去。
 
调度流程 
 
 
从上图我们可以分析出几个结论：
 
 
我们通过 go func()来创建一个goroutine；
 
 
有两个存储G的队列，一个是局部调度器P的本地队列、一个是全局G队列。新创建的G会先保存在P的本地队列中，如果P的本地队列已经满了就会保存在全局的队列中；
 
 
G只能运行在M中，一个M必须持有一个P，M与P是1：1的关系。M会从P的本地队列弹出一个可执行状态的G来执行，如果P的本地队列为空，就会想其他的MP组合偷取一个可执行的G来执行；
 
 
一个M调度G执行的过程是一个循环机制；
 
 
当M执行某一个G时候如果发生了syscall或则其余阻塞操作，M会阻塞，如果当前有一些G在执行，runtime会把这个线程M从P中摘除(detach)，然后再创建一个新的操作系统的线程(如果有空闲的线程可用就复用空闲线程)来服务于这个P；
 
 
当M系统调用结束时候，这个G会尝试获取一个空闲的P执行，并放入到这个P的本地队列。如果获取不到P，那么这个线程M变成休眠状态， 加入到空闲线程中，然后这个G会被放入全局队列中。
 
3、使用通道进行协程间通信 
1）通道定义
 
协程是独立执行的，他们之间没有通信。他们必须通信才会变得更有用：彼此之间发送和接收信息并且协调/同步他们的工作。协程可以使用共享变量来通信，但是很不提倡这样做，因为这种方式给所有的共享内存的多线程都带来了困难。
 
而Go有一个特殊的类型，通道（channel），像是通道（管道），可以通过它们发送类型化的数据在协程之间通信，可以避开所有内存共享导致的坑；通道的通信方式保证了同步性。数据通过通道：同一时间只有一个协程可以访问数据：所以不会出现数据竞争，设计如此。数据的归属（可以读写数据的能力）被传递。
 
工厂的传送带是个很有用的例子。一个机器（生产者协程）在传送带上放置物品，另外一个机器（消费者协程）拿到物品并打包。
 
通道服务于通信的两个目的：值的交换，同步的，保证了两个计算（协程）任何时候都是可知状态。
 
 
通常使用这样的格式来声明通道：var identifier chan datatype
 
未初始化的通道的值是nil。
 
所以通道只能传输一种类型的数据，比如 chan int 或者 chan string，所有的类型都可以用于通道，空接口 interface{} 也可以。甚至可以（有时非常有用）创建通道的通道。
 
通道实际上是类型化消息的队列：使数据得以传输。它是先进先出（FIFO）结构的所以可以保证发送给他们的元素的顺序（有些人知道，通道可以比作 Unix shells 中的双向管道（tw-way pipe））。通道也是引用类型，所以我们使用 make() 函数来给它分配内存。这里先声明了一个字符串通道 ch1，然后创建了它（实例化）：
 
var ch1 chan string
ch1 = make(chan string)
 
当然可以更短： ch1 := make(chan string)。
 
这里我们构建一个int通道的通道： chanOfChans := make(chan int)。
 
或者函数通道：funcChan := chan func()。
 
所以通道是对象的第一类型：可以存储在变量中，作为函数的参数传递，从函数返回以及通过通道发送它们自身。另外它们是类型化的，允许类型检查，比如尝试使用整数通道发送一个指针。
 
下面是创建几种不同的通道：
 
ch1 := make(chan int)      // 无缓冲通道
ch2 := make(chan int, 3)   // 有缓冲通道
ch3 := make(chan{ .title }}
    {.}}{if pipeline}} T1 {{end}}
{{if pipeline}} T1 {{else}} T0 {{end}}
{{if pipeline}} T1 {{else if pipeline}} T0 {{end}}{html .}} 或者通过一个字段 FieldName {{ .FieldName |html }}