Question

在编组时如何确保包含此LookupCode结构中的字段？

package main

import (
    "encoding/json"
    "fmt"
)

type LookupCode struct {
    code string `json:"code"`
    name string `json:"name"`
}

func (l *LookupCode) GetCode() string {
    return l.code
}

func main() {
    c := &LookupCode{
        code: "A",
        name: "Apple",
    }

    b, _ := json.MarshalIndent(c, "", "\t")

    fmt.Println(string(b))
}

http://play.golang.org/p/my52DAn0-Z

Answer 1

您可以通过实现json.Marshaller接口：

完整示例：http://play.golang.org/p/8mIcPwX92P

// Implement json.Unmarshaller
func (l *LookupCode) UnmarshalJSON(b []byte) error {
    var tmp struct {
        Code string `json:"code"`
        Name string `json:"name"`
    }
    err := json.Unmarshal(b, &tmp)
    if err != nil {
        return err
    }
    l.code = tmp.Code
    l.name = tmp.Name
    return nil 
}

func (l *LookupCode) MarshalJSON() ([]byte, error) {
    return json.Marshal(struct {
        Code string `json:"code"`
        Name string `json:"name"`
    }{
        Code: l.code,
        Name: l.name,
    })
}

Answer 2

encode/json无法封送未导出的字段。将您的代码更改为：

type LookupCode struct {
    Code string `json:"code"`
    Name string `json:"name"`
}

并在您使用code或name的任何地方执行相同操作。

游乐场：http://play.golang.org/p/rak0nVCNGI

修改

限制是由于编组结构时使用的反射。如果您需要保持未导出的值，则必须实现json.Marshaller interface并手动执行编码。

Answer 3

如果结构具有仅字符串类型字段，则可以尝试此 hack 方式。

package main

import (
    "fmt"
    "reflect"

    "github.com/bitly/go-simplejson"
)

type A struct {
    name string `json:"name"`
    code string `json:"code"`
}

func marshal(a A) ([]byte, error) {
    j := simplejson.New()
    va := reflect.ValueOf(&a)
    vt := va.Elem()
    types := reflect.TypeOf(a)
    for i := 0; i < vt.NumField(); i++ {
        j.Set(types.Field(i).Tag.Get("json"), fmt.Sprintf("%v", reflect.Indirect(va).Field(i)))
    }
    return j.MarshalJSON()
}

func main() {
    a := A{name: "jessonchan", code: "abc"}
    b, _ := marshal(a)
    fmt.Println(string(b))
}

如何在某些成员受保护/内部/隐藏时编组结构

3 个答案: