我如何在切片內進行json解組切片

Question

我試圖解組一些非常丑陋的json，但不知道如何處理。 我有：

package main

import "fmt"
import "encoding/json"

type PublicKey struct {
    ID     int    `json:"id"`
    Key    string `json:"key"`
    MyData []struct {
        ID    string `json:"id"`
        Value int    `json:"value"`
    }
}

func main() {
    b := `[
  {
    "id": 1,
    "key": "my_key"
  },
  [
    {
      "id": "some_id",
      "value": 12
    },
    {
      "id": "anorther_id",
      "value": 13
    }
  ]
]`

    var pk []PublicKey
    err := json.Unmarshal([]byte(b), &pk)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(pk)

}

結果我得到：

[{1 my_key []} {0  []}]

第二個切片本不應為空。

編輯 ：我得到的錯誤是：

json: cannot unmarshal array into Go struct field PublicKey.key of type main.PublicKey

https://play.golang.org/p/cztXOchiiS5

Answer 1

那是一些真正可怕的JSON！ 我有兩種處理混合數組元素的方法，我更喜歡第二種方法。 這是使用interface和類型開關的第一種方法：

package main

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

type PublicKey struct {
    ID  int    `json:"id"`
    Key string `json:"key"`
}

type MyData struct {
    ID    string `json:"id"`
    Value int    `json:"value"`
}

type MixedData struct {
    Key    []PublicKey
    MyData [][]MyData
}

func (md *MixedData) UnmarshalJSON(b []byte) error {
    md.Key = []PublicKey{}
    md.MyData = [][]MyData{}
    var obj []interface{}
    err := json.Unmarshal([]byte(b), &obj)
    if err != nil {
        return err
    }
    for _, o := range obj {
        switch o.(type) {
        case map[string]interface{}:
            m := o.(map[string]interface{})
            id, ok := m["id"].(float64)
            if !ok {
                return errors.New("public key id must be an int")
            }
            pk := PublicKey{}
            pk.ID = int(id)
            pk.Key, ok = m["key"].(string)
            if !ok {
                return errors.New("public key key must be a string")
            }
            md.Key = append(md.Key, pk)
        case []interface{}:
            a := o.([]interface{})
            myData := make([]MyData, len(a))
            for i, x := range a {
                m, ok := x.(map[string]interface{})
                if !ok {
                    return errors.New("data array contains unexpected object")
                }
                val, ok := m["value"].(float64)
                if !ok {
                    return errors.New("data value must be an int")
                }
                myData[i].Value = int(val)
                myData[i].ID, ok = m["id"].(string)
                if !ok {
                    return errors.New("data id must be a string")
                }
                md.MyData = append(md.MyData, myData)
            }
        default:
            // got something unexpected, handle somehow
        }
    }
    return nil
}

func main() {
    b := `[
  {
    "id": 1,
    "key": "my_key"
  },
  [
    {
      "id": "some_id",
      "value": 12
    },
    {
      "id": "another_id",
      "value": 13
    }
  ]
]`

    m := MixedData{}
    err := json.Unmarshal([]byte(b), &m)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(m)

}

https://play.golang.org/p/g8d_AsH-pYY

希望沒有其他意外的元素，但是可以類似地處理它們。

這是第二個在json.RawMessage的幫助下更依賴於Go的內部JSON解析的json.RawMessage 。 它對數組的內容做出相同的假設。 它假定任何對象都將解組為PublicKey實例，並且任何數組僅由MyData實例組成。 我還添加了如何編組回目標JSON以實現對稱性：

package main

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

type PublicKey struct {
    ID  int    `json:"id"`
    Key string `json:"key"`
}

type MyData struct {
    ID    string `json:"id"`
    Value int    `json:"value"`
}

type MixedData struct {
    Keys   []PublicKey
    MyData [][]MyData
}

func (md *MixedData) UnmarshalJSON(b []byte) error {
    md.Keys = []PublicKey{}
    md.MyData = [][]MyData{}
    obj := []json.RawMessage{}
    err := json.Unmarshal([]byte(b), &obj)
    if err != nil {
        return err
    }
    for _, o := range obj {
        switch o[0] {
        case '{':
            pk := PublicKey{}
            err := json.Unmarshal(o, &pk)
            if err != nil {
                return err
            }
            md.Keys = append(md.Keys, pk)
        case '[':
            myData := []MyData{}
            err := json.Unmarshal(o, &myData)
            if err != nil {
                return err
            }
            md.MyData = append(md.MyData, myData)
        default:
            // got something unexpected, handle somehow
        }
    }
    return nil
}

func (md *MixedData) MarshalJSON() ([]byte, error) {
    out := make([]interface{}, len(md.Keys)+len(md.MyData))
    i := 0
    for _, x := range md.Keys {
        out[i] = x
        i++
    }
    for _, x := range md.MyData {
        out[i] = x
        i++
    }
    return json.Marshal(out)
}

func main() {
    b := `[
  {
    "id": 1,
    "key": "my_key"
  },
  [
    {
      "id": "some_id",
      "value": 12
    },
    {
      "id": "another_id",
      "value": 13
    }
  ]
]`

    m := MixedData{}
    err := json.Unmarshal([]byte(b), &m)
    if err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
    fmt.Println(m)

    enc := json.NewEncoder(os.Stdout)
    enc.SetIndent("", "    ")
    if err := enc.Encode(m); err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
}

https://play.golang.org/p/ryZzaWKNcN0

Answer 2

這是一種將json.RawMessage與在實現json.Unmarshaler的類型中使用默認unmarshaler的技巧結合在一起的方法，方法是創建一個別名為目標類型的新臨時類型。

這個想法是我們將傳入的數組解組為原始消息，並確保數組長度符合我們的期望。 然后，我們使用其JSON標簽注釋將各個數組元素解組為自定義結構類型。 最終結果是，我們可以按通常的方式對PublicKey類型進行編組，並且一旦了解了竅門，就很難遵循UnmarshalJSON代碼。

例如（ Go Playground ）：

type PublicKey struct {
  ID   int    `json:"id"`
  Key  string `json:"key"`
  Data []MyData
}

type MyData struct {
  ID    string `json:"id"`
  Value int    `json:"value"`
}

func (pk *PublicKey) UnmarshalJSON(bs []byte) error {
  // Unmarshal into a RawMessage so we can inspect the array length.
  var rawMessage []json.RawMessage
  err := json.Unmarshal(bs, &rawMessage)
  if err != nil {
    return err
  }
  if len(rawMessage) != 2 {
    return fmt.Errorf("expected array of length 2, got %d", len(rawMessage))
  }

  // Parse the first object as PublicKey using the default unmarshaler
  // using a temporary type that is an alias for the target type.
  type PublicKey2 PublicKey
  var pk2 PublicKey2
  err = json.Unmarshal(rawMessage[0], &pk2)
  if err != nil {
    return err
  }

  // Parse the second object as []MyData in the usual way.
  err = json.Unmarshal(rawMessage[1], &pk2.Data)
  if err != nil {
    return err
  }

  // Finally, assign the aliased object to the target object.
  *pk = PublicKey(pk2)
  return nil
}

func main() {
  var pk PublicKey
  err := json.Unmarshal([]byte(jsonstr), &pk)
  if err != nil {
    panic(err)
  }
  fmt.Printf("%#v\n", pk)
  // main.PublicKey{ID:1, Key:"my_key", Data:[]main.MyData{main.MyData{ID:"some_id", Value:12}, main.MyData{ID:"anorther_id", Value:13}}}

}