当前位置：首页 > 文章列表 > Golang > Go问答 > 将大括号{}转换为键值对{}

将大括号{}转换为键值对{}

来源：stackoverflow 2024-02-12 21:00:28 0浏览收藏

怎么入门Golang编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《将大括号{}转换为键值对{}》，涉及到，有需要的可以收藏一下

问题内容

我的目标是从 json 生成 map[string]interface 结构，其中所有嵌套的 []interface{} 都被转换为 []map[string]interface{} 。这是因为我们使用模块 https://github.com/ivahaev/go-xlsx-templater 从 json 填充 xlsx 。所有数据预计都会进入 map[string]interface{} 结构体，其中所有嵌套的 []interface{} 都是 []map[string]interface。

将 json 作为输入，如下所示：

{
    "totalamount": 4,
    "subtotal": 4,
    "vendors": [{
            "methodoftenders": [{
                "order": 1,
                "fees": 2
            }, {
                "order": 1,
                "fees": 2
            }],
            "subtotalfees": 4
        },
        {
            "methodoftenders": [{
                "order": 1,
                "fees": 2
            }, {
                "order": 1,
                "fees": 1
            }],
            "subtotalfees": 3
        }
    ]
}

当解组到 map[string]interface{} 时。我得到以下结构：

map[string]interface{}:
  "totalamount" : 4 interface{}(float64)
  "subtotal" : 4 interface{}(float64)
  "vendors" : interface{}([]interface{})
       [0]: interface(map[string]interface{})
           "methodoftenders" : interface{}([]interface{})
                 [0] : interface(map[string]interface{})
                    "order" : 1 interface{}(float64)
                    "fees"  : 2 interface{}(float64)
                 [1] : interface(map[string]interface{})
                    "order" : 1 interface{}(float64),
                    "fees"  : 2 interface{}(float64)
           "subtotalfees" : 4 interface{}(float64)
       [1]: interface(map[string]interface{}) 
            "methodoftenders" : interface{}([]interface{})
                  [0] : interface(map[string]interface{})
                    "order" : 1 interface{}(float64)
                    "fees"  : 2 interface{}(float64)
                 [1] : interface(map[string]interface{})
                    "order" : 1 interface{}(float64),
                    "fees"  : 2 interface{}(float64)
           "subtotalfees" : 3 interface{}(float64)

进行一些解析后，对每个 []interface{} 进行范围分析并创建一个 []map[string]interface{} 来存储每个嵌套的 map[string]interface 。

我得到了所需的结果，其中所有 []interfaces{} 都是 []map[string]interface{}

map[string]interface{}:
  "totalAmount" : 4 interface{}(float64)
  "subtotal" : 4 interface{}(float64)
  "Vendors" : interface{}([]map[string]interface{})
       [0]: interface(map[string]interface{})
           "MethodOfTenders" : interface{}([]map[string]interface{})
                 [0] : interface(map[string]interface{})
                    "order" : 1 interface{}(float64)
                    "fees"  : 2 interface{}(float64)
                 [1] : interface(map[string]interface{})
                    "order" : 1 interface{}(float64),
                    "fees"  : 2 interface{}(float64)
           "subtotalFees" : 4 interface{}(float64)
       [1]: interface(map[string]interface{}) 
            "MethodOfTenders" : interface{}([]map[string]interface{})
                  [0] : interface(map[string]interface{})
                    "order" : 1 interface{}(float64)
                    "fees"  : 2 interface{}(float64)
                 [1] : interface(map[string]interface{})
                    "order" : 1 interface{}(float64),
                    "fees"  : 2 interface{}(float64)
           "subtotalFees" : 3 interface{}(float64)

有没有办法递归遍历所有map[string]接口并更改[]map[string]接口的[]interfaces{}？

编辑：这里是包含完整模板和 json 的存储库，当前使用反射方法。

模板和 json 存储库

正确答案

这个技巧是使用反射来执行的。递归地向下检查值的类型：

