Go语言JSON解析：如何高效处理result字段类型不确定且数量不定的问题？

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

// 定义JSON结构体接口 (可选，取决于你的需求)
type JSONStruct interface {
    MarshalJSON() ([]byte, error)
    UnmarshalJSON([]byte) error
}

// 解析JSON到结构体
func UnmarshalJSONDynamic(jsonStr string) (interface{}, error) {
    var data map[string]interface{}
    err := json.Unmarshal([]byte(jsonStr), &data)
    if err != nil {
        return nil, err
    }

    // 获取result字段
    resultData, ok := data["result"]
    if !ok {
        return nil, fmt.Errorf("result field not found")
    }

    // 根据result字段类型创建切片或其他结构
    resultSlice := reflect.MakeSlice(reflect.SliceOf(reflect.TypeOf(resultData)), 0, 0)

    // 遍历resultData，将元素添加到切片
    switch resultData := resultData.(type) {
    case []interface{}:
        for _, item := range resultData {
            resultSlice = reflect.Append(resultSlice, reflect.ValueOf(item))
        }
    default:
        return nil, fmt.Errorf("unsupported result type")
    }


    return resultSlice.Interface(), nil
}

func main() {
    jsonStr := `{
        "success": true,
        "message": "操作成功！",
        "code": 200,
        "result": [104887127, "xxxxx", "xxxxx"],
        "timestamp": 1561395039616
    }`

    result, err := UnmarshalJSONDynamic(jsonStr)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // 访问result字段
    resultSlice := result.([]interface{})
    for _, value := range resultSlice {
        fmt.Println(reflect.TypeOf(value), value)
    }
}