blocks|key|4457674|text|它不是很好，但是您可以通过实现Unmarshaler来实现它|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4457675|type+_Foo+Foo

func+(f+*Foo)+UnmarshalJSON(bs+[]byte)+(err+error)+{
++++foo+:=+_Foo{}

++++if+err+=+json.Unmarshal(bs,+&foo);+err+==+nil+{
++++++++*f+=+Foo(foo)
++++}

++++m+:=+make(map[string]interface{})

++++if+err+=+json.Unmarshal(bs,+&m);+err+==+nil+{
++++++++delete(m,+"a")
++++++++delete(m,+"b")
++++++++f.X+=+m
++++}

++++return+err
}|code-block|syntax|javascript|4457676|为了在解码时避免递归，必须使用_Foo类型。|4457677|entityMap^0|F|B|0|0|F|4|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

<p>It's not nice, but you could to it by implementing <code>Unmarshaler</code>:</p>

<pre><code>type _Foo Foo

func (f *Foo) UnmarshalJSON(bs []byte) (err error) {
    foo := _Foo{}

    if err = json.Unmarshal(bs, &amp;foo); err == nil {
        *f = Foo(foo)
    }

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

    if err = json.Unmarshal(bs, &amp;m); err == nil {
        delete(m, "a")
        delete(m, "b")
        f.X = m
    }

    return err
}
</code></pre>

<p>The type <code>_Foo</code> is necessary to avoid recursion while decoding.</p>


blocks|key|4457689|text|两次解组|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4457690|一种选择是解组两次:一次解组为Foo类型的值，另一次解组为map[string]interface{}类型的值，并删除键"a"和"b"|offset|length|style|CODE|4457691|type+Foo+struct+{
++++A+int++++++++++++++++++++`json:"a"`
++++B+int++++++++++++++++++++`json:"b"`
++++X+map[string]interface{}+`json:"-"`+//+Rest+of+the+fields+should+go+here.
}

func+main()+{
++++s+:=+`{"a":1,+"b":2,+"x":1,+"y":1}`
++++f+:=+Foo{}
++++if+err+:=+json.Unmarshal([]byte(s),+&f);+err+!=+nil+{
++++++++panic(err)
++++}

++++if+err+:=+json.Unmarshal([]byte(s),+&f.X);+err+!=+nil+{
++++++++panic(err)
++++}
++++delete(f.X,+"a")
++++delete(f.X,+"b")

++++fmt.Printf("%25%2Bv",+f)
}|code-block|syntax|javascript|4457692|输出(在Go+Playground上试用)：|4457693|{A:1+B:2+X:map[x:1+y:1]}|4457694|解组一次和手动处理|4457695|另一种选择是将数据解组到map[string]interface{}中，然后手动处理Foo.A和Foo.B字段：|4457696|type+Foo+struct+{
++++A+int++++++++++++++++++++`json:"a"`
++++B+int++++++++++++++++++++`json:"b"`
++++X+map[string]interface{}+`json:"-"`+//+Rest+of+the+fields+should+go+here.
}