// "casts" map values to the desired type recursively
func castmap(m map[string]any) map[string]any {
    for k := range m {
        switch reflect.valueof(m[k]).kind() {
        case reflect.map:
            mm, ok := m[k].(map[string]any)
            if !ok {
                panic(fmt.errorf("expected map[string]any, got %t", m[k]))
            }
            m[k] = castmap(mm)
        case reflect.slice, reflect.array:
            ma, ok := m[k].([]any)
            if !ok {
                panic(fmt.errorf("expected []any, got %t", m[k]))
            }
            m[k] = castarray(ma)
        default:
            // fmt.printf("%s: %t, kind %v\n", k, m[k], reflect.valueof(m[k]).kind())
            continue
        }
    }
    return m
}

// "casts" slice elements to the desired types recursively
func castarray(a []any) []map[string]any {
    res := []map[string]any{}
    for i := range a {
        switch reflect.valueof(a[i]).kind() {
        case reflect.map:
            am, ok := a[i].(map[string]any)
            if !ok {
                panic(fmt.errorf("expected map[string]any, got %t", a[i]))
            }
            am = castmap(am)
            res = append(res, am)
        default:
            panic(fmt.errorf("expected map[string]any, got %t", a[i]))
        }
    }
    return res
}

main 的完整示例位于此处：https://go.dev/play/p/MEQRe-f3dY1

输出：

before: map[string]interface {}{"vendors":[]interface {}{map[string]interface {}{"methodoftenders":[]interface {}{map[string]interface {}{"fees":2, "order":1}, map[string]interface {}{"fees":2, "order":1}}, "subtotalfees":4}, map[string]interface {}{"methodoftenders":[]interface {}{map[string]interface {}{"fees":2, "order":1}, map[string]interface {}{"fees":1, "order":1}}, "subtotalfees":3}}, "subtotal":4, "totalamount":4}
after: map[string]interface {}{"vendors":[]map[string]interface {}{map[string]interface {}{"methodoftenders":[]map[string]interface {}{map[string]interface {}{"fees":2, "order":1}, map[string]interface {}{"fees":2, "order":1}}, "subtotalfees":4}, map[string]interface {}{"methodoftenders":[]map[string]interface {}{map[string]interface {}{"fees":2, "order":1}, map[string]interface {}{"fees":1, "order":1}}, "subtotalfees":3}}, "subtotal":4, "totalamount":4}

看到了吗？ "vendors" 是 []interface {}，变成了 []map[string]interface {} "vendors[].methodoftenders" 是 []interface {}，变成了 []map[string]interface {}

如果函数发现意外情况，就会出现恐慌。如果需要，请随意修改它们以返回 error。

更新

这是使用类型断言的相同递归算法。

// "casts" map values to the desired type recursively
func castmap(m map[string]any) map[string]any {
    for k := range m {
        mm, ok := m[k].(map[string]any)
        if ok {
            m[k] = castmap(mm)
            continue
        }
        ma, ok := m[k].([]any)
        if ok {
            m[k] = castarray(ma)
            continue
        }
    }
    return m
}

// "casts" slice elements to the desired types recursively
func castarray(a []any) []map[string]any {
    res := []map[string]any{}
    for i := range a {
        am, ok := a[i].(map[string]any)
        if ok {
            am = castmap(am)
            res = append(res, am)
        } else {
            panic(fmt.errorf("expected map[string]any, got %t", a[i]))
        }
    }
    return res
}

完整代码https://go.dev/play/p/IbOhQqpisie

基准

其中一位评论者声称 reflection 很昂贵 。这里的情况并非如此：

goos: windows
goarch: amd64
pkg: example.org/try/test
cpu: intel(r) core(tm) i7-8550u cpu @ 1.80ghz
benchmarkcastreflect-8        382574          2926 ns/op        2664 b/op         29 allocs/op
benchmarkcasttype-8           418257          2934 ns/op        2664 b/op         29 allocs/op

基准在这里：https://go.dev/play/p/Ro8PeVQy8kA

演示不执行基准测试。它应该在真实的cpu上运行

更新

所以我注意到您添加了一个指向包含您目前拥有的内容的存储库的链接。该模板很奇怪（其中的某些值不是示例数据的一部分）。我已经删除了除您拥有的示例数据 json 中实际存在的字段之外的所有字段。事实证明，您使用的包的边缘非常粗糙（它确实处理嵌套值中的类型断言，但不是在顶层）。我个人要么分叉该包并解决该问题，但与此同时，如果您知道要迭代哪些字段，我可以在大约 5 分钟内完成所有工作：

