struct { A, B int }

struct { A, B int } // 相同
*struct { A, B int } // 結(jié)構(gòu)的額外間接
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）；數(shù)據(jù)從數(shù)據(jù)流中將被刪除
struct { B, C int } 	// 忽略缺失字段（A）；忽略額外字段（C）。

struct { A int; B uint } 	// 改變 B 的符號
struct { A int; B float } 	// 改變 B 的類型
struct { } 					// 沒有共同的字段名稱
struct { C, D int } 		// 沒有共同的字段名稱

var u uint
if i < 0 {
	u = (^uint(i) << 1) | 1 // complement i, bit 0 is 1
} else {
	u = (uint(i) << 1) // do not complement i, bit 0 is 0
}
encodeUnsigned(u)

type wireType struct {
	ArrayT           *arrayType
	SliceT           *sliceType
	StructT          *structType
	MapT             *mapType
	GobEncoderT      *gobEncoderType
	BinaryMarshalerT *gobEncoderType
	TextMarshalerT   *gobEncoderType
}
type arrayType struct {
	CommonType
	Elem typeId
	Len  int
}
type CommonType struct {
	Name string // the name of the struct type
	Id  int    // the id of the type, repeated so it's inside the type
}
type sliceType struct {
	CommonType
	Elem typeId
}
type structType struct {
	CommonType
	Field []fieldType // the fields of the struct.
}
type fieldType struct {
	Name string // the name of the field.
	Id   int    // the type id of the field, which must be already defined
}
type mapType struct {
	CommonType
	Key  typeId
	Elem typeId
}
type gobEncoderType struct {
	CommonType
}

bool        1
int         2
uint        3
float       4
[]byte      5
string      6
complex     7
interface   8
// gap for reserved ids.
WireType    16
ArrayType   17
CommonType  18
SliceType   19
StructType  20
FieldType   21
// 22 is slice of fieldType.
MapType     23

(byteCount (-type id, encoding of a wireType)* (type id, encoding of a value))*

// Register 記錄 value 具體值對應(yīng)的類型和其名稱。
// 該名稱將用來識別發(fā)送或接受接口類型值時下層的具體類型。
// 本函數(shù)只應(yīng)在初始化時調(diào)用，如果類型和名字的映射不是一一對應(yīng)的，會 panic。
func Register(value any)

// RegisterName 與 Register 類似，但使用提供的名稱而不是類型的默認名稱。
func RegisterName(name string, value any)

type Animal interface { Speak() string }
type Dog struct { Name string }
type Cat struct { Name string }

func init() {
    gob.Register(Dog{}) // 必須注冊
    gob.Register(Cat{}) // 必須注冊
}

func send(a Animal) {
    // 編碼時，Gob 需要知道 a 的具體類型是 Dog 還是 Cat
    // 通過注冊表，可以找到 Dog 或 Cat 的類型標(biāo)識符
}

// NewEncoder 返回一個將在 io.Writer 上傳輸?shù)男戮幋a器。
func NewEncoder(w io.Writer) *Encoder

// Encode 會傳輸接口值所表示的數(shù)據(jù)項，并保證所有必要的類型信息都已傳輸完畢。
// 向 Encoder 傳遞一個 nil 指針會導(dǎo)致 panic，因為 gob 無法傳輸此類數(shù)據(jù)。
func (enc *Encoder) Encode(e any) error

// EncodeValue 傳輸反射值所表示的數(shù)據(jù)項，并保證所有必要的類型信息都已傳輸完畢。
// 將 nil 指針傳遞給 EncodeValue 會導(dǎo)致 panic，因為它們無法通過 gob 傳輸。
func (enc *Encoder) EncodeValue(value reflect.Value) error

// NewDecoder 返回一個從 io.Reader 讀取數(shù)據(jù)的新解碼器。
// 如果 r 未實現(xiàn) io.ByteReader 接口，則會將其包裝在 bufio.Reader 中。
func NewDecoder(r io.Reader) *Decoder

// Decode 從輸入流中讀取下一個值，并將其存儲在空接口值所表示的數(shù)據(jù)中。
// 如果 e 為 nil，則該值將被丟棄。否則，e 的底層值必須是指向下一個接收數(shù)據(jù)項的正確類型的指針。
// 如果輸入位于 EOF，解碼將返回 io.EOF 并且不修改 e。
func (dec *Decoder) Decode(e any) error

// DecodeValue 從輸入流中讀取下一個值。
// 如果 v 為零的 reflect.Value（v.Kind() == Invalid），DecodeValue 會丟棄該值。否則，它會將值存儲到 v 中。在這種情況下，v 必須表示一個指向數(shù)據(jù)的非零指針，或者是一個可賦值的 reflect.Value（v.CanSet()）。
// 如果輸入位于 EOF，DecodeValue 會返回 io.EOF 并且不會修改 v。
func (dec *Decoder) DecodeValue(v reflect.Value) error

package main

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

type Person struct {
    Name string
    Age  int
}

