Рекурсивное изменение массивов в не-массивы в JSON с помощью sjson в Golang - PullRequest
Новая
       20

Рекурсивное изменение массивов в не-массивы в JSON с помощью sjson в Golang

1 голос
/ 19 марта 2019

Что я пытаюсь сделать:

Преобразовать все массивы длины 1 в файле JSON в не массивы.

Например,

Входные данные: {"path": [{"secret/foo": [{"capabilities": ["read"]}]}]}

Выходные данные: {"path": {"secret/foo": {"capabilities": "read"}}}

Я не могу использовать Structs, поскольку формат JSON будет различаться ...

Прямо сейчас мне удалосьпо крайней мере, определите срезы 1 длины: 

package main

import (
    "encoding/json"
    "fmt"
)

func findSingletons(value interface{}) {
    switch value.(type) {
    case []interface{}:
        if len(value.([]interface{})) == 1 {
            fmt.Println("1 length array found!", value)
        }
        for _, v := range value.([]interface{}) {
            findSingletons(v)
        }
    case map[string]interface{}:
        for _, v := range value.(map[string]interface{}) {
            findSingletons(v)
        }
    }
}

func removeSingletonsFromJSON(input string) {
    jsonFromInput := json.RawMessage(input)
    jsonMap := make(map[string]interface{})
    err := json.Unmarshal([]byte(jsonFromInput), &jsonMap)

    if err != nil {
        panic(err)
    }

    findSingletons(jsonMap)

    fmt.Printf("JSON value of without singletons:%s\n", jsonMap)
}

func main() {
    jsonParsed := []byte(`{"path": [{"secret/foo": [{"capabilities": ["read"]}]}]}`)
    removeSingletonsFromJSON(string(jsonParsed))
    fmt.Println(`Should have output {"path": {"secret/foo": {"capabilities": "read"}}}`)
}

Какие выходы 

1 length array found! [map[secret/foo:[map[capabilities:[read]]]]]
1 length array found! [map[capabilities:[read]]]
1 length array found! [read]
JSON value of without singletons:map[path:[map[secret/foo:[map[capabilities:[read]]]]]]
Should have output {"path": {"secret/foo": {"capabilities": "read"}}}

Но я не уверен, как я могу преобразовать их в не-массивы ...

1 Ответ

2 голосов
/ 19 марта 2019

Переключатель типа - ваш друг: 


        switch t := v.(type) {
        case []interface{}:
            if len(t) == 1 {
                data[k] = t[0]

И вы можете использовать рекурсию для удаления внутренних элементов, например: 

func removeOneElementSlice(data map[string]interface{}) {
    for k, v := range data {
        switch t := v.(type) {
        case []interface{}:
            if len(t) == 1 {
                data[k] = t[0]
                if v, ok := data[k].(map[string]interface{}); ok {
                    removeOneElementSlice(v)
                }
            }
        }
    }
}

Я бы сделал это , чтобы преобразовать
{"path":[{"secret/foo":[{"capabilities":["read"]}]}]}
до
{"path":{"secret/foo":{"capabilities":"read"}}} 

package main

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

func main() {
    s := `{"path":[{"secret/foo":[{"capabilities":["read"]}]}]}`
    fmt.Println(s)
    var data map[string]interface{}
    if err := json.Unmarshal([]byte(s), &data); err != nil {
        panic(err)
    }

    removeOneElementSlice(data)

    buf, err := json.Marshal(data)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(buf)) //{"a":"a","n":7}
}
func removeOneElementSlice(data map[string]interface{}) {
    for k, v := range data {
        switch t := v.(type) {
        case []interface{}:
            if len(t) == 1 {
                data[k] = t[0]
                if v, ok := data[k].(map[string]interface{}); ok {
                    removeOneElementSlice(v)
                }
            }
        }
    }
}
...