Question

我试图使用递归结构，当我有多个时，我可以将它们添加到一起，创建一个嵌入了这些结构的新结构。但是，我不确定采用这种方法的正确方法是什么。

我在下方附上了一段代码片段，以进一步说明我的意思。

package main

import "fmt"

type Container struct {
    F          int
    Collection []SubContainer
}

type SubContainer struct {
    Key    string
    Value  int
}

func main() {
    commits := map[string]int{
        "a": 1,
        "b": 2,
        "c": 3,
        "d": 4,
    }

    sc := []SubContainer{}
    c := []Container{}
    count := 0

    for k, v := range commits {
        sc = append(sc, SubContainer{Key: k, Value: v})
        count++

        if len(sc) == 2 {
            c = append(c, Container{Collection: sc, F: count})
            sc = nil
        }
    }

    for _, r := range c {
        fmt.Println(r)
    }
}

结果：

{2 [{a 1} {b 2}]}
{4 [{c 3} {d 4}]}

期望的结果：

{6 {2 [{a 1} {b 2}]} {4 [{c 3} {d 4}]}}

游乐场链接：https://play.golang.org/p/j6rbhgcOoT

有一点需要注意，我无法绕过头，commits长度可能会发生变化（我最初认为我可以创建一个不同的父结构）。任何建议将不胜感激......以某种方式使用递归结构以正确的方法完成此操作？谢谢！

Answer 1

我试图接近所需的输出而不确定确切的目标，您将在下面找到您提供的代码段的修改版本。

您可以对集合使用String() string方法来自定义格式。

package main

import "fmt"

type ContainerCollection struct {
    Count int
    List  []Container
}

func (cc ContainerCollection) String() string {
    total := 0
    for _, c := range cc.List {
        total += c.F
    }
    return fmt.Sprintf("{%d %v}", total, cc.List)
}

type Container struct {
    F          int
    Collection []SubContainer
}

type SubContainer struct {
    Key   string
    Value int
}

func main() {
    commits := map[string]int{
        "a": 1,
        "b": 2,
        "c": 3,
        "d": 4,
    }

    c := ContainerCollection{Count: 0}
    sc := []SubContainer{}

    for k, v := range commits {
        sc = append(sc, SubContainer{Key: k, Value: v})
        c.Count++
        if len(sc) == 2 {
            c.List = append(c.List, Container{Collection: sc, F: c.Count})
            sc = []SubContainer{}
        }
    }
    // Should also cover odd number of commits
    if len(sc) != 0 {
        c.Count++
        c.List = append(c.List, Container{Collection: sc, F: c.Count})
    }

    // for _, r := range c.List { fmt.Println(r) }

    fmt.Println(c)
}

结果：

{6 [{2 [{a 1} {b 2}]} {4 [{c 3} {d 4}]}]}

Playground

Answer 2

这是对代码进行最小修改的东西（只是添加了一个'超级'容器，它基本上是一个摘要结构）。只有当这个被传递到另一个库/包/通过网络等时，才可能需要这个，否则只需维护totalCount就足够了。

package main

import "fmt"

type SuperContainer struct {
    TotalCount int
    Containers []Container
}

type Container struct {
    F          int
    Collection []SubContainer
}

type SubContainer struct {
    Key   string
    Value int
}

func main() {
    var totalCount int
    commits := map[string]int{
        "a": 1,
        "b": 2,
        "c": 3,
        "d": 4,
    }

    sc := []SubContainer{}
    c := []Container{}
    count := 0

    for k, v := range commits {
        sc = append(sc, SubContainer{Key: k, Value: v})
        count++

        if len(sc) == 2 {
            totalCount += count
            c = append(c, Container{Collection: sc, F: count})
            sc = nil
        }
    }

    for _, r := range c {
        fmt.Println(r)
    }
    supC := SuperContainer{TotalCount: totalCount, Containers: c}
    fmt.Println(supC)
}

游乐场：https://play.golang.org/p/yN3N3gHaCX

如何使用将多个结构连接到同一个结构

2 个答案: