CODEWITHSUNDEEP
dictionaryreflectiongointerface
SamTech
SamTech

Reputation: 1313

How to convert interface{} to map

I am trying to create a function that could accept following

*struct
[]*struct
map[string]*struct

Here struct could be any struct not just a specific one. Converting interface to *struct or []*struct is working fine. But giving error for map.

After reflect it shows it is map[] but giving error when try to iterate over range.

Here is code

package main

import (
    "fmt"
    "reflect"
)

type Book struct {
    ID     int
    Title  string
    Year   int
}

func process(in interface{}, isSlice bool, isMap bool) {
    v := reflect.ValueOf(in)

    if isSlice {
        for i := 0; i < v.Len(); i++ {
            strct := v.Index(i).Interface()
            //... proccess struct
        }
        return
    }

    if isMap {
        fmt.Printf("Type: %v\n", v)     // map[]
        for _, s := range v {           // Error: cannot range over v (type reflect.Value)
            fmt.Printf("Value: %v\n", s.Interface())
        }
    }    
}

func main() {
    b := Book{}
    b.Title = "Learn Go Language"
    b.Year = 2014
    m := make(map[string]*Book)
    m["1"] = &b

    process(m, false, true)
}

Is there any way to convert interface{} to map and iterate or get it's elements.

Upvotes: 56

Views: 136539

Answers (4)

Vikram Biwal
Vikram Biwal

Reputation: 2826

This may help:

b := []byte(`{"keyw":"value"}`)

var f interface{}
json.Unmarshal(b, &f)

myMap := f.(map[string]interface{})

fmt.Println(myMap)

Upvotes: 8

Nicolas Filotto
Nicolas Filotto

Reputation: 44965

Another way to convert an interface{} into a map with the package reflect is with MapRange.

I quote:

MapRange returns a range iterator for a map. It panics if v's Kind is not Map.

Call Next to advance the iterator, and Key/Value to access each entry. Next returns false when the iterator is exhausted. MapRange follows the same iteration semantics as a range statement.

Example:

iter := reflect.ValueOf(m).MapRange()
for iter.Next() {
    key := iter.Key().Interface()
    value := iter.Value().Interface()
    ...
}

Upvotes: 0

Thundercat
Thundercat

Reputation: 120951

If the map value can be any type, then use reflect to iterate through the map:

if v.Kind() == reflect.Map {
    for _, key := range v.MapKeys() {
        strct := v.MapIndex(key)
        fmt.Println(key.Interface(), strct.Interface())
    }
}

playground example

If there's a small and known set of struct types, then a type switch can be used:

func process(in interface{}) {
  switch v := in.(type) {
  case map[string]*Book:
     for s, b := range v {
         // b has type *Book
         fmt.Printf("%s: book=%v\n" s, b)
     }
  case map[string]*Author:
     for s, a := range v {
         // a has type *Author
         fmt.Printf("%s: author=%v\n" s, a)
     }
   case []*Book:
     for i, b := range v {
         fmt.Printf("%d: book=%v\n" i, b)
     }
   case []*Author:
     for i, a := range v {
         fmt.Printf("%d: author=%v\n" i, a)
     }
   case *Book:
     fmt.Ptintf("book=%v\n", v)
   case *Author:
     fmt.Printf("author=%v\n", v)
   default:
     // handle unknown type
   }
}

Upvotes: 55

cnicutar
cnicutar

Reputation: 182639

You don't need reflect here. Try:

v, ok := in.(map[string]*Book)
if !ok {
    // Can't assert, handle error.
}
for _, s := range v {
    fmt.Printf("Value: %v\n", s)
}

Same goes for the rest of your function. It looks like you're using reflection when you would be better served by a type switch.

Alternatively, if you insist on using reflection here (which doesn't make a lot of sense) you can also use Value.MapKeys with the result from your ValueOf (see the answer https://stackoverflow.com/a/38186057/714501)

Upvotes: 60

Related Questions