func main() {
    // 創(chuàng)建數(shù)據(jù)
    alice := Person{Name: "Alice", Age: 30}
    
    // 序列化
    var buf bytes.Buffer
    encoder := gob.NewEncoder(&buf)
    if err := encoder.Encode(alice); err != nil {
        log.Fatal("Encode error:", err)
    }
    
    fmt.Printf("Serialized data: %x\n", buf.Bytes())
    
    // 反序列化
    var bob Person
    decoder := gob.NewDecoder(&buf)
    if err := decoder.Decode(&bob); err != nil {
        log.Fatal("Decode error:", err)
    }
    
    fmt.Printf("Deserialized: %+v\n", bob)
}

package main

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

type Animal interface {
	Sound() string
}

type Dog struct{ Name string }

func (d Dog) Sound() string { return "Woof!" }

type Cat struct{ Name string }

func (c Cat) Sound() string { return "Meow!" }

func interfaceExample() {
	// 注冊具體類型
	gob.Register(Dog{})
	gob.Register(Cat{})

	animals := []Animal{
		Dog{Name: "Rex"},
		Cat{Name: "Whiskers"},
	}

	// 序列化
	var buf bytes.Buffer
	if err := gob.NewEncoder(&buf).Encode(animals); err != nil {
		log.Fatal(err)
	}

	// 反序列化
	var decoded []Animal
	if err := gob.NewDecoder(&buf).Decode(&decoded); err != nil {
		log.Fatal(err)
	}

	for _, a := range decoded {
		fmt.Printf("%T: %s says %s\n", a, a.(interface{ GetName() string }).GetName(), a.Sound())
	}
}

// 為類型添加GetName方法以便類型斷言
func (d Dog) GetName() string { return d.Name }
func (c Cat) GetName() string { return c.Name }

func main() {
	interfaceExample()
}

gob: type not registered for interface: main.Dog

func fileStorage() {
    type Config struct {
        APIKey string
        Port   int
    }
    
    cfg := Config{APIKey: "secret123", Port: 8080}
    
    // 寫入文件
    file, err := os.Create("config.gob")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()
    
    if err := gob.NewEncoder(file).Encode(cfg); err != nil {
        log.Fatal(err)
    }
    
    // 從文件讀取
    file, err = os.Open("config.gob")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()
    
    var loaded Config
    if err := gob.NewDecoder(file).Decode(&loaded); err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("Loaded config: %+v\n", loaded)
}

package main

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

// Vector 類型實現(xiàn)了BinaryMarshal/BinaryUnmarshal 方法，這樣我們就可以發(fā)送和接受 gob 類型的數(shù)據(jù)。
type Vector struct {
	x, y, z int
}

func (v Vector) MarshalBinary() ([]byte, error) {
	// A simple encoding: plain text.
	var b bytes.Buffer
	_, _ = fmt.Fprintln(&b, v.x, v.y, v.z)
	return b.Bytes(), nil
}

// UnmarshalBinary 修改接收器，所以必須要傳遞指針類型
func (v *Vector) UnmarshalBinary(data []byte) error {
	// A simple encoding: plain text.
	b := bytes.NewBuffer(data)
	_, err := fmt.Fscanln(b, &v.x, &v.y, &v.z)
	return err
}

// 此示例傳輸實現(xiàn)自定義編碼和解碼方法的值。
func main() {
	var network bytes.Buffer
	// 創(chuàng)建一個編碼器發(fā)送數(shù)據(jù)
	enc := gob.NewEncoder(&network)
	err := enc.Encode(Vector{3, 4, 5})
	if err != nil {
		log.Fatal("encode:", err)
	}
	
	// 創(chuàng)建一個解碼器接收數(shù)據(jù)
	dec := gob.NewDecoder(&network)
	var v Vector
	err = dec.Decode(&v)
	if err != nil {
		log.Fatal("decode:", err)
	}
	fmt.Printf("%#v\n", v)
}

type Complex struct {
    Slice  []*int
    Map    map[string]chan struct{}
    Func   func() // 不支持！
}
// 自動支持：切片、指針、映射、結(jié)構(gòu)體嵌套

// V1 結(jié)構(gòu)
type User struct { ID int; Name string }

// V2 結(jié)構(gòu)（添加字段）
type User struct { ID int; Name string; Email string }

// V1 數(shù)據(jù) → V2 解碼：Email 自動置零值

// 舊版本
type Config struct { Host string; Port int }

// 新版本（字段調(diào)序）仍可兼容
type Config struct { Port int; Host string }

type Node struct {
    Value int
    Next  *Node // 循環(huán)指針
}

n1 := &Node{Value: 1}
n2 := &Node{Value: 2, Next: n1}
n1.Next = n2 // 循環(huán)引用

// Gob 完美序列化/反序列化

type Encoder interface { Encode() []byte }

func main() {
    var enc Encoder = MyEncoder{}
    gob.Register(MyEncoder{}) // 必須!
    gob.Encode(enc)
}

// 不可信來源的gob數(shù)據(jù)可能：
// 1. 導(dǎo)致內(nèi)存耗盡（大容器攻擊）
// 2. 觸發(fā)未預(yù)期類型重建
// 3. 暴露私有字段（通過反射）

// 兼容性示例
type V1 struct { A int }
type V2 struct { 
    A int 
    B string // 新增字段在末尾
}

// 調(diào)試編碼數(shù)據(jù)
fmt.Printf("%x\n", buf.Bytes())

// 或者轉(zhuǎn)換為字符串查看（可能包含可讀內(nèi)容）
fmt.Println(buf.String())