Go语言中处理动态JSON结构与嵌套属性的最佳实践

type Frame struct {
    Type  string                 `json:"type"`
    Value map[string]interface{} `json:"value"`
}

var data Frame
// 假设JSON数据为：
// {
//   "type": "image",
//   "value": {
//     "Imagedata": "some_filename.jpg",
//     "Size": 1024
//   }
// }
// json.Unmarshal(jsonData, &data)

if data.Type == "image" {
    // 访问map中的键
    if imageData, ok := data.Value["Imagedata"]; ok {
        fmt.Printf("Image data found: %v\n", imageData)
    } else {
        fmt.Printf("Imagedata key not found in Value map.\n")
    }
}

if data.Type == "image" {
    if imageDataInterface, ok := data.Value["Imagedata"]; ok {
        // 进行类型断言，尝试转换为string
        if imageDataString, isString := imageDataInterface.(string); isString {
            fmt.Printf("Image filename: %s\n", imageDataString)
        } else {
            fmt.Printf("Imagedata is not a string, actual type: %T\n", imageDataInterface)
        }
    }

    if sizeInterface, ok := data.Value["Size"]; ok {
        // 进行类型断言，尝试转换为float64 (JSON数字默认解析为float64)
        if sizeFloat, isFloat := sizeInterface.(float64); isFloat {
            fmt.Printf("Image size: %.0f bytes\n", sizeFloat)
        } else {
            fmt.Printf("Size is not a float64, actual type: %T\n", sizeInterface)
        }
    }
}

type FrameWithAnon struct {
    Type  string `json:"type"`
    Value struct { // 匿名结构体
        Imagedata string `json:"image_data"` // 注意JSON tag，如果JSON键名不同
        Width     int    `json:"width"`
        Height    int    `json:"height"`
    } `json:"value"`
}

// 假设JSON数据为：
// {
//   "type": "image",
//   "value": {
//     "image_data": "another_filename.png",
//     "width": 800,
//     "height": 600
//   }
// }
// var dataAnon FrameWithAnon
// json.Unmarshal(jsonData, &dataAnon)

// 访问方式：
fmt.Printf("Image data: %s\n", dataAnon.Value.Imagedata)
fmt.Printf("Image dimensions: %dx%d\n", dataAnon.Value.Width, dataAnon.Value.Height)

// 定义一个独立的ImageValue结构体
type ImageValue struct {
    Imagedata string `json:"image_data"`
    Width     int    `json:"width"`
    Height    int    `json:"height"`
}

type FrameWithSeparate struct {
    Type  string     `json:"type"`
    Value ImageValue `json:"value"` // 使用独立的结构体类型
}

// 假设JSON数据与上面匿名结构体示例相同
// var dataSeparate FrameWithSeparate
// json.Unmarshal(jsonData, &dataSeparate)

// 访问方式：
fmt.Printf("Image data: %s\n", dataSeparate.Value.Imagedata)
fmt.Printf("Image dimensions: %dx%d\n", dataSeparate.Value.Width, dataSeparate.Value.Height)

import (
    "encoding/json"
    "fmt"
)

type ImageInfo struct {
    Filename string `json:"filename"`
    Size     int    `json:"size"`
}

type TextInfo struct {
    Content string `json:"content"`
    Author  string `json:"author"`
}

type GenericFrame struct {
    Type  string          `json:"type"`
    Value json.RawMessage `json:"value"` // 暂时保存原始JSON字节
}

func main() {
    jsonDataImage := []byte(`{"type": "image", "value": {"filename": "pic.jpg", "size": 1024}}`)
    jsonDataText := []byte(`{"type": "text", "value": {"content": "Hello Go!", "author": "Gopher"}}`)

    processFrame(jsonDataImage)
    fmt.Println("---")
    processFrame(jsonDataText)
}

func processFrame(jsonData []byte) {
    var genericFrame GenericFrame
    if err := json.Unmarshal(jsonData, &genericFrame); err != nil {
        fmt.Printf("Error unmarshaling generic frame: %v\n", err)
        return
    }

    fmt.Printf("Frame Type: %s\n", genericFrame.Type)

    switch genericFrame.Type {
    case "image":
        var imageInfo ImageInfo
        if err := json.Unmarshal(genericFrame.Value, &imageInfo); err != nil {
            fmt.Printf("Error unmarshaling image info: %v\n", err)
            return
        }
        fmt.Printf("Image Filename: %s, Size: %d\n", imageInfo.Filename, imageInfo.Size)
    case "text":
        var textInfo TextInfo
        if err := json.Unmarshal(genericFrame.Value, &textInfo); err != nil {
            fmt.Printf("Error unmarshaling text info: %v\n", err)
            return
        }
        fmt.Printf("Text Content: %s, Author: %s\n", textInfo.Content, textInfo.Author)
    default:
        fmt.Printf("Unknown frame type: %s\n", genericFrame.Type)
    }
}