func+main()+{
++++s+:=+`{"a":1,+"b":2,+"x":1,+"y":1}`
++++f+:=+Foo{}
++++if+err+:=+json.Unmarshal([]byte(s),+&f.X);+err+!=+nil+{
++++++++panic(err)
++++}
++++if+n,+ok+:=+f.X["a"].(float64);+ok+{
++++++++f.A+=+int(n)
++++}
++++if+n,+ok+:=+f.X["b"].(float64);+ok+{
++++++++f.B+=+int(n)
++++}
++++delete(f.X,+"a")
++++delete(f.X,+"b")

++++fmt.Printf("%25%2Bv",+f)
}|4457697|输出相同(Go+Playground)：|4457698|{A:1+B:2+X:map[x:1+y:1]}|4457699|entityMap|0|LINK|mutability|MUTABLE|url|http://play.golang.org/p/MbGVDwBgzy|1|http://play.golang.org/p/juAjK6ymIk^0|0|F|3|T|M|1O|3|1S|3|0|0|4|D|0|0|0|0|C|M|16|5|1C|5|0|0|5|D|1|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1B|8|@$D|1C|E|1D|F|G]|$D|1E|E|1F|F|G]|$D|1G|E|1H|F|G]|$D|1I|E|1J|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|1K|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1L|8|@]|9|@$D|1M|E|1N|1|1O]]|A|$]]|$1|O|3|P|5|J|7|1P|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1R|8|@$D|1S|E|1T|F|G]|$D|1U|E|1V|F|G]|$D|1W|E|1X|F|G]]|9|@]|A|$]]|$1|U|3|V|5|J|7|1Y|8|@]|9|@]|A|$K|L]]|$1|W|3|X|5|6|7|1Z|8|@]|9|@$D|20|E|21|1|22]]|A|$]]|$1|Y|3|Z|5|J|7|23|8|@]|9|@]|A|$K|L]]|$1|10|3|-4|5|6|7|24|8|@]|9|@]|A|$]]]|11|$12|$5|13|14|15|A|$16|17]]|18|$5|13|14|15|A|$16|19]]]]

<h2>Unmarshal twice</h2>

<p>One option is to unmarshal twice: once into a value of type <code>Foo</code> and once into a value of type <code>map[string]interface{}</code> and removing the keys <code>"a"</code> and <code>"b"</code>:</p>

<pre><code>type Foo struct {
    A int                    `json:"a"`
    B int                    `json:"b"`
    X map[string]interface{} `json:"-"` // Rest of the fields should go here.
}

func main() {
    s := `{"a":1, "b":2, "x":1, "y":1}`
    f := Foo{}
    if err := json.Unmarshal([]byte(s), &amp;f); err != nil {
        panic(err)
    }

    if err := json.Unmarshal([]byte(s), &amp;f.X); err != nil {
        panic(err)
    }
    delete(f.X, "a")
    delete(f.X, "b")

    fmt.Printf("%+v", f)
}
</code></pre>

<p>Output (try it on the <a href="http://play.golang.org/p/MbGVDwBgzy" rel="noreferrer">Go Playground</a>):</p>

<pre><code>{A:1 B:2 X:map[x:1 y:1]}
</code></pre>

<h2>Unmarshal once and manual handling</h2>

<p>Another option is to unmarshal once into an <code>map[string]interface{}</code> and handle the <code>Foo.A</code> and <code>Foo.B</code> fields manually:</p>

<pre><code>type Foo struct {
    A int                    `json:"a"`
    B int                    `json:"b"`
    X map[string]interface{} `json:"-"` // Rest of the fields should go here.
}

func main() {
    s := `{"a":1, "b":2, "x":1, "y":1}`
    f := Foo{}
    if err := json.Unmarshal([]byte(s), &amp;f.X); err != nil {
        panic(err)
    }
    if n, ok := f.X["a"].(float64); ok {
        f.A = int(n)
    }
    if n, ok := f.X["b"].(float64); ok {
        f.B = int(n)
    }
    delete(f.X, "a")
    delete(f.X, "b")

    fmt.Printf("%+v", f)
}
</code></pre>

<p>Output is the same (<a href="http://play.golang.org/p/juAjK6ymIk" rel="noreferrer">Go Playground</a>):</p>

<pre><code>{A:1 B:2 X:map[x:1 y:1]}
</code></pre>


