在Go Lang中使用深度嵌套的JSON 我有一个我认为是非常混乱的JSON块，我想读 使用Go修改两个深度嵌套的值（表示为：我想要这个！）。 由于我要将其发送到的服务器， 我无法更改标签名称。什么使它特别困难 对我来说，父母有多个嵌套的孩子，因为有太多的“值”标签，我不知道如何指定要输入的“值”孩子

我用这个很快就得到了Bash中的值

jq ' .value[0].value[1].value[0].value[1].value[0].value="'"$one"'" | '\ '
.value[0].value[1].value[0].value[1].value[1].value="'"$two"'"'

我最初在Go中尝试过这样的格式，但由于孩子们都被命名为“值”的问题，我无法让它工作，我想进入一个不同于第一个的格式。不幸的是，这些神奇的JSON to Go结构中也没有一个能够处理所有嵌套

type Bar struct {
    Value struct { // Value[0]
        Value struct {  // Value[1]
            Value struct { // Value[0]
                Value struct { // Value[1]
                    Value struct { // Value[1] or Value[2]
                    }}}}}}

这段代码将JSON转换成一种更为结构/映射友好的形式，并打印整个内容

var foo interface{}
err := json.Unmarshal(blob, &foo)
if err != nil {
    fmt.Println("error:", err)
}

m := foo.(map[string]interface{})

// print all
fmt.Println("Loop: ", m)
for k, v := range m {
    fmt.Printf("%v : %v", k, v)
}

下面是我作为变量存储的JSON

var blob = []byte(`{
"tag": "1",
"value": [{
        "tag": "2",
        "value": [{
                "tag": "3",
                "value": [{
                        "tag": "4",
                        "type": "x",
                        "value": "x"
                    }, {
                        "tag": "5",
                        "type": "x",
                        "value": "x"
                    }
                ]
            }, {
                "tag": "6",
                "value": [{
                        "tag": "7",
                        "value": [{
                                "tag": "8",
                                "type": "x",
                                "value": "x"
                            }, {
                                "tag": "9",
                                "value": [{
                                        "tag": "10",
                                        "type": "x",
                                        "value": "I want this!"
                                    }, {
                                        "tag": "11",
                                        "type": "Thanks for the help mate!",
                                        "value": "I want this!"
                                    }
                                ]
                            }
                        ]
                    }
                ]
            }, {
                "tag": "12",
                "type": "x",
                "value": "x"
            }
        ]
    }, {
        "tag": "13",
        "value": [{
                "tag": "14",
                "type": "x",
                "value": "x"
            }, {
                "tag": "15",
                "value": [{
                        "tag": "16",
                        "value": [{
                                "tag": "17",
                                "type": "x",
                                "value": "x"
                            }
                        ]
                    }
                ]
            }
        ]
    }
]
}`)

---

如果您能给我任何帮助或建议，我将不胜感激

您最初的尝试没有成功，因为您使用了需要结构片的结构（

Value[]struct{…}

）。但这也行不通，因为在某些情况下，值是片，而在某些情况下，它们是字符串，这是

encoding/json

不喜欢的。您的最佳选择是两个选项之一：原始文本操作，这可能会更快但更脆弱且更容易出错，或者像第二个示例中那样解码到

map[string]接口{}

，并执行一些粗糙的类型断言：

var foo map[string]interface{}
err := json.Unmarshal(blob, &foo)
if err != nil {
    fmt.Println("error:", err)
}

foo["value"].([]interface{})[0].(map[string]interface{})["value"].([]interface{})[1].(map[string]interface{})["value"].([]interface{})[0].(map[string]interface{})["value"].([]interface{})[1].(map[string]interface{})["value"].([]interface{})[0].(map[string]interface{})["value"]

---

非常感谢。这是非常有洞察力和帮助的。出于好奇，您是否有一些确定路径的技巧，或者只是一个冗长的过程，为我想要到达的每个属性找到路径？另外，我如何在foo中向该位置写信？当我尝试将：=blah放在那条长线的右侧时，它会在：=EDIT:ignore的左侧生成错误：expected identifier，忽略最后一个设置，它等于think。当我输入时，我意识到它只是=而不是：=完全取决于数据本身。你可能需要做一些实验来找到一些有效的方法。老实说，这听起来像是一个结构非常糟糕的JSON，因此乏味可能是唯一的选择。