【问题标题】:nested struct in mongodbMongoDB中的嵌套结构
【发布时间】:2019-08-20 15:38:02
【问题描述】:

我使用以下软件包:

“gopkg.in/mgo.v2”

“gopkg.in/mgo.v2/bson”

我尝试处理嵌套结构并将其放入 mongodb。 下面的代码正确地完成了这项工作,但我不知道这是否是正确的方法。

// init
type DummyStruct struct {
    User     string  `bson:"user"`
    Foo      FooType `bson:"foo"`
}

type FooType struct {
    BarA int `bson:"bar_a"`
    BarB int `bson:"bar_b"`
}


//  main
foobar := DummyStruct{
    User: "Foobar",
    Foo: FooType{
        BarA: 123,
        BarB: 456,
    },
}

// Insert
if err := c.Insert(foobar); err != nil {
    panic(err)
}

嵌套结构是否需要分两部分构建?

如果我使用 json->golang 结构转换器 (https://mholt.github.io/json-to-go/)

我会得到以下结构

type DummyStructA struct {
    User string `bson:"user"`
    Foo  struct {
        BarA int `bson:"bar_a"`
        BarB int `bson:"bar_b"`
    } `bson:"foo"`
}

现在我不知道如何填充这个结构。

我试过了:

foobar := DummyStructA{
    User: "Foobar",
    Foo: {
        BarA: 123,
        BarB: 456,
    },
}

但出现此错误:复合文字中缺少类型

我也试过了

foobar := DummyStructA{
    User: "Foobar",
    Foo{
        BarA: 123,
        BarB: 456,
    },
}

并得到这 2 个错误:

  • field:value 和 value 初始化器的混合

  • 未定义:Foo

还是需要用bson.M来处理结构体(DummyStructA)?

【问题讨论】:

    标签: mongodb go bson mgo


    【解决方案1】:

    你可以这样做

    package main
    
    import (
        "fmt"
        "encoding/json"
    )
    
    type DummyStruct struct {
        User     string  `bson:"user" json:"user"`
        Foo      FooType `bson:"foo" json:"foo"`
    }
    
    type FooType struct {
        BarA int `bson:"barA" json:"barA"`
        BarB int `bson:"bar_b" json:"bar_b"`
    }
    
    func main() {
        test:=DummyStruct{}
        test.User="test"
        test.Foo.BarA=123
        test.Foo.BarB=321
        b,err:=json.Marshal(test)
        if err!=nil{
            fmt.Println("error marshaling test struct",err)
            return
        }
        fmt.Println("test data\n",string(b))
    }
    

    输出是这样的

    test data
    {"user":"test","foo":{"barA":123,"bar_b":321}}
    

    去游乐场试试看:https://play.golang.org/p/s32pMvqP6Y8

    【讨论】:

    • thx,这真的很好,也适用于“大”结构:)
    • 是的,保持不同的结构很简单,如果来自 api 的数据也很容易解码。
    【解决方案2】:

    如果您在问题中定义了 2 个不同的结构。你需要声明foobar 喜欢:

    foobar := DummyStructA{
    User: "Foobar",
    Foo: FooType{
        BarA: 123,
        BarB: 456,
    },
    

    }

    但没有必要定义第二种类型来处理这种情况。您可以使用匿名的struct,例如:

    type DummyStructA {
        User string `bson:"user"`
        Foo struct{
           Name string `bson:"name"`
           Age int `bson:"age"`
        } `bson: "foo"`
    }
    

    但是在尝试填充数据时变得很麻烦。

    foobar := DummyStructA{
         User: "hello",
         Foo : struct{
               Name string
               Age int
             }{
             Name: "John",
             Age: 50,
         }
    }
    

    【讨论】:

    • 感谢您的回复。这意味着它必须有两个像我的第一个示例那样在单独的结构中处理这个,以便在填充这个时有一个很好的句柄?这对我来说感觉不太顺利:D
    • 是的,您需要像以前那样拥有不同的结构,以使事情变得简单。
    猜你喜欢
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 2020-09-28
    • 2020-11-08
    • 1970-01-01
    • 1970-01-01
    • 2016-02-22
    相关资源
    最近更新 更多