blocks|key|4457746|text|几乎单次通过，使用json.RawMessage|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4457747|我们可以解组到map[string]json.RawMessage中，然后分别解组每个字段。|4457748|JSON将被标记化两次，但这是相当便宜的。|4457749|可以使用以下helper函数：|4457750|func+UnmarshalJsonObject(jsonStr+[]byte,+obj+interface{},+otherFields+map[string]json.RawMessage)+(err+error)+{
++++objValue+:=+reflect.ValueOf(obj).Elem()
++++knownFields+:=+map[string]reflect.Value{}
++++for+i+:=+0;+i+!=+objValue.NumField();+i%2B%2B+{
++++++++jsonName+:=+strings.Split(objValue.Type().Field(i).Tag.Get("json"),+",")[0]
++++++++knownFields[jsonName]+=+objValue.Field(i)
++++}

++++err+=+json.Unmarshal(jsonStr,+&otherFields)
++++if+err+!=+nil+{
++++++++return
++++}

++++for+key,+chunk+:=+range+otherFields+{
++++++++if+field,+found+:=+knownFields[key];+found+{
++++++++++++err+=+json.Unmarshal(chunk,+field.Addr().Interface())
++++++++++++if+err+!=+nil+{
++++++++++++++++return
++++++++++++}
++++++++++++delete(otherFields,+key)
++++++++}
++++}
++++return
}|code-block|syntax|javascript|4457751|以下是Go+Playground+-+http://play.golang.org/p/EtkJUzMmKt上的完整代码|4457752|entityMap|0|LINK|mutability|MUTABLE|url|http://play.golang.org/p/EtkJUzMmKt^0|9|F|0|7|Q|0|0|0|0|J|Z|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|16|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|17|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|18|8|@]|D|@]|E|$O|P]]|$1|Q|3|R|5|6|7|19|8|@]|D|@$9|1A|A|1B|1|1C]]|E|$]]|$1|S|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

<h1>Almost single pass, uses <code>json.RawMessage</code></h1>

<p>We can unmarshal into <code>map[string]json.RawMessage</code>, and then unmarshal each field separately.</p>

<p>JSON will be tokenized twice, but that's quite cheap.</p>

<p>The following helper function can be used:</p>

<pre><code>func UnmarshalJsonObject(jsonStr []byte, obj interface{}, otherFields map[string]json.RawMessage) (err error) {
    objValue := reflect.ValueOf(obj).Elem()
    knownFields := map[string]reflect.Value{}
    for i := 0; i != objValue.NumField(); i++ {
        jsonName := strings.Split(objValue.Type().Field(i).Tag.Get("json"), ",")[0]
        knownFields[jsonName] = objValue.Field(i)
    }

    err = json.Unmarshal(jsonStr, &amp;otherFields)
    if err != nil {
        return
    }

    for key, chunk := range otherFields {
        if field, found := knownFields[key]; found {
            err = json.Unmarshal(chunk, field.Addr().Interface())
            if err != nil {
                return
            }
            delete(otherFields, key)
        }
    }
    return
}
</code></pre>

<p>Here is the complete code on Go Playground - <a href="http://play.golang.org/p/EtkJUzMmKt" rel="noreferrer">http://play.golang.org/p/EtkJUzMmKt</a></p>


blocks|key|4457788|text|单次通过，使用github.com/ugorji/go/codec|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4457789|在解组为map时，encoding/json会清空映射，但ugorji/go/codec不会。它还会尝试填充现有值，因此我们可以将指向foo.A、foo.B的指针放入foo.X：|4457790|package+main

import+(
++++"fmt"
++++"github.com/ugorji/go/codec"
)

type+Foo+struct+{
++++A+int
++++B+int
++++X+map[string]interface{}
}

func+(this+*Foo)+UnmarshalJSON(jsonStr+[]byte)+(err+error)+{
++++this.X+=+make(map[string]interface{})
++++this.X["a"]+=+&this.A
++++this.X["b"]+=+&this.B
++++return+codec.NewDecoderBytes(jsonStr,+&codec.JsonHandle{}).Decode(&this.X)
}

func+main()+{
++++s+:=+`{"a":1,+"b":2,+"x":3,+"y":[]}`
++++f+:=+&Foo{}
++++err+:=+codec.NewDecoderBytes([]byte(s),+&codec.JsonHandle{}).Decode(f)
++++fmt.Printf("err+=+%25v\n",+err)
++++fmt.Printf("%25%2Bv\n",+f)
}|code-block|syntax|javascript|4457791|entityMap^0|7|Q|0|4|3|9|D|T|F|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|@$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|N|$]]

