blocks|key|74699|text|你可以使用标签属性"omitifempty“，或者将可选字段设为指针，而不初始化那些你想跳过的字段。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|74700|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You can use tagging attribute "omitifempty" or make optional fields pointers and leave those you want skipped uninitialized.

blocks|key|74719|text|使用json:"-"|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|74720|//+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"`|code-block|syntax|javascript|74721|文档：http://golang.org/pkg/encoding/json/#Marshal|74722|entityMap|0|LINK|mutability|MUTABLE|url|http://golang.org/pkg/encoding/json/#Marshal^0|2|8|0|0|3|18|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

use `json:"-"`

<pre><code>// 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"`
</code></pre>

doc : <a href="http://golang.org/pkg/encoding/json/#Marshal" rel="noreferrer">http://golang.org/pkg/encoding/json/#Marshal</a>

blocks|key|74747|text|这个问题现在有点老了，但我不久前遇到了同样的问题，因为我发现没有简单的方法来做到这一点，所以我建立了一个库来实现这个目的。它允许轻松地从静态结构生成map[string]interface{}。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|74748|https://github.com/tuvistavie/structomap|74749|entityMap|0|LINK|mutability|MUTABLE|url^0|22|M|0|0|14|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@$9|S|A|T|1|U]]|E|$]]|$1|H|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|G]]]]

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 <code>map[string]interface{}</code> from a static struct.

<a href="https://github.com/tuvistavie/structomap" rel="nofollow">https://github.com/tuvistavie/structomap</a>

blocks|key|292019|text|我刚刚发布了sheriff，它根据结构字段上注释的标记将结构转换为映射。然后，您可以编组(JSON或其他)生成的映射。它可能不允许您只序列化调用者请求的字段集，但我想使用一组组将允许您涵盖大多数情况。使用组而不是直接使用字段也很可能会增加缓存能力。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|292020|示例：|292021|package+main

import+(
++++"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("%25s",+output)
}|code-block|syntax|javascript|292022|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/liip/sheriff^0|6|7|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

I just published <a href="https://github.com/liip/sheriff" rel="noreferrer">sheriff</a>, 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:

<pre><code>package main

import (
 "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 := &amp;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)
}
</code></pre>

blocks|key|292065|text|我没有同样的问题，但很相似。当然，如果你不介意性能问题，下面的代码也能解决你的问题。在将这种解决方案实现到您的系统之前，我建议您尽可能重新设计您的结构。发送可变结构响应是一种过度工程。我认为响应结构代表了请求和资源之间的契约，它不应该是依赖请求。(你可以将不需要的字段设为空，我这样做)。在某些情况下，我们必须实现这种设计，如果你认为你在这种情况下，这里是我使用的play+link和代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|292066|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%2B%2B+{
++++++++++++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+arrays
++++++++++++++++if+!ContainsCommonItem(tagList,+acTags)+{
++++++++++++++++++++fieldVal.Set(reflect.Zero(fieldVal.Type()))
++++++++++++++++}
++++++++++++}
++++++++}
++++}
}

//ContainsCommonItem+checks+if+arrays+have+at+least+one+equal+item
func+ContainsCommonItem(arr1+[]string,+arr2+[]string)+bool+{
++++for+i+:=+0;+i+<+len(arr1);+i%2B%2B+{
++++++++for+j+:=+0;+j+<+len(arr2);+j%2B%2B+{
++++++++++++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+fields
++++OmitFields(&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+names
++++OmitFields(&u2,+[]string{"id",+"nickname"})+
++++bytes,+_+=+json.Marshal(&u2)
++++fmt.Println(string(bytes))

}|code-block|syntax|javascript|292067|entityMap|0|LINK|mutability|MUTABLE|url|https://play.golang.org/p/_qrB8o9laZW^0|52|9|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

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 <a href="https://play.golang.org/p/_qrB8o9laZW" rel="nofollow noreferrer">play link</a> and code I use.

<pre><code>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 &lt; 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 arrays
 if !ContainsCommonItem(tagList, acTags) {
 fieldVal.Set(reflect.Zero(fieldVal.Type()))
 }
 }
 }
 }
}