var jsonmap map[string]interface{}
data := sampledata()
err := json.unmarshal(data, &jsonmap)
if err != nil {
    panic("final log")
}
ctx := jsonmap
v := jsonmap["vendors"]
vs := v.([]interface{})
vendors := make([]map[string]interface{}, 0, len(vs))
for _, v := range vs {
    m := v.(map[string]interface{})
    vendors = append(vendors, m)
}
jsonmap["vendors"] = vendors

doc := xlst.new()
err = doc.readtemplate("export_support_template.xlsx")
if err != nil {
    fmt.println("error opening the template: ", err)
    panic("error opening template")
}
err = doc.render(ctx)
if err != nil {
    fmt.println("error rendering the template: ", err)
    panic("error rendering template")
}
err = doc.save("report.xlsx")

如您所见，我刚刚对数据进行了整理。然后，我专注于 vendors 键，将其转换为切片 (v.([]inteface{})，创建一个 []map[string]interface{} 类型的新变量，并复制数据转换在这个简单循环中映射切片的元素：

for _, v := range vs {
    m := v.(map[string]interface{})
    vendors = append(vendors, m)
}

然后，我只是在原始地图中重新分配了 vendors 键 (ctx["vendors"] = sellers)，并将其传递到模板中。只需要不到 10 行代码，一切都非常顺利。不需要反思，或任何其他魔法。只是简单的类型转换。如果没有这个，您使用的软件包确实会抱怨在 interface{} 类型上使用 range （而不是首先检查密钥是否可以成功转换为 []interface{}）。我从主文件中删除了所有其他函数（示例数据除外），运行 go build 并执行 ./json_marshaller。它毫无问题地生成了正确填充的 xlsx 文件。简单。

我仍然建议您实际为模板程序包创建一个 pr，这样您就不必自己处理这些东西。这应该是一个相当简单的改变，但就目前而言：这种方法效果非常好。

包含您的模板

查看 go-xlsx-templater 的存储库，我真的不明白为什么您需要除此之外的任何内容：

data := map[string]interface{}
_ = json.unmarshal(input, &data)

之所以完全没问题，是因为 go-xlsx-templater 已经执行了该映射中所有 interface{} 值的类型转换。它将遍历地图，并检查是否有任何值属于 []interface{} 类型，然后迭代此切片并检查切片内的 map[string]interface{} 值。它是 all in the source code。根据他们自己的文档，如果您的模板看起来有点像这样，它应该可以正常工作：

| total:              | {{ totalamount }}  |
| subtotal:           | {{ subtotal }}     |
|                     | vendor subtotal    | fees                       | order                       |
| {{ range vendors }} |
|                     |                    | {{ methodsoftender.fees }} | {{ methodsoftender.order }} |
|                     | {{ subtotalfees }} |
| {{ end }}           |

您最终应该正确填充电子表格：

| total:    | 4               |      |       |
| subtotal: | 4               |      |       |
|           | vendor subtotal | fees | order |
|           |                 | 2    | 1     |
|           |                 | 2    | 1     |
|           | 4               |      |       |
|           |                 | 2    | 1     |
|           |                 | 1    | 1     |
|           | 3               |      |       |

本质上，您显示的数据集与存储库在其自己的 main README file 中提供的示例没有什么不同。上下文数据本身包含嵌套地图以及显示如何使用它的电子表格模板的屏幕截图。说白了，我觉得你的问题几乎就是rtfm的一个例子......

但是，如果没有您的模板，就无法确定，所以我将在下面完整地留下我最初的答案...

如果我正确理解您的要求，您正在寻找一种使用类型断言/强制转换从 map[string]interface{} 类型的映射中提取键并使用 [ 类型的值]接口{} 为 []map[字符串]接口{}。在此特定示例中，您需要可以通过 []map[string]interface{}（而不是 interface{} 或 []interface{}）访问顶级密钥 vendors。如果这就是您正在寻找的，您可以很容易地做到这一点：

data := map[string]interface{}{}
if err := json.unmarshal(jsonbytes, &data); err != nil {
    // handle error
}
nested := map[string][]map[string]interface{}{} // subset of data that needs to be accessible as slices of maps
for k, v := range data {
    if s, ok := v.([]interface); ok {
        // this key is of type []interface, see if we can use it as slice of maps
        if maps, err := sliceanytomap(s); err == nil {
            nested[k] = maps
        } // handle error if needed
    }
}

func sliceanytomap(s []any) ([]map[string]interface{}, error) {
    ret := make([]map[string]interface{}, 0, len(s))
    for _, v := range s {
        if m, ok := v.(map[string]interface{}); ok {
            ret = append(ret, m)
        } else {
            return nil, errors.new("slice contains non-map data")
        }
    }
    return ret, nil
}

这样，您最终会得到一个名为 nested 的变量，其中包含 vendors 之类的键，并且可以通过 []map[string]interface{} 访问数据。这可以传递到您的模板程序，以使用供应商数据填充电子表格。

Demo here

现在，在 vendors 的一些键中，有一些数据又是一个地图，但仍然无法直接访问。将这个 sliceanytomap 内容分解为一个函数将使您更轻松地转换您需要的所有数据。

说了这么多，我个人确实认为这是一个 x-y 问题。您在此处显示的数据看起来具有非常明确的结构。如果您使用实际类型，那么与其胡乱使用 map[string]interface{} 之类的东西，那么阅读、编写和维护会容易得多。根据您在问题中包含的内容，只需使用以下几种类型即可：

type data struct {
    total    float64  `json:"totalamount"`
    subtotal float64  `json:"subtotal"`
    vendors  []vendor `json:"vendors"`
}

type vendor struct {
    methodoftenders []mot   `json:"methodoftenders"`
    subtotalfees    float64 `json:"subtotalfees"`
}

type mot struct {
    fees  float64 `json:"fees"`
    order float64 `json:"order"`
}

使用这些类型，您可以快速、轻松地将给定的输入解析为更易于后续使用的格式：

data := data{}
if err := json.unmarshal(input, &data); err != nil {
    // handle error
}
for _, vendor := range data.vendors {
    fmt.printf("vendor subtotal fees: %f\n", vendor.subtotalfees)
    for i, mot := range vendor.methodoftenders {
        fmt.printf("mot %d:\norder: %f\nfees: %f\n\n", i+1, mot.order, mot.fees)
    }
    fmt.println("-----")
}

Demo here

最后几件事我想知道是否所有数值都应该是float64。当然，这对于金额和/或费用来说是有意义的（假设它们是货币值），但是 order 字段可能包含一个订单号，我不希望它是像 0.123 这样的值。

最后，如果您需要将此数据传递给需要映射的模板器，那么使用上述类型仍然是一件相当简单的事情。有几种方法可以做到这一点。最简单的方法是：

func (d data) tomap() (map[string]interface{}, error) {
    raw, err := json.marshal(d)
    if err != nil {
        return nil, err
    }
    asmap := map[string]interface{}{}
    if err := json.unmarshal(raw, &asmap); err != nil {
        return nil, err
    }
    return asmap, nil
}

json 编组实现起来很快，但效率有点低，所以如果性能很重要，那么您可以花几分钟编写一些方法，例如：

func (d data) tomap() map[string]interface{} {
    vendors := make([]map[string]interface{}, 0, len(d.vendors))
    for _, v := range d.vendors {
        vendors = append(vendors, v.tomap())
    }
    return map[string]interface{}{
        "totalamount": d.total,
        "subtotal":    d.subtotal,
        "vendors":     vendors,
    }
}

func (v vendor) tomap() map[string]interface{} {
    mot := make([]map[string]interface{}, 0, len(v.methodsoftender))
    for _, m := range v.methodsoftender {
        mot = append(mot, m.tomap())
    }
    return map[string]interface{
        "methodsoftender": mot,
        "subtotalfees":    v.subtotalfees,
    }
}

func (m mot) tomap() map[string]interface{} {
    return map[string]interface{}{
        "fees":  m.fees,
        "order": m.order,
    }
}

然后，将 data 对象转换为地图非常简单：