Cast emtpy interface to its equivalent type in Golang

Question

Convert dynamic interface to its equivalent type. For example if value is int it should return int and if is string so it return int.

Code example:

var options = bson.M{}
for _, val := range conditions {
    var attr, operator, value interface{}
    cons := val.(map[interface{}]interface{})

    for range cons {
        attr     = cons["attribute"]
        operator = cons["operator"]
        value    = cons["value"]
        switch operator {
            case "==":
                operator = "$eq"
            case "!=":
                operator = "$ne"
            case "()":
                operator = "$in"
                value = []string{fmt.Sprintf("%v", value)}
        }
        options[attr.(string)] = bson.M{operator.(string): value. 
        (int)}
    }
}

Conditions come in below format.

conditions []interface{}
cons = append(cons, map[interface{}]interface{}{"attribute": 
"discontinued", "operator": "!=", "value": 1})

cons = append(cons, map[interface{}]interface{}{"attribute": "status", 
"operator": "==", "value": 1})

cons = append(cons, map[interface{}]interface{}{"attribute": 
"visibility", "operator": "==", "value": 4})

But the "value": 4 OR "value": 1 is not confirm.

Error thrown: interface conversion: interface {} is string, not int

Answer 1

You can implement recursion to get the underlying value of interface using type assertions. Implement a Switch case and then call it recursively until you found the primitive type for unknown types. Since if you are parsing anything inside the interface it will surely be of below types.

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

Check for below code on how to implement the approach.

package main

import (
    "fmt"
)

func main() {
     res, err := g.Execute( // Sends a query to Gremlin Server with bindings
           "g.V(x)",
            map[string]string{"x": "1234"},
            map[string]string{},
     )
     if err != nil {
          fmt.Println(err)
          return
     }
     fetchValue(res)
}

func fetchValue(value interface{}) {
    switch value.(type) {
    case string:
        fmt.Printf("%v is an interface \n ", value)
    case bool:
        fmt.Printf("%v is bool \n ", value)
    case float64:
        fmt.Printf("%v is float64 \n ", value)
    case []interface{}:
        fmt.Printf("%v is a slice of interface \n ", value)
        for _, v := range value.([]interface{}) { // use type assertion to loop over []interface{}
            fetchValue(v)
        }
    case map[string]interface{}:
        fmt.Printf("%v is a map \n ", value)
        for _, v := range value.(map[string]interface{}) { // use type assertion to loop over map[string]interface{}
            fetchValue(v)
        }
    default:
        fmt.Printf("%v is unknown \n ", value)
    }
}