外部类型问题的 JSON 序列化 - 将 map[string]interface{} 项转换为 int

Question

I want to serialize the type Dense of package gonum.org/v1/gonum/mat . Because of the fact, that I cannot implement methods for external types, I created a type

type DenseEx struct {
    Mtx *mat.Dense
}

and implemented MarshalJSON method as follows

func (d DenseEx) MarshalJSON() ([]byte, error) {
    js := map[string]interface{}{}
    rows, cols := d.Mtx.Dims()
    js["cols"] = cols
    js["rows"] = rows
    fltVals := make([]float64, cols*rows)
    for r := 0; r < rows; r++ {
       for c := 0; c < cols; c++ {
            i := r*cols + c
            fltVals[i] = d.Mtx.At(r, c)
        }
    }
  js["values"] = fltVals
  return json.Marshal(js)
}

This works as expected. Now I have issues to unmarshal the structure.

func (d DenseEx) UnmarshalJSON(data []byte) error {
    js := map[string]interface{}{}
    err := json.Unmarshal(data, &js)
    if err != nil {
        return err
    }
    intf, ok := js["cols"]
    if !ok {
        return fmt.Errorf("tag 'cols' missing in JSON data")
    }
    var cols, rows int
    cols, ok = intf.(int)
    if !ok {
        return fmt.Errorf("tag 'cols' cannot be converted to int")
    }
    ...
    return nil
}

I am not able to convert the value of the tags to its correct type. My test json string is

var jsonStrs = []struct {
    str         string
    expected    DenseEx
    description string
}{
    {
        str: "{\"cols\":3,\"rows\":2,\"values\":[6,1,5,2,4,3]}",
        expected: DenseEx{
            Mtx: nil,
        },
        description: "deserialization of a 2x3 matrice",
    },
}

and my test code is

...
for _, d := range jsonStrs {
    var m DenseEx
    err := m.UnmarshalJSON([]byte(d.str))
...

I always get the result

matex_test.go:26: FAIL: deserialization of a 2x3 matrice: tag 'cols' cannot be converted to int

Any ideas?

Thanks in advance!

Answer 1

if you check the docs of Unmarshal. You will find that the know type of Numbers in Unmarshal is float64

To unmarshal JSON into an interface value, Unmarshal stores one of these in the interface value:

bool, for JSON booleans
float64, for JSON numbers
string, for JSON strings
[]interface{}, for JSON arrays
map[string]interface{}, for JSON objects
nil for JSON null

So, when you try to Unmarshal an int you will get it as float 64. One should type assert it first to float64 intf.(float64) then convert it to int

for example :

    intf, ok := js["cols"]
    if !ok {
        return fmt.Errorf("tag 'cols' missing in JSON data")
    }
    var cols, rows int

    ucols, ok := intf.(float64)
    if !ok {
        return fmt.Errorf("tag 'cols' cannot be converted to float64")
    } 

    cols = int(ucols)