<h1>Single pass, use <code>github.com/ugorji/go/codec</code></h1>

<p>When unmarshaling into a <code>map</code>, <code>encoding/json</code> empties the map, but <code>ugorji/go/codec</code> doesn't. It also attempts to fill existing values, so we can put pointers to foo.A, foo.B into foo.X:</p>

<pre><code>package main

import (
    "fmt"
    "github.com/ugorji/go/codec"
)

type Foo struct {
    A int
    B int
    X map[string]interface{}
}

func (this *Foo) UnmarshalJSON(jsonStr []byte) (err error) {
    this.X = make(map[string]interface{})
    this.X["a"] = &amp;this.A
    this.X["b"] = &amp;this.B
    return codec.NewDecoderBytes(jsonStr, &amp;codec.JsonHandle{}).Decode(&amp;this.X)
}

func main() {
    s := `{"a":1, "b":2, "x":3, "y":[]}`
    f := &amp;Foo{}
    err := codec.NewDecoderBytes([]byte(s), &amp;codec.JsonHandle{}).Decode(f)
    fmt.Printf("err = %v\n", err)
    fmt.Printf("%+v\n", f)
}
</code></pre>


blocks|key|4457816|text|最简单的方法是使用这样的接口：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4457817|var+f+interface{}
s+:=+`{"a":1,+"b":2,+"x":1,+"y":1}`

if+err+:=+json.Unmarshal([]byte(s),+&f);+err+!=+nil+{
++++panic(err)
}|code-block|syntax|javascript|4457818|Go+Playground+example|offset|length|4457819|entityMap|0|LINK|mutability|MUTABLE|url|https://play.golang.org/p/HV5bYV4uud^0|0|0|0|L|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]]]]

<p>Simplest way is to use an interface like this: </p>

<pre><code>var f interface{}
s := `{"a":1, "b":2, "x":1, "y":1}`

if err := json.Unmarshal([]byte(s), &amp;f); err != nil {
    panic(err)
}
</code></pre>

<p><a href="https://play.golang.org/p/HV5bYV4uud" rel="noreferrer">Go Playground example</a></p>


blocks|key|4457851|text|使用Hashicorp的map-to-struct解码器，它可以跟踪未使用的字段：https://godoc.org/github.com/mitchellh/mapstructure#example-Decode--Metadata|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4457852|这是两次传递，但您不必在任何地方使用已知的字段名。|4457853|func+UnmarshalJson(input+[]byte,+result+interface{})+(map[string]interface{},+error)+{
++++//+unmarshal+json+to+a+map
++++foomap+:=+make(map[string]interface{})
++++json.Unmarshal(input,+&foomap)

++++//+create+a+mapstructure+decoder
++++var+md+mapstructure.Metadata
++++decoder,+err+:=+mapstructure.NewDecoder(
++++++++&mapstructure.DecoderConfig{
++++++++++++Metadata:+&md,
++++++++++++Result:+++result,
++++++++})
++++if+err+!=+nil+{
++++++++return+nil,+err
++++}

++++//+decode+the+unmarshalled+map+into+the+given+struct
++++if+err+:=+decoder.Decode(foomap);+err+!=+nil+{
++++++++return+nil,+err
++++}

++++//+copy+and+return+unused+fields
++++unused+:=+map[string]interface{}{}
++++for+_,+k+:=+range+md.Unused+{
++++++++unused[k]+=+foomap[k]
++++}
++++return+unused,+nil
}

type+Foo+struct+{
++++//+Known+fields
++++A+int
++++B+int
++++//+Unknown+fields
++++X+map[string]interface{}+//+Rest+of+the+fields+should+go+here.
}

