JSON 和处理未导出字段

为什么编码/json 不包含未导出的字段，是否有技术原因？如果没有，这是一个武断的决定，是否可能有一个额外的后门选项(如’+’) ，包括即使未导出？

要求客户端代码导出以获得此功能感觉很不幸，特别是如果小写字母提供封装或决定封送结构比设计结构晚得多。

人们是怎么处理这个的? 把所有东西都输出去？

另外，导出字段名不会使得跟随建议的习惯用法变得困难吗。我认为如果 structX 有字段 Y，那么就不能有访问器方法 Y ()。如果您想要提供对 Y 的接口访问，那么您必须为 getter 提供一个新的名称，无论您得到的是什么，根据 http://golang.org/doc/effective_go.html#Getters，都是不惯用的

50630 次浏览
小开
最佳答案

There is a technical reason. The json library does not have the power to view fields using reflect unless they are exported. A package can only view the unexported fields of types within its own package

In order to deal with your problem, what you can do is make an unexported type with exported fields. Json will unmarshal into an unexported type if passed to it without a problem but it would not show up in the API docs. You can then make an exported type that embeds the unexported type. This exported type would then need methods to implement the json.Marshaler and json.Unmarshaler interfaces.

Note: all code is untested and may not even compile.

type jsonData struct {
Field1 string
Field2 string
}


type JsonData struct {
jsonData
}


// Implement json.Unmarshaller
func (d *JsonData) UnmarshalJSON(b []byte) error {
return json.Unmarshal(b, &d.jsonData)
}


// Getter
func (d *JsonData) Field1() string {
return d.jsonData.Field1
}
小开

Stephen's answer is complete. As an aside, if all you really want is lowercase keys in your json, you can manually specify the key name as follows:

type Whatever struct {
SomeField int `json:"some_field"`
}

In that way, marshaling a Whatever produces the key "some_field" for the field SomeField (instead of having "SomeField" in your json).

If you're dead-set on keeping unexported fields, you can also implement the json.Marshaler interface by defining a method with the signature MarshalJSON() ([]byte, error). One way to do this is to use a struct literal that simply has exported versions of the unexported fields, like this:

type Whatever struct {
someField int
}


func (w Whatever) MarshalJSON() ([]byte, error) {
return json.Marshal(struct{
SomeField int `json:"some_field"`
}{
SomeField: w.someField,
})
}

That can be a bit cumbersome, so you can also use a map[string]interface{} if you prefer:

func (w Whatever) MarshalJSON() ([]byte, error) {
return json.Marshal(map[string]interface{}{
"some_field": w.SomeField,
})
}

However it should be noted that marshaling interface{} has some caveats and can do things like marshal uint64 to a float, causing a loss of precision. (all code untested)


提交答案