解组嵌套的 JSON 对象

在 话题上有 <一 href="https://st一ckoverflow.com/questions/20101954/go-json-unm一rsh一l-nested-object-into-string-or-byte">一 很少 问题，但它们似乎都不能覆盖我的病例，因此我正在创建一个新的病例。

我有如下的 JSON:

{"foo":{ "bar": "1", "baz": "2" }, "more": "text"}

有没有一种方法可以解组嵌套的 bar 属性并直接将其分配给 struct 属性，而无需创建嵌套的 struct？

我现在采用的解决方案如下:

type Foo struct {
More String `json:"more"`
Foo  struct {
Bar string `json:"bar"`
Baz string `json:"baz"`
} `json:"foo"`
//  FooBar  string `json:"foo.bar"`
}

这是一个简化版本，请忽略冗长。如您所见，我希望能够解析并将值赋给

//  FooBar  string `json:"foo.bar"`

我见过有人用地图，但那不是我的案子。我基本上不关心 foo的内容(它是一个很大的对象) ，除了一些特定的元素。

在这种情况下，正确的方法是什么？我不想找什么奇怪的黑客，所以如果要这么做，我没意见。

161398 次浏览
小开
最佳答案

有没有一种方法可以解组嵌套的 bar 属性并直接将其分配给 struct 属性，而无需创建嵌套的 struct？

不，编码/json 不能像编码/xml 那样使用“ > some > deep > children node”。 嵌套结构才是正确的选择。

小开

就像 Volker 提到的那样，嵌套结构才是正确的选择。但是，如果 真的不希望使用嵌套结构，则可以重写 UnMarshalJSON 函数。

Https://play.golang.org/p/dqn5udqffjt

type A struct {
FooBar string // takes foo.bar
FooBaz string // takes foo.baz
More   string
}


func (a *A) UnmarshalJSON(b []byte) error {


var f interface{}
json.Unmarshal(b, &f)


m := f.(map[string]interface{})


foomap := m["foo"]
v := foomap.(map[string]interface{})


a.FooBar = v["bar"].(string)
a.FooBaz = v["baz"].(string)
a.More = m["more"].(string)


return nil
}

请忽略这样一个事实，即我没有返回一个适当的错误。

更新: 正确检索“ more”值。

小开

那匿名字段呢？我不确定这是否会构成一个“嵌套结构”，但它比拥有一个嵌套结构声明要干净。如果希望在其他地方重用嵌套元素，该怎么办？

type NestedElement struct{
someNumber int `json:"number"`
someString string `json:"string"`
}


type BaseElement struct {
NestedElement `json:"bar"`
}
小开

这是如何从安全浏览 v4 API sbserver 代理服务器 https://play.golang.org/p/4rGB5da0Lt解封 JSON 响应的示例

// this example shows how to unmarshall JSON requests from the Safebrowsing v4 sbserver
package main


import (
"fmt"
"log"
"encoding/json"
)


// response from sbserver POST request
type Results struct {
Matches []Match
}


// nested within sbserver response
type Match struct {
ThreatType string
PlatformType string
ThreatEntryType string
Threat struct {
URL string
}
}


func main() {
fmt.Println("Hello, playground")


// sample POST request
//   curl -X POST -H 'Content-Type: application/json'
// -d '{"threatInfo": {"threatEntries": [{"url": "http://testsafebrowsing.appspot.com/apiv4/ANY_PLATFORM/MALWARE/URL/"}]}}'
// http://127.0.0.1:8080/v4/threatMatches:find


// sample JSON response
jsonResponse := `{"matches":[{"threatType":"MALWARE","platformType":"ANY_PLATFORM","threatEntryType":"URL","threat":{"url":"http://testsafebrowsing.appspot.com/apiv4/ANY_PLATFORM/MALWARE/URL/"}}]}`


res := &Results{}
err := json.Unmarshal([]byte(jsonResponse), res)
if(err!=nil) {
log.Fatal(err)
}


fmt.Printf("%v\n",res)
fmt.Printf("\tThreat Type: %s\n",res.Matches[0].ThreatType)
fmt.Printf("\tPlatform Type: %s\n",res.Matches[0].PlatformType)
fmt.Printf("\tThreat Entry Type: %s\n",res.Matches[0].ThreatEntryType)
fmt.Printf("\tURL: %s\n",res.Matches[0].Threat.URL)
}
小开

是的，有了 Gjson，你现在要做的就是:

bar := gjson.Get(json, "foo.bar")

如果您愿意，bar可以是一个 struct 属性。

小开

将嵌套 json的值赋给 struct，直到您知道 json 键的底层类型:-

package main


import (
"encoding/json"
"fmt"
)


// Object
type Object struct {
Foo map[string]map[string]string `json:"foo"`
More string `json:"more"`
}


func main(){
someJSONString := []byte(`{"foo":{ "bar": "1", "baz": "2" }, "more": "text"}`)
var obj Object
err := json.Unmarshal(someJSONString, &obj)
if err != nil{
fmt.Println(err)
}
fmt.Println("jsonObj", obj)
}
小开

我曾经研究过类似的东西，但是只研究原型产生的结构。 Https://github.com/flowup-labs/grpc-utils

在你的原型里

message Msg {
Firstname string = 1 [(gogoproto.jsontag) = "name.firstname"];
PseudoFirstname string = 2 [(gogoproto.jsontag) = "lastname"];
EmbedMsg = 3  [(gogoproto.nullable) = false, (gogoproto.embed) = true];
Lastname string = 4 [(gogoproto.jsontag) = "name.lastname"];
Inside string  = 5 [(gogoproto.jsontag) = "name.inside.a.b.c"];
}


message EmbedMsg{
Opt1 string = 1 [(gogoproto.jsontag) = "opt1"];
}

那么您的输出将是

{
"lastname": "Three",
"name": {
"firstname": "One",
"inside": {
"a": {
"b": {
"c": "goo"
}
}
},
"lastname": "Two"
},
"opt1": "var"
}
小开

结合 map 和 struct 可以解组嵌套的 JSON 对象，其中键是动态的。 = > map [ string ]

例如: stock.json

{
"MU": {
"symbol": "MU",
"title": "micro semiconductor",
"share": 400,
"purchase_price": 60.5,
"target_price": 70
},
"LSCC":{
"symbol": "LSCC",
"title": "lattice semiconductor",
"share": 200,
"purchase_price": 20,
"target_price": 30
}
}

去申请吧

package main


import (
"encoding/json"
"fmt"
"io/ioutil"
"log"
"os"
)


type Stock struct {
Symbol        string  `json:"symbol"`
Title         string  `json:"title"`
Share         int     `json:"share"`
PurchasePrice float64 `json:"purchase_price"`
TargetPrice   float64 `json:"target_price"`
}
type Account map[string]Stock


func main() {
raw, err := ioutil.ReadFile("stock.json")
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
var account Account
log.Println(account)
}

散列中的动态键是处理字符串，嵌套对象由结构表示。


提交答案