func+main()+{
++++s+:=+[]byte(`{"a":1,+"b":2,+"?":3,+"??":4}`)

++++var+foo+Foo
++++unused,+err+:=+UnmarshalJson(s,+&foo)
++++if+err+!=+nil+{
++++++++panic(err)
++++}

++++foo.X+=+unused
++++fmt.Println(foo)+//+prints+{1+2+map[?:3+??:4]}
}|code-block|syntax|javascript|4457854|entityMap|0|LINK|mutability|MUTABLE|url|https://godoc.org/github.com/mitchellh/mapstructure#example-Decode--Metadata^0|15|24|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]]]]

<p>Use Hashicorp's map-to-struct decoder, which keeps track of unused fields: <a href="https://godoc.org/github.com/mitchellh/mapstructure#example-Decode--Metadata" rel="nofollow noreferrer">https://godoc.org/github.com/mitchellh/mapstructure#example-Decode--Metadata</a></p>

<p>It's two-pass, but you don't have to use known field names anywhere.</p>

<pre><code>func UnmarshalJson(input []byte, result interface{}) (map[string]interface{}, error) {
    // unmarshal json to a map
    foomap := make(map[string]interface{})
    json.Unmarshal(input, &amp;foomap)

    // create a mapstructure decoder
    var md mapstructure.Metadata
    decoder, err := mapstructure.NewDecoder(
        &amp;mapstructure.DecoderConfig{
            Metadata: &amp;md,
            Result:   result,
        })
    if err != nil {
        return nil, err
    }

    // decode the unmarshalled map into the given struct
    if err := decoder.Decode(foomap); err != nil {
        return nil, err
    }

    // copy and return unused fields
    unused := map[string]interface{}{}
    for _, k := range md.Unused {
        unused[k] = foomap[k]
    }
    return unused, nil
}

type Foo struct {
    // Known fields
    A int
    B int
    // Unknown fields
    X map[string]interface{} // Rest of the fields should go here.
}

func main() {
    s := []byte(`{"a":1, "b":2, "?":3, "??":4}`)

    var foo Foo
    unused, err := UnmarshalJson(s, &amp;foo)
    if err != nil {
        panic(err)
    }

    foo.X = unused
    fmt.Println(foo) // prints {1 2 map[?:3 ??:4]}
}
</code></pre>


blocks|key|4457864|text|我使用接口来解组不确定类型的json。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4457865|bytes+:=+[]byte(`{"name":"Liam","gender":1,+"salary":+1}`)
var+p2+interface{}
json.Unmarshal(bytes,+&p2)
m+:=+p2.(map[string]interface{})
fmt.Println(m)|code-block|syntax|javascript|4457866|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>I use interface to unmarshal uncertain type json.</p>

<pre><code>bytes := []byte(`{"name":"Liam","gender":1, "salary": 1}`)
var p2 interface{}
json.Unmarshal(bytes, &amp;p2)
m := p2.(map[string]interface{})
fmt.Println(m)
</code></pre>


<p>I have the following JSON</p>

<pre><code>{"a":1, "b":2, "?":1, "??":1}
</code></pre>

<p>I know that it has the "a" and "b" fields, but I don't know the names of other fields. So I want to unmarshal it in the following type:</p>

<pre><code>type Foo struct {
  // Known fields
  A int `json:"a"`
  B int `json:"b"`
  // Unknown fields
  X map[string]interface{} `json:???` // Rest of the fields should go here.
}
</code></pre>

<p>How do I do that?</p>


Unmarshal JSON with some known, and some unknown field names

我有以下JSON{"a":1, "b":2, "?":1, "??":1}我知道它有"a“和"b”字段，但我不知道其他字段的名称。所以我想用下面的类型对它进行解组：type Foo struct {  // Known fields  A int `json:"a"`  B int `json:"b"`  // Unk...

问使用一些已知的和一些未知的字段名称解组JSON
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用一些已知的和一些未知的字段名称解组JSONEN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用一些已知的和一些未知的字段名称解组JSON
EN