I'm reading data structures from JSON. There's a little bit of conversions going on and at the end I have a struct
where one of the fields is of type interface{}
. It's actually a map, so JSON puts it inside a map[string]inteface{}
.
I actually know that the underlying structure is map[string]float64
and I would like to use it like that, so I try to do an assertion. The following code reproduces the behaviour:
type T interface{}
func jsonMap() T {
result := map[string]interface{}{
"test": 1.2,
}
return T(result)
}
func main() {
res := jsonMap()
myMap := res.(map[string]float64)
fmt.Println(myMap)
}
I get the error:
panic: interface conversion: main.T is map[string]interface {}, not map[string]float64
I can do the following:
func main() {
// A first assertion
res := jsonMap().(map[string]interface{})
myMap := map[string]float64{
"test": res["test"].(float64), // A second assertion
}
fmt.Println(myMap)
}
This works fine, but I find it very ugly since I need to reconstruct the whole map and use two assertions. Is there a correct way to force the first assertion to drop the interface{}
and use float64
? In other words, what is the correct way to do the original assertion .(map[string]float64)
?
Edit:
The actual data I'm parsing looks like this:
[
{"Type":"pos",
"Content":{"x":0.5 , y: 0.3}} ,
{"Type":"vel",
"Content":{"vx": 0.1, "vy": -0.2}}
]
In Go I use a struct
and encoding/json
in the following way.
type data struct {
Type string
Content interface{}
}
// I read the JSON from a WebSocket connection
_, event, _ := c.ws.ReadMessage()
j := make([]data,0)
json.Unmarshal(event, &j)
You cannot type assert map[string]interface{}
to map[string]float64
. You need to manually create new map.
package main
import (
"encoding/json"
"fmt"
)
var exampleResponseData = `{
"Data":[
{
"Type":"pos",
"Content":{
"x":0.5,
"y":0.3
}
},
{
"Type":"vel",
"Content":{
"vx":0.1,
"vy":-0.2
}
}
]
}`
type response struct {
Data []struct {
Type string
Content interface{}
}
}
func main() {
var response response
err := json.Unmarshal([]byte(exampleResponseData), &response)
if err != nil {
fmt.Println("Cannot process not valid json")
}
for i := 0; i < len(response.Data); i++ {
response.Data[i].Content = convertMap(response.Data[i].Content)
}
}
func convertMap(originalMap interface{}) map[string]float64 {
convertedMap := map[string]float64{}
for key, value := range originalMap.(map[string]interface{}) {
convertedMap[key] = value.(float64)
}
return convertedMap
}
Are you sure you cannot define Content
as map[string]float64
? See example below. If not, how can you know that you can cast it in the first place?
type response struct {
Data []struct {
Type string
Content map[string]float64
}
}
var response response
err := json.Unmarshal([]byte(exampleResponseData), &response)
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.