gob包（"encoding/gob"）管理gob流——在encoder（编码器，也就是发送器）和decoder（解码器，也就是接受器）之间交换的字节流数据（gob 就是 go binary的缩写）。一般用于传递远端程序调用（RPC）的参数和结果。
要使用gob，通过调用NewEncoder()方法先创建一个编码器，并向其提供一系列数据；然后在接收端，通过调用NewDecoder()方法创建一个解码器，它从数据流中恢复数据并将它们填写进本地变量里。下面会通过几个例子进行说明。
发送端和接收端的值/类型不需要严格匹配。对结构体来说，某一字段（通过字段名进行识别）如果发送端有而接收端没有，会被忽略；接收端有而发送端没有的字段也会被忽略；发送端和接收端都有的字段其类型必须是可兼容的；发送端和接收端都会在gob流和实际go类型之间进行必要的指针取址/寻址工作。举例如下：
下面是发送端的承载数据的结构体： struct { A, B int }
可以和如下类型互相发送和接收： struct { A, B int } // 同一类型 *struct { A, B int } // 结构体需要额外重定向（指针） struct { *A, **B int } // 字段需要额外重定向（指针） struct { A, B int64 } // 同为整型/浮点型且符号类型相同的不同值类型
可以发送给如下任一类型： struct { A, B int } // 同一类型 struct { B, A int } // 字段顺序改变无影响，按名称匹配 struct { A, B, C int } // 忽略多出的字段C struct { B int } // 忽略缺少的字段A，会丢弃A的值 struct { B, C int } // 忽略缺少的字段A，忽略多出的字段C
但尝试发送给如下类型的话就会导致错误： struct { A int; B uint } // B字段改变了符号类型 struct { A int; B float } // B字段改变了类型 struct { } // 无共同字段名 struct { C, D int } // 无共同字段名
首先来看一个关于encode/decode结构体数据类型的示例。仔细观察这个例子，有助理解上面所说的发送端和接收端之间字段匹配的问题。
type P struct { X, Y, Z int Name string } type Q struct { X, Y *int32 Name string } type R struct { Y, W int } // This example shows the basic usage of the package: Create an encoder, // transmit some values, receive them with a decoder. func GobBasic() { // 初始化 encoder 和 decoder var buf bytes.Buffer encoder := gob.NewEncoder(&buf) // will write to buf decoder := gob.NewDecoder(&buf) // will read from buf // Encode (send) some values err := encoder.Encode(P{X: 3, Y: 4, Z: 5, Name: "hello"}) if err != nil { log.Fatal("Encode error:",err) }
// case 1
// Decode (receive) and print the values //var q Q //err = decoder.Decode(&q) //if err != nil { // log.Fatal("Decode error:",err) //} // //// 注意，不能写成 q.X，因为在接收方，定义的是 int型 指针 //// *(q.X) 与 *q.Y 结果相同，但前者语义更加明确 //fmt.Printf("%d %d %s ", *(q.X), *q.Y, q.Name) //case 2
//var p P //err = decoder.Decode(&p) //if err != nil { // log.Fatal("Decode error:",err) //} //// 这里的接收方和传入方格式完全一致 //fmt.Printf("%d %d %d %s ", p.X, p.Y, p.Z, p.Name)
// case 3 var r R err = decoder.Decode(&r) if err != nil { log.Fatal("Decode error:",err) } //fmt.Printf("%d %d %d %s ", r.X, r.Y, r.Z, r.Name) // 会输出如下：因为接收端是根据字段名称进行匹配的 // r.X undefined (type R has no field or method X) // r.Z undefined (type R has no field or method Z) // r.Name undefined (type R has no field or method Name) fmt.Printf("%d ", r.Y) // ok }
接着我们看一下encode/decode 接口类型的值是如何操作的。与其他常规的类型（比如结构体）最大的不同在于：需要注册一个明确的实现该接口的类型。
示例如下：
type Point struct { X, Y int } func (p Point) Hypotenuse() float64 { // Hypot returns Sqrt(p*p + q*q) return math.Hypot(float64(p.X), float64(p.Y)) } type Pythagoras interface { Hypotenuse() float64 } // 这个例子展示了如何 encode/decode 一个接口类型(interface{})的值 // 与其他常规的类型（比如结构体）最大的不同在于： // 需要注册一个明确的实现该接口的类型 func GobInterface() { // 我们必须要对encoder和decoder注册具体的类型， // 因为通常来说，decoder和encoder是在不同的机器上的。 // 经过“注册”，解析引擎才能知道实现这一接口的具体类型是什么 // （因为同一个接口可以有多种不同的实现） gob.Register(Point{}) p1 := Point{X: 3, Y: 4} fmt.Println(p1.Hypotenuse()) // 5 // 编码，再解码，观察解码后返回的结果是否一致 b, _ := encode(p1) p2, _ := decode(b) fmt.Println(p2.Hypotenuse()) // 5 } // 编码，把结构体数据编码成字节流数据 func encode(p Pythagoras) ([]byte, error) { var buf bytes.Buffer encoder := gob.NewEncoder(&buf) // 构造编码器，并把数据写进buf中 if err := encoder.Encode(&p); err != nil { log.Printf("encode error: %v ", err) return nil, err } return buf.Bytes(), nil } // 解码，把字节流数据解析成结构体数据 func decode(b []byte) (Pythagoras, error) { //var buf bytes.Buffer bufPtr := bytes.NewBuffer(b) // 返回的类型是 *Buffer，而不是 Buffer。注意一下 decoder := gob.NewDecoder(bufPtr) // 从 bufPtr 中获取数据 var p Pythagoras if err := decoder.Decode(&p); err != nil { // 将数据写进变量 p 中 return Point{}, err } return p, nil }