Go语言中模拟扩展方法与动态访问嵌套JSON的策略

package main

import "fmt"

// MyString 定义了一个基于string的新类型
type MyString string

// CustomMethod 为MyString类型定义了一个方法
func (m MyString) CustomMethod() {
    fmt.Printf("调用了MyString的CustomMethod，值为: %s\n", m)
}

// 也可以定义指针接收器方法，如果需要修改接收器本身
func (m *MyString) AppendText(suffix string) {
    *m = *m + MyString(suffix)
    fmt.Printf("AppendText后，值为: %s\n", *m)
}

func main() {
    var s MyString = "Hello"
    s.CustomMethod() // 直接在MyString类型的变量上调用方法

    var ptrS MyString = "World"
    ptrS.AppendText(" Go!") // 调用指针接收器方法
    fmt.Printf("最终值: %s\n", ptrS)

    // 注意：你不能直接在内置的string类型上调用CustomMethod
    // var plainString string = "Go"
    // plainString.CustomMethod() // 编译错误
}

{
 "data": {
  "issued": "2023-01-01",
  "details": {
   "amount": 100
  }
 }
}

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    jsonStr := `{
        "data": {
            "issued": "2023-01-01",
            "details": {
                "amount": 100
            }
        }
    }`

    var config map[string]interface{}
    err := json.Unmarshal([]byte(jsonStr), &config)
    if err != nil {
        fmt.Println("JSON解析错误:", err)
        return
    }

    // 手动逐层访问
    if data, ok := config["data"].(map[string]interface{}); ok {
        if issued, ok := data["issued"].(string); ok {
            fmt.Println("Issued:", issued) // 输出: Issued: 2023-01-01
        }
        if details, ok := data["details"].(map[string]interface{}); ok {
            if amount, ok := details["amount"].(float64); ok { // JSON数字默认解析为float64
                fmt.Println("Amount:", amount) // 输出: Amount: 100
            }
        }
    }
}

package main

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

// GetValueByPath 根据点分路径从map[string]interface{}中获取值
func GetValueByPath(data map[string]interface{}, path string) (interface{}, error) {
    keys := strings.Split(path, ".")
    currentValue := interface{}(data)

    for _, key := range keys {
        if m, ok := currentValue.(map[string]interface{}); ok {
            if val, exists := m[key]; exists {
                currentValue = val
            } else {
                return nil, fmt.Errorf("路径中键 '%s' 不存在", key)
            }
        } else if arr, ok := currentValue.([]interface{}); ok {
            // 如果当前值是数组，尝试将key解析为索引
            idx, err := parseArrayIndex(key)
            if err != nil {
                return nil, fmt.Errorf("路径中键 '%s' 无法作为数组索引: %w", key, err)
            }
            if idx >= 0 && idx < len(arr) {
                currentValue = arr[idx]
            } else {
                return nil, fmt.Errorf("数组索引 '%d' 超出范围", idx)
            }
        } else {
            return nil, fmt.Errorf("路径中 '%s' 不是一个map或array，无法继续遍历", key)
        }
    }
    return currentValue, nil
}

// parseArrayIndex 尝试将字符串解析为数组索引
func parseArrayIndex(key string) (int, error) {
    var idx int
    _, err := fmt.Sscanf(key, "%d", &idx)
    if err != nil {
        return -1, fmt.Errorf("无法将 '%s' 解析为整数索引", key)
    }
    return idx, nil
}

func main() {
    jsonStr := `{
        "_id": 2001,
        "address": {
            "line1": "123 Main St",
            "line2": "",
            "line3": ""
        },
        "tickets": [
            {
                "seq": 1,
                "add": [
                    {"seq": "A", "amnt": 50},
                    {"seq": "B", "amnt": 60}
                ]
            },
            {
                "seq": 2,
                "add": [
                    {"seq": "C", "amnt": 70}
                ]
            }
        ]
    }`

    var config map[string]interface{}
    err := json.Unmarshal([]byte(jsonStr), &config)
    if err != nil {
        fmt.Println("JSON解析错误:", err)
        return
    }

    // 示例用法
    val, err := GetValueByPath(config, "address.line1")
    if err != nil {
        fmt.Println("获取值失败:", err)
    } else {
        fmt.Printf("address.line1: %v (类型: %T)\n", val, val)
    }

    val, err = GetValueByPath(config, "tickets.0.seq") // 访问数组第一个元素的seq
    if err != nil {
        fmt.Println("获取值失败:", err)
    } else {
        fmt.Printf("tickets.0.seq: %v (类型: %T)\n", val, val)
    }

    val, err = GetValueByPath(config, "tickets.0.add.1.amnt") // 访问数组第一个ticket的add数组的第二个元素的amnt
    if err != nil {
        fmt.Println("获取值失败:", err)
    } else {
        fmt.Printf("tickets.0.add.1.amnt: %v (类型: %T)\n", val, val)
    }

    val, err = GetValueByPath(config, "non.existent.path")
    if err != nil {
        fmt.Println("获取值失败 (预期错误):", err)
    } else {
        fmt.Printf("non.existent.path: %v (类型: %T)\n", val, val)
    }
}