英文:
Removing fields from struct or hiding them in JSON Response
问题
我在Go中创建了一个API，当被调用时，执行一个查询，创建一个结构的实例，然后将该结构编码为JSON并发送回调用者。现在，我想允许调用者通过传递一个"fields" GET参数来选择他们想要返回的特定字段。
这意味着根据字段的值，我的结构会发生变化。有没有办法从结构中删除字段？或者至少在JSON响应中动态隐藏它们？（注意：有时我有空值，所以JSON omitEmpty标签在这里不起作用）如果这两个都不可能，是否有更好的处理方式的建议？
我使用的结构的较小版本如下：
type SearchResult struct {Date string `json:"date"`IdCompany int `json:"idCompany"`Company string `json:"company"`IdIndustry interface{} `json:"idIndustry"`Industry string `json:"industry"`IdContinent interface{} `json:"idContinent"`Continent string `json:"continent"`IdCountry interface{} `json:"idCountry"`Country string `json:"country"`IdState interface{} `json:"idState"`State string `json:"state"`IdCity interface{} `json:"idCity"`City string `json:"city"`} //SearchResulttype SearchResults struct {NumberResults int `json:"numberResults"`Results []SearchResult `json:"results"`} //type SearchResults
然后像这样编码和输出响应：
err := json.NewEncoder(c.ResponseWriter).Encode(&msg)
英文:
I've created an API in Go that, upon being called, performs a query, creates an instance of a struct, and then encodes that struct as JSON before sending back to the caller. I'd now like to allow the caller to be able to select the specific fields they would like returned by passing in a "fields" GET parameter.
This means depending on the fields value(s), my struct would change. Is there any way to remove fields from a struct? Or at least hide them in the JSON response dynamically? (Note: Sometimes I have empty values so the JSON omitEmpty tag will not work here) If neither of these are possible, is there a suggestion on a better way to handle this?
A smaller version of the structs I'm using are below:
type SearchResult struct {Date string `json:"date"`IdCompany int `json:"idCompany"`Company string `json:"company"`IdIndustry interface{} `json:"idIndustry"`Industry string `json:"industry"`IdContinent interface{} `json:"idContinent"`Continent string `json:"continent"`IdCountry interface{} `json:"idCountry"`Country string `json:"country"`IdState interface{} `json:"idState"`State string `json:"state"`IdCity interface{} `json:"idCity"`City string `json:"city"`} //SearchResulttype SearchResults struct {NumberResults int `json:"numberResults"`Results []SearchResult `json:"results"`} //type SearchResults
I then encode and output the response like so:
err := json.NewEncoder(c.ResponseWriter).Encode(&msg)
答案1
得分: 450
问题是要求根据调用者提供的字段列表动态选择字段。这是不可能通过静态定义的json结构标签来实现的。
如果你想要始终跳过一个字段进行json编码，那么当然可以使用json:"-"来忽略该字段。（请注意，如果字段未导出，则json编码器始终会忽略这些字段，因此不需要使用json:"-"。）但这不是问题所问的。
引用json:"-"答案的评论：
> 这个（json:"-答案）是大多数通过搜索到达这里的人想要的答案，但它不是问题的答案。
在这种情况下，我会使用map[string]interface{}而不是结构体。你可以通过在要删除的字段上调用内置的delete函数来轻松删除字段。
也就是说，如果你不能一开始就只查询所请求的字段。
英文:
The question is asking for fields to be dynamically selected based on the caller-provided list of fields. This isn't possible to be done with the statically-defined json struct tag.
If what you want is to always skip a field to json-encode, then of course use json:"-" to ignore the field. (Note also that this is not required if your field is unexported; those fields are always ignored by the json encoder.) This isn't what the question asks.
To quote the comment on the json:"-" answer:
> This [the json:"-" answer] is the answer most people ending up here from searching would want, but it's not the answer to the question.
I'd use a map[string]interface{} instead of a struct in this case. You can easily remove fields by calling the delete built-in on the map for the fields to remove.
That is, if you can't query only for the requested fields in the first place.
答案2
得分: 234
使用 `json:"-"`
// 该字段被此包忽略。Field int `json:"-"`// 该字段在JSON中以键"myName"出现。Field int `json:"myName"`// 该字段在JSON中以键"myName"出现，并且如果其值为空，则从对象中省略该字段，如上所定义。Field int `json:"myName,omitempty"`// 该字段在JSON中以键"Field"（默认）出现，但如果为空，则跳过该字段。// 注意前导逗号。Field int `json:",omitempty"`
文档：http://golang.org/pkg/encoding/json/#Marshal
英文:
use `json:"-"`
// Field is ignored by this package.Field int `json:"-"`// Field appears in JSON as key "myName".Field int `json:"myName"`// Field appears in JSON as key "myName" and// the field is omitted from the object if its value is empty,// as defined above.Field int `json:"myName,omitempty"`// Field appears in JSON as key "Field" (the default), but// the field is skipped if empty.// Note the leading comma.Field int `json:",omitempty"`
答案3
得分: 80
另一种方法是使用带有,omitempty标签的指针结构体。如果指针为nil，则字段将不会被编组。
这种方法不需要额外的反射或低效的映射使用。
使用此方法的相同示例：http://play.golang.org/p/JJNa0m2_nw
英文:
Another way to do this is to have a struct of pointers with the ,omitempty tag. If the pointers are nil, the fields won't be Marshalled.
This method will not require additional reflection or inefficient use of maps.
Same example as jorelli using this method: http://play.golang.org/p/JJNa0m2_nw
答案4
得分: 19
你可以使用reflect包来通过反射字段标签并选择json标签值来选择你想要的字段。在你的SearchResults类型上定义一个方法，该方法选择你想要的字段并将它们作为map[string]interface{}返回，然后将该对象编组而不是SearchResults结构本身。以下是如何定义该方法的示例：
func fieldSet(fields ...string) map[string]bool {set := make(map[string]bool, len(fields))for _, s := range fields {set展开收缩= true}return set}func (s *SearchResult) SelectFields(fields ...string) map[string]interface{} {fs := fieldSet(fields...)rt, rv := reflect.TypeOf(*s), reflect.ValueOf(*s)out := make(map[string]interface{}, rt.NumField())for i := 0; i < rt.NumField(); i++ {field := rt.Field(i)jsonKey := field.Tag.Get("json")if fs[jsonKey] {out[jsonKey] = rv.Field(i).Interface()}}return out}
这是一个可运行的解决方案，展示了如何调用这个方法并编组你的选择：http://play.golang.org/p/1K9xjQRnO8
英文:
You can use the reflect package to select the fields that you want by reflecting on the field tags and selecting the json tag values. Define a method on your SearchResults type that selects the fields you want and returns them as a map[string]interface{}, and then marshal that instead of the SearchResults struct itself. Here's an example of how you might define that method:
func fieldSet(fields ...string) map[string]bool {set := make(map[string]bool, len(fields))for _, s := range fields {set展开收缩= true}return set}func (s *SearchResult) SelectFields(fields ...string) map[string]interface{} {fs := fieldSet(fields...)rt, rv := reflect.TypeOf(*s), reflect.ValueOf(*s)out := make(map[string]interface{}, rt.NumField())for i := 0; i < rt.NumField(); i++ {field := rt.Field(i)jsonKey := field.Tag.Get("json")if fs[jsonKey] {out[jsonKey] = rv.Field(i).Interface()}}return out}
and here's a runnable solution that shows how you would call this method and marshal your selection: http://play.golang.org/p/1K9xjQRnO8
答案5
得分: 9
使用三个组件：
-
reflect包来遍历结构体的所有字段。 -
if语句来选择要Marshal的字段。 -
encoding/json包来Marshal你喜欢的字段。
准备工作：
-
按照适当的比例混合它们。使用
reflect.TypeOf(your_struct).Field(i).Name()来获取your_struct的第i个字段的名称。 -
使用
reflect.ValueOf(your_struct).Field(i)来获取your_struct的第i个字段的类型Value表示。 -
使用
fieldValue.Interface()来检索fieldValue的实际值（向上转型为interface{}类型）（注意括号的使用 - Interface() 方法 产生interface{}）。
如果你幸运地在这个过程中没有烧毁任何晶体管或断路器，你应该得到类似这样的结果：
func MarshalOnlyFields(structa interface{},includeFields map[string]bool) (jsona []byte, status error) {value := reflect.ValueOf(structa)typa := reflect.TypeOf(structa)size := value.NumField()jsona = append(jsona, '{')for i := 0; i < size; i++ {structValue := value.Field(i)var fieldName string = typa.Field(i).Nameif marshalledField, marshalStatus := json.Marshal((structValue).Interface()); marshalStatus != nil {return []byte{}, marshalStatus} else {if includeFields[fieldName] {jsona = append(jsona, '"')jsona = append(jsona, []byte(fieldName)...)jsona = append(jsona, '"')jsona = append(jsona, ':')jsona = append(jsona, (marshalledField)...)if i+1 != len(includeFields) {jsona = append(jsona, ',')}}}}jsona = append(jsona, '}')return}
服务：
使用任意结构体和一个包含要包含的字段的 map[string]bool，例如
type magic struct {Magic1 intMagic2 stringMagic3 [2]int}func main() {var magic = magic{0, "tusia", [2]int{0, 1}}if json, status := MarshalOnlyFields(magic, map[string]bool{"Magic1": true}); status != nil {println("error")} else {fmt.Println(string(json))}}
Bon Appetit!
英文:
Take three ingredients:
-
The
reflectpackage to loop over all the fields of a struct. -
An
ifstatement to pick up the fields you want toMarshal, and -
The
encoding/jsonpackage toMarshalthe fields of your liking.
Preparation:
-
Blend them in a good proportion. Use
reflect.TypeOf(your_struct).Field(i).Name()to get a name of theith field ofyour_struct. -
Use
reflect.ValueOf(your_struct).Field(i)to get a typeValuerepresentation of anith field ofyour_struct. -
Use
fieldValue.Interface()to retrieve the actual value (upcasted to type interface{}) of thefieldValueof typeValue(note the bracket use - the Interface() method producesinterface{}
If you luckily manage not to burn any transistors or circuit-breakers in the process you should get something like this:
func MarshalOnlyFields(structa interface{},includeFields map[string]bool) (jsona []byte, status error) {value := reflect.ValueOf(structa)typa := reflect.TypeOf(structa)size := value.NumField()jsona = append(jsona, '{')for i := 0; i < size; i++ {structValue := value.Field(i)var fieldName string = typa.Field(i).Nameif marshalledField, marshalStatus := json.Marshal((structValue).Interface()); marshalStatus != nil {return []byte{}, marshalStatus} else {if includeFields[fieldName] {jsona = append(jsona, '"')jsona = append(jsona, []byte(fieldName)...)jsona = append(jsona, '"')jsona = append(jsona, ':')jsona = append(jsona, (marshalledField)...)if i+1 != len(includeFields) {jsona = append(jsona, ',')}}}}jsona = append(jsona, '}')return}
Serving:
serve with an arbitrary struct and a map[string]bool of fields you want to include, for example
type magic struct {Magic1 intMagic2 stringMagic3 [2]int}func main() {var magic = magic{0, "tusia", [2]int{0, 1}}if json, status := MarshalOnlyFields(magic, map[string]bool{"Magic1": true}); status != nil {println("error")} else {fmt.Println(string(json))}}
Bon Appetit!
答案6
得分: 9
我刚刚发布了sheriff，它可以根据在结构体字段上注释的标签将结构体转换为基于映射的形式。然后，您可以将生成的映射进行编组（JSON或其他格式）。它可能不允许您仅序列化调用者请求的字段集，但我想使用一组组可能可以涵盖大多数情况。与直接使用字段相比，使用组很可能还会增加缓存能力。
示例：
package mainimport ("encoding/json""fmt""log""github.com/hashicorp/go-version""github.com/liip/sheriff")type User struct {Username string `json:"username" groups:"api"`Email string `json:"email" groups:"personal"`Name string `json:"name" groups:"api"`Roles []string `json:"roles" groups:"api" since:"2"`}func main() {user := User{Username: "alice",Email: "alice@example.org",Name: "Alice",Roles: []string{"user", "admin"},}v2, err := version.NewVersion("2.0.0")if err != nil {log.Panic(err)}o := &sheriff.Options{Groups: []string{"api"},ApiVersion: v2,}data, err := sheriff.Marshal(o, user)if err != nil {log.Panic(err)}output, err := json.MarshalIndent(data, "", " ")if err != nil {log.Panic(err)}fmt.Printf("%s", output)}
英文:
I just published sheriff, which transforms structs to a map based on tags annotated on the struct fields. You can then marshal (JSON or others) the generated map. It probably doesn't allow you to only serialize the set of fields the caller requested, but I imagine using a set of groups would allow you to cover most cases. Using groups instead of the fields directly would most likely also increase cache-ability.
Example:
package mainimport ("encoding/json""fmt""log""github.com/hashicorp/go-version""github.com/liip/sheriff")type User struct {Username string `json:"username" groups:"api"`Email string `json:"email" groups:"personal"`Name string `json:"name" groups:"api"`Roles []string `json:"roles" groups:"api" since:"2"`}func main() {user := User{Username: "alice",Email: "alice@example.org",Name: "Alice",Roles: []string{"user", "admin"},}v2, err := version.NewVersion("2.0.0")if err != nil {log.Panic(err)}o := &sheriff.Options{Groups: []string{"api"},ApiVersion: v2,}data, err := sheriff.Marshal(o, user)if err != nil {log.Panic(err)}output, err := json.MarshalIndent(data, "", " ")if err != nil {log.Panic(err)}fmt.Printf("%s", output)}
答案7
得分: 8
我创建了这个函数来将结构体转换为JSON字符串，可以忽略一些字段。希望能对你有所帮助。
func GetJSONString(obj interface{}, ignoreFields ...string) (string, error) {toJson, err := json.Marshal(obj)if err != nil {return "", err}if len(ignoreFields) == 0 {return string(toJson), nil}toMap := map[string]interface{}{}json.Unmarshal([]byte(string(toJson)), &toMap)for _, field := range ignoreFields {delete(toMap, field)}toJson, err = json.Marshal(toMap)if err != nil {return "", err}return string(toJson), nil}
示例：https://play.golang.org/p/nmq7MFF47Gp
英文:
I created this function to convert struct to JSON string by ignoring some fields. Hope it will help.
func GetJSONString(obj interface{}, ignoreFields ...string) (string, error) {toJson, err := json.Marshal(obj)if err != nil {return "", err}if len(ignoreFields) == 0 {return string(toJson), nil}toMap := map[string]interface{}{}json.Unmarshal([]byte(string(toJson)), &toMap)for _, field := range ignoreFields {delete(toMap, field)}toJson, err = json.Marshal(toMap)if err != nil {return "", err}return string(toJson), nil}
答案8
得分: 5
你可以使用标记属性"omitifempty"或将可选字段设置为指针，并将要跳过的字段保持未初始化。
英文:
You can use tagging attribute "omitifempty" or make optional fields pointers and leave those you want skipped uninitialized.
答案9
得分: 5
这是我定义结构的方式。
type User struct {Username string `json:"username" bson:"username"`Email string `json:"email" bson:"email"`Password *string `json:"password,omitempty" bson:"password"`FullName string `json:"fullname" bson:"fullname"`}
在我的函数中，使用user.Password = nil 来防止被编组。
英文:
Here is how I defined my structure.
type User struct {Username string `json:"username" bson:"username"`Email string `json:"email" bson:"email"`Password *string `json:"password,omitempty" bson:"password"`FullName string `json:"fullname" bson:"fullname"`}
And inside my function set user.Password = nil for not to be Marshalled.
答案10
得分: 3
这个问题现在有点老了，但是我之前遇到了同样的问题，由于找不到简单的方法来解决这个问题，所以我构建了一个满足这个目的的库。
它可以轻松地从一个静态结构生成一个map[string]interface{}。
https://github.com/tuvistavie/structomap
英文:
The question is now a bit old, but I came across the same issue a little while ago, and as I found no easy way to do this, I built a library fulfilling this purpose.
It allows to easily generate a map[string]interface{} from a static struct.
答案11
得分: 3
我没有同样的问题，但是类似。下面的代码也可以解决你的问题，当然如果你不介意性能问题的话。在将这种解决方案实施到你的系统之前，我建议你重新设计你的结构（如果可以的话）。发送变量结构响应是过度工程化的。我认为响应结构代表了请求和资源之间的契约，它不应该依赖于请求。（你可以将不需要的字段设置为null，我这样做）。在某些情况下，我们不得不实现这种设计，如果你认为你处于这种情况下，这里是play链接和我使用的代码。
type User2 struct {ID int `groups:"id" json:"id,omitempty"`Username string `groups:"username" json:"username,omitempty"`Nickname string `groups:"nickname" json:"nickname,omitempty"`}type User struct {ID int `groups:"private,public" json:"id,omitempty"`Username string `groups:"private" json:"username,omitempty"`Nickname string `groups:"public" json:"nickname,omitempty"`}var (tagName = "groups")//OmitFields通过检查它们的标签组值和访问控制标签（acTags）将字段设置为nilfunc OmitFields(obj interface{}, acTags []string) {//nilV := reflect.Value{}sv := reflect.ValueOf(obj).Elem()st := sv.Type()if sv.Kind() == reflect.Struct {for i := 0; i < st.NumField(); i++ {fieldVal := sv.Field(i)if fieldVal.CanSet() {tagStr := st.Field(i).Tag.Get(tagName)if len(tagStr) == 0 {continue}tagList := strings.Split(strings.Replace(tagStr, " ", "", -1), ",")//fmt.Println(tagList)// ContainsCommonItem检查数组中是否至少有一个公共项if !ContainsCommonItem(tagList, acTags) {fieldVal.Set(reflect.Zero(fieldVal.Type()))}}}}}//ContainsCommonItem检查数组是否至少有一个相等的项func ContainsCommonItem(arr1 []string, arr2 []string) bool {for i := 0; i < len(arr1); i++ {for j := 0; j < len(arr2); j++ {if arr1[i] == arr2[j] {return true}}}return false}func main() {u := User{ID: 1, Username: "very secret", Nickname: "hinzir"}//假设经过身份验证的用户没有权限访问私有字段OmitFields(&u, []string{"public"})bytes, _ := json.Marshal(&u)fmt.Println(string(bytes))u2 := User2{ID: 1, Username: "very secret", Nickname: "hinzir"}//你想通过字段名来过滤字段OmitFields(&u2, []string{"id", "nickname"})bytes, _ = json.Marshal(&u2)fmt.Println(string(bytes))}
英文:
I didn't have the same problem but similar. Below code solves your problem too, of course if you don't mind performance issue. Before implement that kind of solution to your system I recommend you to redesign your structure if you can. Sending variable structure response is over-engineering. I believe a response structure represents a contract between a request and resource and it should't be depend requests.(you can make un-wanted fields null, I do). In some cases we have to implement this design, if you believe you are in that cases here is the play link and code I use.
type User2 struct {ID int `groups:"id" json:"id,omitempty"`Username string `groups:"username" json:"username,omitempty"`Nickname string `groups:"nickname" json:"nickname,omitempty"`}type User struct {ID int `groups:"private,public" json:"id,omitempty"`Username string `groups:"private" json:"username,omitempty"`Nickname string `groups:"public" json:"nickname,omitempty"`}var (tagName = "groups")//OmitFields sets fields nil by checking their tag group value and access control tags(acTags)func OmitFields(obj interface{}, acTags []string) {//nilV := reflect.Value{}sv := reflect.ValueOf(obj).Elem()st := sv.Type()if sv.Kind() == reflect.Struct {for i := 0; i < st.NumField(); i++ {fieldVal := sv.Field(i)if fieldVal.CanSet() {tagStr := st.Field(i).Tag.Get(tagName)if len(tagStr) == 0 {continue}tagList := strings.Split(strings.Replace(tagStr, " ", "", -1), ",")//fmt.Println(tagList)// ContainsCommonItem checks whether there is at least one common item in arraysif !ContainsCommonItem(tagList, acTags) {fieldVal.Set(reflect.Zero(fieldVal.Type()))}}}}}//ContainsCommonItem checks if arrays have at least one equal itemfunc ContainsCommonItem(arr1 []string, arr2 []string) bool {for i := 0; i < len(arr1); i++ {for j := 0; j < len(arr2); j++ {if arr1[i] == arr2[j] {return true}}}return false}func main() {u := User{ID: 1, Username: "very secret", Nickname: "hinzir"}//assume authenticated user doesn't has permission to access private fieldsOmitFields(&u, []string{"public"})bytes, _ := json.Marshal(&u)fmt.Println(string(bytes))u2 := User2{ID: 1, Username: "very secret", Nickname: "hinzir"}//you want to filter fields by field namesOmitFields(&u2, []string{"id", "nickname"})bytes, _ = json.Marshal(&u2)fmt.Println(string(bytes))}
答案12
得分: 3
我也遇到了这个问题，起初我只是想在我的http处理程序中专门处理响应。我的第一个方法是创建一个包，将一个结构体的信息复制到另一个结构体中，然后将第二个结构体进行编组。我使用反射来实现这个包，所以从来不喜欢这种方法，而且我也不是动态的。
所以我决定修改encoding/json包来实现这个。函数Marshal、MarshalIndent和(Encoder) Encode还接收一个
type F map[string]F
我想模拟一个JSON，其中只有需要编组的字段，所以它只编组映射中的字段。
https://github.com/jtorz/jsont
package mainimport ("fmt""log""net/http""github.com/jtorz/jsont/v2")type SearchResult struct {Date string `json:"date"`IdCompany int `json:"idCompany"`Company string `json:"company"`IdIndustry interface{} `json:"idIndustry"`Industry string `json:"industry"`IdContinent interface{} `json:"idContinent"`Continent string `json:"continent"`IdCountry interface{} `json:"idCountry"`Country string `json:"country"`IdState interface{} `json:"idState"`State string `json:"state"`IdCity interface{} `json:"idCity"`City string `json:"city"`} //SearchResulttype SearchResults struct {NumberResults int `json:"numberResults"`Results []SearchResult `json:"results"`} //type SearchResultsfunc main() {msg := SearchResults{NumberResults: 2,Results: []SearchResult{{Date: "12-12-12",IdCompany: 1,Company: "alfa",IdIndustry: 1,Industry: "IT",IdContinent: 1,Continent: "america",IdCountry: 1,Country: "México",IdState: 1,State: "CDMX",IdCity: 1,City: "Atz",},{Date: "12-12-12",IdCompany: 2,Company: "beta",IdIndustry: 1,Industry: "IT",IdContinent: 1,Continent: "america",IdCountry: 2,Country: "USA",IdState: 2,State: "TX",IdCity: 2,City: "XYZ",},},}fmt.Println(msg)http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {//{"numberResults":2,"results":[{"date":"12-12-12","idCompany":1,"idIndustry":1,"country":"México"},{"date":"12-12-12","idCompany":2,"idIndustry":1,"country":"USA"}]}err := jsont.NewEncoder(w).Encode(msg, jsont.F{"numberResults": nil,"results": jsont.F{"date": nil,"idCompany": nil,"idIndustry": nil,"country": nil,},})if err != nil {log.Fatal(err)}})http.ListenAndServe(":3009", nil)}
英文:
I also faced this problem, at first I just wanted to specialize the responses in my http handler. My first approach was creating a package that copies the information of a struct to another struct and then marshal that second struct. I did that package using reflection, so, never liked that approach and also I wasn't dynamically.
So I decided to modify the encoding/json package to do this. The functions Marshal, MarshalIndent and (Encoder) Encode additionally receives a
type F map[string]F
I wanted to simulate a JSON of the fields that are needed to marshal, so it only marshals the fields that are in the map.
https://github.com/jtorz/jsont
package mainimport ("fmt""log""net/http""github.com/jtorz/jsont/v2")type SearchResult struct {Date string `json:"date"`IdCompany int `json:"idCompany"`Company string `json:"company"`IdIndustry interface{} `json:"idIndustry"`Industry string `json:"industry"`IdContinent interface{} `json:"idContinent"`Continent string `json:"continent"`IdCountry interface{} `json:"idCountry"`Country string `json:"country"`IdState interface{} `json:"idState"`State string `json:"state"`IdCity interface{} `json:"idCity"`City string `json:"city"`} //SearchResulttype SearchResults struct {NumberResults int `json:"numberResults"`Results []SearchResult `json:"results"`} //type SearchResultsfunc main() {msg := SearchResults{NumberResults: 2,Results: []SearchResult{{Date: "12-12-12",IdCompany: 1,Company: "alfa",IdIndustry: 1,Industry: "IT",IdContinent: 1,Continent: "america",IdCountry: 1,Country: "México",IdState: 1,State: "CDMX",IdCity: 1,City: "Atz",},{Date: "12-12-12",IdCompany: 2,Company: "beta",IdIndustry: 1,Industry: "IT",IdContinent: 1,Continent: "america",IdCountry: 2,Country: "USA",IdState: 2,State: "TX",IdCity: 2,City: "XYZ",},},}fmt.Println(msg)http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {//{"numberResults":2,"results":[{"date":"12-12-12","idCompany":1,"idIndustry":1,"country":"México"},{"date":"12-12-12","idCompany":2,"idIndustry":1,"country":"USA"}]}err := jsont.NewEncoder(w).Encode(msg, jsont.F{"numberResults": nil,"results": jsont.F{"date": nil,"idCompany": nil,"idIndustry": nil,"country": nil,},})if err != nil {log.Fatal(err)}})http.ListenAndServe(":3009", nil)}
答案13
得分: 1
<h1>根据结构体中的另一个字段动态更新/删除序列化的字段</h1>
<h2>也就是说，如果Hidden字段为true，则不序列化Content字段。或者，如果Hidden字段为true，则将Content设置为“未找到任何内容！”</h2>
<br>
<h4>示例：</h4>
对于以下结构体（其中CustomStruct是您拥有的任何自定义结构体）：
type Post struct {Hidden bool `json:"hidden"`Content string `json:"content"`Value CustomStruct `json:"value"`}
您可以根据Hidden的布尔值动态返回或不返回任何字段的值。
首先，为您的结构体创建一个别名：
type Alias Post
然后为该别名创建一个包装器：
type AuxPost struct {*Alias}
然后重写MarshalJSON方法（导入"encoding/json"包）：
func (p Post) MarshalJSON() ([]byte, error) {type Alias Postif p.Hidden {hiddenPost := struct {AliasContent string `json:"content"`Value bool `json:"value,omitempty"`}{Alias: (Alias)(p),Content: "[this post was removed]",Value: false,}return json.Marshal(hiddenPost)}regularPost := struct {Alias}{Alias: (Alias)(p),}return json.Marshal(regularPost)}
如果帖子的Hidden字段为true，则它将正常序列化。如果不是，则Content字段将被设置为"[this post was removed]"，并且Value字段将被完全省略（因为在这种特殊情况下我设置了omitempty）。
... Hidden为false时的序列化结果为：
{"hidden": true,"content": "hello world","value": {"note": "your custom struct can have anything"}}
... Hidden为true时的序列化结果为：
{"hidden": true,"content": "[this post was removed]"}
删除非结构体字段很简单，但是删除结构体的方式是通过欺骗它，使其认为它是一个布尔值，然后将该布尔值设置为false，并从序列化中省略零值（布尔值的零值为false）。
编辑：如果我们希望Value结构体只被序列化为null，我们需要删除omitempty标签，并将其类型（之前为bool）设置为*interface{}，然后将其设置为nil（之前为false）。
英文:
<h1>Update/remove struct fields from serialization based on another field in that struct dynamically</h1>
<h2>AKA: Don't serialize the Content field if the Hidden field is true. Or, Set Content to "nothing found!" if the Hidden field is true.</h2>
<br>
<h4>Example:</h4>
For this struct (where CustomStruct is any custom struct you have):
type Post struct {Hidden bool `json:"hidden"`Content string `json:"content"`Value CustomStruct `json:"value"`}
You can choose to dynamically return or not the value of any field based on the bool value of Hidden.
First, create an alias for your struct:
type Alias Post
Then make a wrapper for the alias:
type AuxPost struct {*Alias}
Then override the MarshalJSON method (importing package "encoding/json"):
func (p Post) MarshalJSON() ([]byte, error) {type Alias Postif p.Hidden {hiddenPost := struct {AliasContent string `json:"content"`Value bool `json:"value,omitempty"`}{Alias: (Alias)(p),Content: "[this post was removed]",Value: false,}return json.Marshal(hiddenPost)}regularPost := struct {Alias}{Alias: (Alias)(p),}return json.Marshal(regularPost)}
If your post's Hidden field is true, then it will serialize normally. If not, the Content field will be set to "[this post was removed]" and the Value field will be completely omitted (because in this particular case I set omitempty).
... the case where Hidden is false serializes as:
{"hidden": true,"content": "hello world","value": {"note": "your custom struct can have anything"}}
... and the case where Hidden is true serializes as:
{"hidden": true,"content": "[this post was removed]"}
Removing a non-struct field is trivial, but the way the struct getting removed works is by tricking it into thinking its a boolean, and then setting that bool to false, and omitting zero values from serializations (bool's zero-value = false).
EDIT: If we wanted the Value struct to just be serialized as null instead, we got remove the omitempty tag and instead set its type (previously bool) to *interface{} and then below as nil (previously false).
答案14
得分: 0
为了扩展chhaileng的答案，这里是一个使用递归删除所有出现的字段的版本
// GetJSONWithOutFields - 描述：返回一个删除指定字段的接口的字符串表示func GetJSONWithOutFields(obj interface{}, ignoreFields ...string) (string, error) {toJson, err := json.Marshal(obj)if err != nil {return "", err}if len(ignoreFields) == 0 {return string(toJson), nil}toMap := map[string]interface{}{}err = json.Unmarshal(toJson, &toMap)if err != nil {return "", err}for _, field := range ignoreFields {DeleteField(toMap, field)}toJson, err = json.Marshal(toMap)if err != nil {return "", err}return string(toJson), nil}// DeleteField - 描述：递归删除字段func DeleteField(toMap map[string]interface{}, field string) {delete(toMap, field)for _, v := range toMap {if m, isMap := v.(map[string]interface{}); isMap {DeleteField(m, field)}}}
英文:
To extend chhaileng answer, here is the version that remove all occurrences of a field with recursion
// GetJSONWithOutFields - Description: return a string representation of an interface with specified fields removedfunc GetJSONWithOutFields(obj interface{}, ignoreFields ...string) (string, error) {toJson, err := json.Marshal(obj)if err != nil {return "", err}if len(ignoreFields) == 0 {return string(toJson), nil}toMap := map[string]interface{}{}err = json.Unmarshal(toJson, &toMap)if err != nil {return "", err}for _, field := range ignoreFields {DeleteField(toMap, field)}toJson, err = json.Marshal(toMap)if err != nil {return "", err}return string(toJson), nil}// DeleteField - Description: recursively delete fieldfunc DeleteField(toMap map[string]interface{}, field string) {delete(toMap, field)for _, v := range toMap {if m, isMap := v.(map[string]interface{}); isMap {DeleteField(m, field)}}}
答案15
得分: 0
使用带有omitempty的指针：
package mainimport ("encoding/json""fmt")type Foo struct {N int `json:"n,omitempty"`S string `json:"s,omitempty"`}type Bar struct {N *int `json:"n,omitempty"`S *string `json:"s,omitempty"`}func main() {var zero intvar empty stringfoo := Foo{N: zero,S: empty,}data, _ := json.Marshal(foo)fmt.Println(string(data)) // 输出 {}bar := Bar{N: &zero,S: &empty,}data, _ = json.Marshal(bar)fmt.Println(string(data)) // 输出 {"n":0,"s":""}}
omitempty会省略零值，而指向某个变量的指针不是指针的零值，即使被指向的变量是零值。要从JSON中省略值，请将指针设置为nil（或者不要初始化它）。
英文:
Use pointers with omitempty:
package mainimport ("encoding/json""fmt")type Foo struct {N int `json:"n,omitempty"`S string `json:"s,omitempty"`}type Bar struct {N *int `json:"n,omitempty"`S *string `json:"s,omitempty"`}func main() {var zero intvar empty stringfoo := Foo{N: zero,S: empty,}data, _ := json.Marshal(foo)fmt.Println(string(data)) // prints {}bar := Bar{N: &zero,S: &empty,}data, _ = json.Marshal(bar)fmt.Println(string(data)) // prints {"n":0,"s":""}}
omitempty omits zero values, and pointer to something is not a zero value of pointer, even if variable pointed has zero value. To omit value from JSON set the pointer to nil (or just don't initialize it)
通过集体智慧和协作来改善编程学习和解决问题的方式。致力于成为全球开发者共同参与的知识库，让每个人都能够通过互相帮助和分享经验来进步。
评论