Golang 结构转换接口出现问题

最近发现不少小伙伴都对Golang很感兴趣，所以今天继续给大家介绍Golang相关的知识，本文《Golang 结构转换接口出现问题》主要内容涉及到等等知识点，希望能帮到你！当然如果阅读本文时存在不同想法，可以在评论中表达，但是请勿使用过激的措辞~

我有一个 json 作为以下格式的字符串：

{"add": [{"var": ["100"]}, "200"]}

这里的键“add”并不是所有 json 的常量值。在某些情况下，它可以是“减”、“乘”等。 该键的值是一个数组。在本例中为 [{"var": ["100"]}, "200"]。这意味着 100 应添加到现有值 200 中。

我正在尝试解析这个表达式。由于主键（在本例中为“add”）不是常量，因此我无法转换为结构。因此，我通过以下方式将其转换为 json 对象：

type mathExpVar struct {
    valueVar []string `json:"var"`
}
var mathExpJson map[string][]interface{}
var input = "{\"add\": [{\"var\": [\"100\"]}, \"200\"]}"
err := json.Unmarshal([]byte(input), &mathExpJson)
for operator, values := range mathExpJson{
    vals, ok := values[0].(mathExpVar) // here values[0] will be {"var": ["100"]}
    if !ok{
        return nil
    }
}

这里的“ok”总是返回 false。我不知道为什么。没有其他错误消息可供我检查失败的原因。有人可以帮我解决这个问题吗？

链接到相同的演示：https://go.dev/play/p/pofqmeopbjd

正确答案

这里解析的 json 值的整个结构将存储在嵌套的 map[string]interface{}(json object) 或 []interface{}(json array) 类型中。

行中：

vals, ok := values[0].(mathexpvar)

values[0] 的类型为 map[string]interface{}，不能断言为 mathexpvar，它是一个结构体，是一种完全不同的数据类型。

您需要首先向 map[string]interface{} 输入断言，然后在继续操作时在每个嵌套级别中执行此操作：

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    type mathexpvar struct {
        valuevar []string `json:"var"`
    }
    var mathexpjson map[string][]interface{}
    var input = "{\"add\": [{\"var\": [\"100\"]}, \"200\"]}"
    err := json.unmarshal([]byte(input), &mathexpjson)
    if err != nil {
        fmt.println("error in unmarshalling")
    }
    for _, values := range mathexpjson {
        var vals mathexpvar
        valmap, ok := values[0].(map[string]interface{})
        if ok {
            varslice, ok := valmap["var"].([]interface{})
            if ok {
                for _, v := range varslice {
                    nv, ok := v.(string)
                    if ok {
                        vals.valuevar = append(vals.valuevar, nv)
                    } else {
                        fmt.printf("%t\n", v)
                    }
                }
            } else {
                fmt.printf("%t\n", valmap["var"])
            }
        } else {
            fmt.printf("%t\n", values[0])
        }
        fmt.printf("%+v\n", vals)
    }
}

参见：https://go.dev/play/p/Ot_9IZr4pwM

有关接口和 go 反射的更多信息，请查看：https://go.dev/blog/laws-of-reflection

工作示例：https://go.dev/play/p/02YzI5cv8vV

在我看来，burak serdar 的原始响应无效的全部原因是它没有考虑到您还需要处理其余参数的事实。如果您仔细观察，您会发现该表达式不是字符串数组，而是不同类型的。此实现处理自定义解组并将所有额外参数存储在 extra 字段中。

还有代码：

package main

import (
    "encoding/json"
    "log"
    "reflect"
)

const jsonPayload = "{\"add\": [{\"var\": [\"100\"]}, \"200\"]}"

func main() {

    data := MathExpressions{}
    err := json.Unmarshal([]byte(jsonPayload), &data)

    if err != nil {
        log.Println("Failed to unmarshal json, error:", err)
        return
    }

    log.Println(data)

    for operation, expression := range data {
        log.Print("Op:", operation, "Exp:", expression)
    }

    log.Println("Finished..")
}

/**
The sub definition for a specific expression in the object
*/
type ExpressionDefinition struct {
    Vars  []string `json:"var"`
    Extra []string
}

func (e *ExpressionDefinition) UnmarshalJSON(data []byte) error {
    tokens := make([]interface{}, 0)
    err := json.Unmarshal(data, &tokens)

    if err != nil {
        return err
    }

    for _, token := range tokens {
        log.Println("Processing token:", token, "type:", reflect.TypeOf(token))
        switch token.(type) {
        case map[string]interface{}:
            for _, v := range token.(map[string]interface{})["var"].([]interface{}) {
                e.Vars = append(e.Vars, v.(string))
            }
        case string:
            e.Extra = append(e.Extra, token.(string))
        }
    }

    log.Println(tokens)
    return nil
}

/**
The main expressions object which contains all the sub-expressions.
*/
type MathExpressions map[string]ExpressionDefinition

今天关于《Golang 结构转换接口出现问题》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！