Convertir l'interface{} en int

Question

J'essaie d'obtenir une valeur à partir d'un JSON et de la convertir en int, mais cela ne fonctionne pas, et je ne sais pas comment le faire correctement.

Voici le message d'erreur :

...cannot convert val (type interface {}) to type int: need type assertion

Et le code :

    var f interface{}
    err = json.Unmarshal([]byte(jsonStr), &f)
    if err != nil {
        utility.CreateErrorResponse(w, "Error: failed to parse JSON data.")
        return
    }

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

    val, ok := m["area_id"]
    if !ok {
        utility.CreateErrorResponse(w, "Error: Area ID is missing from submitted data.")
        return
    }

    fmt.Fprintf(w, "Type = %v", val)   // <--- Type = float64
    iAreaId := int(val)                // <--- Error on this line.
    testName := "Area_" + iAreaId      // not reaching here

Answer 1

Peut-être avez-vous besoin

func TransToString(data interface{}) (res string) {
    switch v := data.(type) {
    case float64:
        res = strconv.FormatFloat(data.(float64), 'f', 6, 64)
    case float32:
        res = strconv.FormatFloat(float64(data.(float32)), 'f', 6, 32)
    case int:
        res = strconv.FormatInt(int64(data.(int)), 10)
    case int64:
        res = strconv.FormatInt(data.(int64), 10)
    case uint:
        res = strconv.FormatUint(uint64(data.(uint)), 10)
    case uint64:
        res = strconv.FormatUint(data.(uint64), 10)
    case uint32:
        res = strconv.FormatUint(uint64(data.(uint32)), 10)
    case json.Number:
        res = data.(json.Number).String()
    case string:
        res = data.(string)
    case []byte:
        res = string(v)
    default:
        res = ""
    }
    return
}

Answer 2

Pour mieux comprendre la conversion de type, regardez le code ci-dessous :

package main
import "fmt"
func foo(a interface{}) {
    fmt.Println(a.(int))  // conversion of interface into int
}
func main() {
    var a int = 10
    foo(a)
}

Ce code s'exécute parfaitement et convertit le type interface en type int.

Pour une expression x de type interface et un type T, l'expression primaire x.(T) affirme que x n'est pas nil et que la valeur stockée dans x est de type T. La notation x.(T) est appelée une assertion de type. Plus précisément, si T n'est pas un type d'interface, x.(T) affirme que le type dynamique de x est identique au type T. Dans ce cas, T doit implémenter le type (d'interface) de x ; sinon l'assertion de type est invalide puisqu'il n'est pas possible pour x de stocker une valeur de type T. Si T est un type interface, x.(T) affirme que le type dynamique de x implémente l'interface T.

En revenant à votre code, ceci

iAreaId := val.(int)

devrait fonctionner correctement. Si vous voulez vérifier les erreurs survenues lors de la conversion, vous pouvez aussi réécrire la ligne ci-dessus comme suit

iAreaId, ok := val.(int)

Answer 3

Vous devez faire une assertion de type pour convertir votre interface{} en valeur int.

iAreaId := val.(int)
iAreaId, ok := val.(int)

Pour plus d'informations, voir disponible sur .

Answer 4

J'ai écrit une bibliothèque qui peut aider avec les conversions de type. https://github.com/KromDaniel/jonson

js := jonson.New([]interface{}{55.6, 70.8, 10.4, 1, "48", "-90"})

js.SliceMap(func(jsn *jonson.JSON, index int) *jonson.JSON {
    jsn.MutateToInt()
    return jsn
}).SliceMap(func(jsn *jonson.JSON, index int) *jonson.JSON {
    if jsn.GetUnsafeInt() > 50{
        jsn.MutateToString()
    }
    return jsn
}) // ["55","70",10,1,48,-90]

Answer 5

La façon la plus simple dont j'ai procédé. Pas la meilleure, mais la plus simple que je connaisse.

import "fmt"

func main() {
    fmt.Print(addTwoNumbers(5, 6))
}

func addTwoNumbers(val1 interface{}, val2 interface{}) int {
    op1, _ := val1.(int)
    op2, _ := val2.(int)

    return op1 + op2
}