Go语言中处理动态JSON数据的高效策略：方法扩展与路径式访问

package main

import "fmt"

// MyString 是基于 string 的自定义类型
type MyString string

// Greet 方法为 MyString 类型添加行为
func (m MyString) Greet() {
    fmt.Printf("Hello, %s!\n", m)
}

func main() {
    var s MyString = "World"
    s.Greet() // 输出: Hello, World!
}

package main

import (
    "encoding/json"
    "fmt"
    "strconv"
    "strings"
)

// JSONMap 是一个基于 map[string]interface{} 的自定义类型，用于增强JSON数据操作。
type JSONMap map[string]interface{}

// Get 方法根据点分隔的路径字符串（如 "data.issued" 或 "tickets.0.seq"）从JSONMap中检索值。
// 它返回找到的值和是否成功找到的布尔值。
func (jm JSONMap) Get(path string) (interface{}, bool) {
    keys := strings.Split(path, ".")
    current := interface{}(jm) // 从当前的JSONMap开始遍历

    for _, key := range keys {
        if m, ok := current.(map[string]interface{}); ok {
            // 当前是 map 类型，尝试按键查找
            if val, found := m[key]; found {
                current = val
            } else {
                return nil, false // 键不存在
            }
        } else if arr, ok := current.([]interface{}); ok {
            // 当前是 slice (数组) 类型，尝试将键解析为索引
            idx, err := strconv.Atoi(key)
            if err == nil && idx >= 0 && idx < len(arr) {
                current = arr[idx]
            } else {
                return nil, false // 键不是有效的数组索引，或索引越界
            }
        } else {
            return nil, false // 当前值既不是 map 也不是 slice，无法继续遍历
        }
    }
    return current, true // 成功找到并返回最终值
}

// 示例JSON数据
const sampleJSON = `{
 "_id" : 2001,
    "address" : {
        "line1" : "123 Main St",
        "line2" : "Apt 4B",
        "line3" : "Some City"
       },
    "tickets" : [
        {
            "seq" : 2,
            "add" : [
              {
              "seq" : "A1",
              "amnt" : 50
              },
              {
              "seq" : "A2",
              "amnt" : 75
              }
            ]
        },
        {
            "seq" : 3,
            "add" : [
              {
              "seq" : "B1",
              "amnt" : 100
              }
            ]
        }
    ]
}`

func main() {
    var config JSONMap
    err := json.Unmarshal([]byte(sampleJSON), &config)
    if err != nil {
        fmt.Printf("JSON解析失败: %v\n", err)
        return
    }

    fmt.Println("--- 深度访问示例 ---")

    // 访问嵌套的map字段
    if line1, found := config.Get("address.line1"); found {
        fmt.Printf("address.line1: %v (类型: %T)\n", line1, line1)
    } else {
        fmt.Println("address.line1: 未找到")
    }

    // 访问数组中的特定元素及其字段
    if ticketSeq, found := config.Get("tickets.0.seq"); found {
        fmt.Printf("tickets.0.seq: %v (类型: %T)\n", ticketSeq, ticketSeq)
    } else {
        fmt.Println("tickets.0.seq: 未找到")
    }

    // 访问数组中嵌套数组的元素
    if amnt, found := config.Get("tickets.0.add.1.amnt"); found {
        fmt.Printf("tickets.0.add.1.amnt: %v (类型: %T)\n", amnt, amnt)
    } else {
        fmt.Println("tickets.0.add.1.amnt: 未找到")
    }

    // 访问不存在的路径
    if nonExistent, found := config.Get("data.issued"); found {
        fmt.Printf("data.issued: %v\n", nonExistent)
    } else {
        fmt.Println("data.issued: 未找到")
    }

    if nonExistentArray, found := config.Get("tickets.99.seq"); found {
        fmt.Printf("tickets.99.seq: %v\n", nonExistentArray)
    } else {
        fmt.Println("tickets.99.seq: 未找到")
    }

    fmt.Println("\n--- 原始JSON数据 (部分) ---")
    // 对比原生访问方式
    if addr, ok := config["address"].(map[string]interface{}); ok {
        if line1, ok := addr["line1"]; ok {
            fmt.Printf("原生访问 address.line1: %v\n", line1)
        }
    }
}