//ContainsCommonItem checks if arrays have at least one equal item
func ContainsCommonItem(arr1 []string, arr2 []string) bool {
 for i := 0; i &lt; len(arr1); i++ {
 for j := 0; j &lt; 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 fields
 OmitFields(&amp;u, []string{"public"}) 
 bytes, _ := json.Marshal(&amp;u)
 fmt.Println(string(bytes))


 u2 := User2{ID: 1, Username: "very secret", Nickname: "hinzir"}
 //you want to filter fields by field names
 OmitFields(&amp;u2, []string{"id", "nickname"}) 
 bytes, _ = json.Marshal(&amp;u2)
 fmt.Println(string(bytes))

}
</code></pre>

blocks|key|74832|text|我也面临着这个问题，一开始我只是想在我的http处理程序中专门化响应。我的第一种方法是创建一个包，该包将一个结构的信息复制到另一个结构，然后封送第二个结构。我使用反射做了那个包，所以，我从来不喜欢这种方法，而且我也不是动态的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|74833|因此，我决定修改编码/json包来实现这一点。函数Marshal、MarshalIndent和(Encoder)+Encode另外接收一个|offset|length|style|CODE|74834|type+F+map[string]F|74835|我想模拟编组所需的字段的JSON，以便它只编组映射中的字段。|74836|https://github.com/jtorz/jsont|74837|package+main

import+(
++++"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"`
}+//SearchResult

type+SearchResults+struct+{
++++NumberResults+int++++++++++++`json:"numberResults"`
++++Results+++++++[]SearchResult+`json:"results"`
}+//type+SearchResults
func+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)
}|code-block|syntax|javascript|74838|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/JuanTorr/jsont^0|0|P|7|X|D|1B|G|0|0|J|0|0|0|U|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@$D|12|E|13|F|G]|$D|14|E|15|F|G]|$D|16|E|17|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|18|8|@$D|19|E|1A|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1B|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1C|8|@]|9|@$D|1D|E|1E|1|1F]]|A|$]]|$1|N|3|O|5|P|7|1G|8|@]|9|@]|A|$Q|R]]|$1|S|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

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 <code>Marshal</code>, <code>MarshalIndent</code> and <code>(Encoder) Encode</code> additionally receives a
<code>type F map[string]F</code>
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.
<a href="https://github.com/JuanTorr/jsont" rel="nofollow noreferrer">https://github.com/jtorz/jsont</a>
<pre><code>package main

import (
 &quot;fmt&quot;
 &quot;log&quot;
 &quot;net/http&quot;

 &quot;github.com/jtorz/jsont/v2&quot;
)

type SearchResult struct {
 Date string `json:&quot;date&quot;`
 IdCompany int `json:&quot;idCompany&quot;`
 Company string `json:&quot;company&quot;`
 IdIndustry interface{} `json:&quot;idIndustry&quot;`
 Industry string `json:&quot;industry&quot;`
 IdContinent interface{} `json:&quot;idContinent&quot;`
 Continent string `json:&quot;continent&quot;`
 IdCountry interface{} `json:&quot;idCountry&quot;`
 Country string `json:&quot;country&quot;`
 IdState interface{} `json:&quot;idState&quot;`
 State string `json:&quot;state&quot;`
 IdCity interface{} `json:&quot;idCity&quot;`
 City string `json:&quot;city&quot;`
} //SearchResult

type SearchResults struct {
 NumberResults int `json:&quot;numberResults&quot;`
 Results []SearchResult `json:&quot;results&quot;`
} //type SearchResults
func main() {
 msg := SearchResults{
 NumberResults: 2,
 Results: []SearchResult{
 {
 Date: &quot;12-12-12&quot;,
 IdCompany: 1,
 Company: &quot;alfa&quot;,
 IdIndustry: 1,
 Industry: &quot;IT&quot;,
 IdContinent: 1,
 Continent: &quot;america&quot;,
 IdCountry: 1,
 Country: &quot;México&quot;,
 IdState: 1,
 State: &quot;CDMX&quot;,
 IdCity: 1,
 City: &quot;Atz&quot;,
 },
 {
 Date: &quot;12-12-12&quot;,
 IdCompany: 2,
 Company: &quot;beta&quot;,
 IdIndustry: 1,
 Industry: &quot;IT&quot;,
 IdContinent: 1,
 Continent: &quot;america&quot;,
 IdCountry: 2,
 Country: &quot;USA&quot;,
 IdState: 2,
 State: &quot;TX&quot;,
 IdCity: 2,
 City: &quot;XYZ&quot;,
 },
 },
 }
 fmt.Println(msg)
 http.HandleFunc(&quot;/&quot;, func(w http.ResponseWriter, r *http.Request) {

 //{&quot;numberResults&quot;:2,&quot;results&quot;:[{&quot;date&quot;:&quot;12-12-12&quot;,&quot;idCompany&quot;:1,&quot;idIndustry&quot;:1,&quot;country&quot;:&quot;México&quot;},{&quot;date&quot;:&quot;12-12-12&quot;,&quot;idCompany&quot;:2,&quot;idIndustry&quot;:1,&quot;country&quot;:&quot;USA&quot;}]}
 err := jsont.NewEncoder(w).Encode(msg, jsont.F{
 &quot;numberResults&quot;: nil,
 &quot;results&quot;: jsont.F{
 &quot;date&quot;: nil,
 &quot;idCompany&quot;: nil,
 &quot;idIndustry&quot;: nil,
 &quot;country&quot;: nil,
 },
 })
 if err != nil {
 log.Fatal(err)
 }
 })

 http.ListenAndServe(&quot;:3009&quot;, nil)
}
</code></pre>

blocks|key|74883|text|我创建了这个函数，通过忽略一些字段将struct转换为JSON字符串。希望这能有所帮助。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|74884|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
}|code-block|syntax|javascript|74885|示例：https://play.golang.org/p/nmq7MFF47Gp|offset|length|74886|entityMap|0|LINK|mutability|MUTABLE|url|https://play.golang.org/p/nmq7MFF47Gp^0|0|0|3|11|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

I created this function to convert struct to JSON string by ignoring some fields. Hope it will help.

<pre><code>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)), &amp;toMap)

 for _, field := range ignoreFields {
 delete(toMap, field)
 }

 toJson, err = json.Marshal(toMap)
 if err != nil {
 return "", err
 }
 return string(toJson), nil
}
</code></pre>

Example: <a href="https://play.golang.org/p/nmq7MFF47Gp" rel="nofollow noreferrer">https://play.golang.org/p/nmq7MFF47Gp</a>

blocks|key|74905|text|下面是我如何定义我的结构的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|74906|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"`
}|code-block|syntax|javascript|74907|在我的函数中，user.Password+=+nil设置为不被编组。|offset|length|style|CODE|74908|entityMap^0|0|0|7|J|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Here is how I defined my structure.
<pre><code>type User struct {
 Username string `json:&quot;username&quot; bson:&quot;username&quot;`
 Email string `json:&quot;email&quot; bson:&quot;email&quot;`
 Password *string `json:&quot;password,omitempty&quot; bson:&quot;password&quot;`
 FullName string `json:&quot;fullname&quot; bson:&quot;fullname&quot;`
}
</code></pre>
And inside my function set <code>user.Password = nil</code> for not to be Marshalled.

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 &quot;fields&quot; 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:
<pre><code>type SearchResult struct {
 Date string `json:&quot;date&quot;`
 IdCompany int `json:&quot;idCompany&quot;`
 Company string `json:&quot;company&quot;`
 IdIndustry interface{} `json:&quot;idIndustry&quot;`
 Industry string `json:&quot;industry&quot;`
 IdContinent interface{} `json:&quot;idContinent&quot;`
 Continent string `json:&quot;continent&quot;`
 IdCountry interface{} `json:&quot;idCountry&quot;`
 Country string `json:&quot;country&quot;`
 IdState interface{} `json:&quot;idState&quot;`
 State string `json:&quot;state&quot;`
 IdCity interface{} `json:&quot;idCity&quot;`
 City string `json:&quot;city&quot;`
} //SearchResult

type SearchResults struct {
 NumberResults int `json:&quot;numberResults&quot;`
 Results []SearchResult `json:&quot;results&quot;`
} //type SearchResults
</code></pre>
I then encode and output the response like so:
<pre><code>err := json.NewEncoder(c.ResponseWriter).Encode(&amp;msg)
</code></pre>

Removing fields from struct or hiding them in JSON Response

JSON

我在Go中创建了一个API，它在被调用时执行查询，创建一个结构的实例，然后在发送回调用者之前将该结构编码为JSON。现在，我想让调用者能够通过传递一个“field”GET参数来选择他们想要返回的特定字段。这意味着根据字段值的不同，我的结构也会发生变化。有什么方法可以从结构中删除字段吗？或者至少将它们动态地隐藏在JSON...

问从结构中删除字段或将其隐藏在JSON响应中
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从结构中删除字段或将其隐藏在JSON响应中EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从结构中删除字段或将其隐藏在JSON响应中
EN