proposal: encoding/json support Unmarshal type interface

[diiyw]

package main

import (
	"fmt"
	"encoding/json"
)

type Interface interface {
	Inter()
}

type A struct {
	AValue string
}

func(a *A)Inter() {}

type B struct {
	BValue string
}

func(b *B)Inter() {}


func main() {
	var i Interface
	err := json.Unmarshal([]byte("{\"BValue\":\"B\"}"), &i)
	if err != nil {
		fmt.Println(err)
	}
}

error:json: cannot unmarshal object into Go value of type main.Interface.

A and B implemented Unmarshaler :

package main

import (
	"fmt"
	"encoding/json"
)

type Interface interface {
	Inter()
	UnmarshalJSON([]byte) error
}

type A struct {
	AValue string
}

func(a *A)Inter() {}

func(a *A)UnmarshalJSON([]byte) error{
	return nil
}

type B struct {
	BValue string
}

func(b *B)Inter() {}
func(b *B)UnmarshalJSON([]byte) error{
	return nil
}


func main() {
	var i Interface
	err := json.Unmarshal([]byte("{\"BValue\":\"B\"}"), &i)
	if err != nil {
		fmt.Println(err)
	}
}

The same error,also not ok.
But Marshaler could marshaled.

[mvdan]

There is nothing that encoding/json can do here. It can unmarshal into a map[string]interface{}, but then that type isn't named and cannot have any methods, thus it cannot satisfy a non-empty interface.

And encoding/json cannot magically know that it could use types A or B. And, even if it did know, which one would it choose?

So really, you should either unmarshal into map[string]interface{}, or one of your two named struct types.

[mattn]

If use json.RawMessage, and you write switc/case for AValue/BValue.

package main

import (
	"encoding/json"
	"fmt"
)

type Interface interface {
	Inter()
}

type A struct {
	AValue string
}

func (a *A) Inter() {
}

type B struct {
	BValue string
}

func (b *B) Inter() {
}

type Something struct {
	Value interface{}
}

func (s *Something) UnmarshalJSON(b []byte) error {
	var r map[string]*json.RawMessage
	err := json.Unmarshal(b, &r)
	if err != nil {
		return err
	}
	for k, v := range r {
		switch k {
		case "AValue":
			var a A
			if err = json.Unmarshal([]byte(*v), &a.AValue); err != nil {
				return err
			}
			s.Value = a
		case "BValue":
			var b B
			if err = json.Unmarshal([]byte(*v), &b.BValue); err != nil {
				return err
			}
			s.Value = b
		}
	}
	return nil
}

func main() {
	var i Something
	err := json.Unmarshal([]byte("{\"BValue\":\"B\"}"), &i)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(i.Value.(B).BValue)
}

[rsc]

As @mvdan said, there's nothing that can be done here. You can't unmarshal into a nil interface - what methods should be used?

[gopherbot]

Change https://golang.org/cl/107196 mentions this issue: net: enable TCP keepalives by default