Go语言中的方法定义与动态JSON数据处理：替代.NET扩展方法的方式

package main

import "fmt"

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

// 为MyString类型定义一个方法
func (m MyString) Greet() {
    fmt.Printf("Hello from MyString: %s\n", m)
}

// 也可以为指针接收者定义方法
func (m *MyString) Append(suffix string) {
    *m = *m + MyString(suffix)
}

func main() {
    var s MyString = "Go Developer"
    s.Greet() // 调用值接收者方法

    var ptrS *MyString = &s
    ptrS.Append("!") // 调用指针接收者方法
    fmt.Printf("Modified MyString: %s\n", *ptrS)
}

package main

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

// GetNestedValue 通过点分路径从map[string]interface{}中获取嵌套值
// path示例: "data.issued", "address.line1", "tickets.0.amnt"
func GetNestedValue(data map[string]interface{}, path string) (interface{}, error) {
    keys := strings.Split(path, ".")
    currentValue := interface{}(data)

    for _, key := range keys {
        switch v := currentValue.(type) {
        case map[string]interface{}:
            // 如果当前是map，尝试按key获取
            if val, ok := v[key]; ok {
                currentValue = val
            } else {
                return nil, fmt.Errorf("path not found: %s in %v", key, v)
            }
        case []interface{}:
            // 如果当前是数组，尝试将key解析为索引
            index, err := fmt.Atoi(key)
            if err != nil || index < 0 || index >= len(v) {
                return nil, fmt.Errorf("invalid array index or path not found: %s in %v", key, v)
            }
            currentValue = v[index]
        default:
            return nil, fmt.Errorf("cannot navigate through non-map/non-array type at key: %s, type: %T", key, currentValue)
        }
    }
    return currentValue, nil
}

func main() {
    jsonStr := `{
        "_id" : 2001,
        "address" : {
            "line1" : "123 Main St",
            "line2" : "Apt 4B",
            "line3" : ""
        },
        "tickets" : [ 
            {
                "seq" : 2,
                "add" : [
                    { "seq" : "A", "amnt" : 50 },
                    { "seq" : "B", "amnt" : 75 }
                ]
            },
            {
                "seq" : 3,
                "add" : [
                    { "seq" : "C", "amnt" : 100 }
                ]
            }
        ],
        "data": {
            "issued": "2023-01-01"
        }
    }`

    var config map[string]interface{}
    err := json.Unmarshal([]byte(jsonStr), &config)
    if err != nil {
        fmt.Printf("Error unmarshalling JSON: %v\n", err)
        return
    }

    // 示例1: 访问嵌套的map字段
    if issuedDate, err := GetNestedValue(config, "data.issued"); err == nil {
        fmt.Printf("Issued Date: %v (Type: %T)\n", issuedDate, issuedDate)
    } else {
        fmt.Printf("Error getting data.issued: %v\n", err)
    }

    // 示例2: 访问嵌套的数组元素及其字段
    if firstTicketAmnt, err := GetNestedValue(config, "tickets.0.add.0.amnt"); err == nil {
        fmt.Printf("First Ticket Amount: %v (Type: %T)\n", firstTicketAmnt, firstTicketAmnt)
    } else {
        fmt.Printf("Error getting tickets.0.add.0.amnt: %v\n", err)
    }

    // 示例3: 访问不存在的路径
    if nonExistent, err := GetNestedValue(config, "address.city"); err != nil {
        fmt.Printf("Error getting address.city: %v\n", err)
    }

    // 示例4: 访问类型不匹配的路径
    if invalidPath, err := GetNestedValue(config, "address.line1.subfield"); err != nil {
        fmt.Printf("Error getting address.line1.subfield: %v\n", err)
    }
}