Question

我有一个嵌套JSON的深层嵌套结构，如下所示。

{"object": 
    {
       "buffer_size": 10,
       "Databases":
       [
               {
                       "host": "localhost",
                       "user": "root",
                       "pass": "",
                       "type": "mysql",
                       "name": "go",
                       "Tables":
                       [
                               {
                                       "name": "testing",
                                       "statment": "teststring",
                                       "regex": "teststring ([0-9]+) ([A-z]+)",
                                       "Types": 
                                        [
                                           {
                                               "id": "1",
                                               "value": "string"
                                           },
                                           {
                                               "id": "2",
                                               "value": "string"
                                           },
                                           {
                                               "id": "3",
                                               "value": "string"
                                           }
                                        ]
                               }
                       ]
               }
       ]
    }
}

有没有办法可以使用常量时间查找来搜索id的{{1}}，并获得具有展平JSON的筛选结果，以便输出：

Types

我知道我可以通过使用for循环来实现，但这需要很长时间。

Answer 1

以下是我的表现：

type Id int

func (i *Id) UnmarshalJSON(b []byte) error {
    s := strings.Trim(string(b), `"`)
    id, err := strconv.Atoi(s)
    *i = Id(id)
    return err
}

type Type struct {
    Id    Id     `json:"id"`
    Value string `json:"value"`
}

func getTypes(b []byte) ([]Type, error) {
    var types = []Type{}
    var obj struct {
        Object struct {
            Databases []struct {
                Tables []struct {
                    Types []Type `json:"Types"`
                } `json:"Tables"`
            } `json:"Databases"`
        } `json:"object"`
    }
    if err := json.Unmarshal(b, &obj); err != nil {
        return nil, err
    }
    for _, d := range obj.Object.Databases {
        for _, t := range d.Tables {
            types = append(types, t.Types...)
        }
    }
    return types, nil
}

func showTypes(types []Type) error {
    return json.NewEncoder(os.Stdout).Encode(struct {
        Types []Type `json:"Types"`
    }{types})
}

func main() {
    types, err := getTypes([]byte(data))
    if err != nil {
        log.Fatal(err)
    }
    if err := showTypes(types); err != nil {
        log.Fatal(err)
    }
}

就时间而言，这根本不可能。

恒定时间搜索深层嵌套的JSON数据

1 个答案: