>

字数 505 阅读 12 评论 6

虽然 encoding/json 包提供了 Marshal 和 Unmarshal 两个函数用来处理 json 对象的编解码，但是对于批量的 json 文件编解码来说，这两个函数就会显得效率不高。 因此，json package 还提供了用于流式处理 JSON 数据的类型 Decoder 和 Encoder, 他们可以批量的编解码 json 文件。

NewEncoder() 和 NewDecoder() 两个函数可以用来生成这两种类型：

1
2
3
4
5
6
7
func NewDecoder(r io.Reader) *Decoder{
    return &Decoder{r: r}
}

func NewEncoder(w io.Writer) *Encoder{
    return &Encoder{w: w, escapeHTML: true}
}

Decoder 和 Encoder 的原型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// A Decoder reads and decodes JSON values from an input stream.
type Decoder struct {
    r     io.Reader
    buf   []byte
    d     decodeState
    scanp int // start of unread data in buf
    scan  scanner
    err   error

    tokenState int
    tokenStack []int
}

// An Encoder writes JSON values to an output stream.
type Encoder struct {
    w          io.Writer
    err        error
    escapeHTML bool

    indentBuf    *bytes.Buffer
    indentPrefix string
    indentValue  string
}

上述两个结构体有两个函数 Encode() 和 Decode() 用来进行编解码。

  • Decode 从流中读取一个 json 数据， 解析后保存到 v 对象中
  • Encode 把本地的 v 对象转换成 json 数据后， 写到流中。
    传入的参数是一个 io.Reader 类型， 很多类型都是 io.Reader 的 duck type， 比如 os.Stdin, bytes.Buffer 等。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Decode reads the next JSON-encoded value from its input and stores it in the value pointed to by v.
// acts like UnMarshal
func (dec *Decoder) Decode(v interface{}) error {
    ...
    err = dec.d.unmarshal(v)
    ...
}


// Encode writes the JSON encoding of v to the stream, followed by a newline character.
// acts like Marshal
func (enc *Encoder) Encode(v interface{}) error {
    ...
    e := newEncodeState()
    err := e.marshal(v, encOpts{escapeHTML: enc.escapeHTML})
    if err != nil {
        return err
    }
       ...
}

注：Decode 相当于 Unmarshal， Encode 相当于 Marshal。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
type Dog struct {
    Name string
    Age  int
}

type Car struct {
    Engine string
    Count  int
}

func main() {

    // 1. Decode
    var data = []byte(`{"Name":"jemy","Age":26}{"Engine":"Power","Count":4}`)
    var d Dog
    var c Car

    decoder := json.NewDecoder(bytes.NewReader(data))
    decoder.Decode(&d)
    decoder.Decode(&c)

    // 2. Encode
    var dog = Dog{"jemy", 26,}
    var car = Car{"Power", 4}

    buffer := bytes.NewBuffer(nil)
    encoder := json.NewEncoder(buffer)
    err := encoder.Encode(&dog)
    err := encoder.Encode(&car)

}



更多例子：
http://golanghome.com/post/868