如何有效地自定義展平地圖

因此，根據傳遞的 resourcesToCreate 引數，我必須相應地創建它們以創建流程，并且我已經為其撰寫了以下邏輯

resourcesToCreate := "func1-func3"

func createFlow(resourcesToCreate) {
    resources := strings.Split(resourcesToCreate, "-")

    for _, resource := range resources {
        switch resource {
        case "func1":
            func1Input := func1Input{}
            func1(func1Input)

        case "func2":
            func2Input := func2Input{}
            func2(func2Input)

        case "func3":
            func3Input := func3Input{}
            func3(func3Input)
        }
      }
}

但現在的問題是，在分配 funcInput 時，json 實際上是根據它創建的流嵌套的，并且屬性可以出現在任何地方，所以我無法進行硬編碼。

Example 1: Contains on one resource
"config": {
        "type": "func3",
        "properties": {
            "param1": "10",
            "param2": "10"
        }
    }

Example 2: Contains 2 resources connected to each other
"config": {
    "type": "func1",
    "properties": {
        "param1": "10",
        "param2": "10"
    },
    "connected": [
        {
            "type": "func3",
            "properties": {
              "param1": "10",
              "param2": "10"
            },
            "connected": [
                {}
        },
    ],
}

所以在想它我像這樣把它弄平我可以參考而不考慮流量

{
"func1": {
        "param1": "10",
        "param2": "10"
    },
"func3" : {
        "param1": "10",
        "param2": "10"
    },
}

所以現在我可以輕松地對路徑進行硬編碼

func3Config := config["func3"]
func3Input := func3Input{
     param1: func3Config["param1"]
     param2: func3Config["param2"]
}

因此，代碼當前使 json 變胖，但無法獲得所需的輸出

func Flatten(prefix string, src map[string]interface{}, dest map[string]interface{}) {
    if len(prefix) > 0 {
        prefix  = "."
    }
    for k, v := range src {
        switch child := v.(type) {
        case map[string]interface{}:
            Flatten2(prefix k, child, dest)
        case []interface{}:
            for i := 0; i < len(child); i   {
                dest[prefix k "." strconv.Itoa(i)] = child[i]
            }
        default:
            dest[prefix k] = v
        }
    }
}
``

uj5u.com熱心網友回復：

這種扁平化更像是提取值。通用方式是不可能的，而是依賴于 JSON 鍵，如type，properties并connected有效地提取func和param值。你的 flatten 函式應該是這樣的：

func keyValuePairs(m interface{}) map[string]interface{} {
    kvs := make(map[string]interface{})
    if reflect.ValueOf(m).Kind() == reflect.Map {
        mp, ok := m.(map[string]interface{})
        if ok {
            var key string
            var value interface{}
            for k, v := range mp {
                switch k {
                case "type":
                    key = v.(string)
                case "properties":
                    value = v
                case "connected":
                    if collection, ok := v.([]interface{}); ok {
                        for _, c := range collection {
                            for nk, nv := range keyValuePairs(c) {
                                kvs[nk] = nv
                            }
                        }
                    }
                default:
                    for nk, nv := range keyValuePairs(v) {
                        kvs[nk] = nv
                    }
                }
            }
            if key != "" {
                kvs[key] = value
            }
        } else {
            for k, v := range m.(map[string]interface{}) {
                kvs[k] = v
            }
        }
    }
    return kvs
}

帶有示例輸入的相同代碼：Go Playground

為了更好地理解代碼片段，請查看我實際上將 JSON 扁平化為最后一個鍵值對的這個要點。

標籤：去

上一篇：Golang：“ErrTLSHandshakefailed:tls:serverselectedunsupportedprotocolversion301”嘗試連接到sqlserver（不同主機）時

下一篇：多層次提升嵌套結構陣列以進行XML解碼