在 Go 中处理解耦的最佳方法是使用类似结构但具有不同子项的两个不同包。这种方法可以有效地将代码分离，提高可维护性和模块化程度。然而，当结构中的子项变得复杂时，这种解耦方法可能会变得困难。在这种情况下，可以考虑使用接口和多态的概念来解决问题。通过定义通用的接口类型，可以将不同的结构类型进行统一处理，从而实现更灵活的解耦方式。这种方法在 Go 中被广泛使用，可以让代码更加可扩展和可重用。

问题内容

我相对较新，并且一直在进行大规模重写，试图尽可能减少我的依赖关系图。我对我得到它的地方感到非常满意，但是有一个部分我不知道如何最好地处理。如果答案是“两者之间会有这种依赖性”，那也很好，我只是在寻找一个好的方法，而不是期待奇迹。

所以下面我有两个包，a 和 b，它们都有相同的结构。通常你可以在 main 中将一个转换为另一个，但每个都有一个子项，它也是一个结构体，这会阻止 go 允许它，即使子项具有相同的签名。

一种方法是在 b 的结构中引用 a.tzconfig 并让其存在依赖关系，但这就是我想要摆脱的。

我想另一种方法是创建一个接口，然后通过方法获取 loc 的值，我认为这可行，但我还没有尝试过，因为这意味着为只是数据结构的东西创建方法（实际结构有很多项目，为了简单起见，我在这里将其简化为必需品），这似乎有点矫枉过正。

我可以将 tzconfig 移至第三个模块，这样它们都会引用该模块，而不是一个引用另一个模块，这就是我所想到的。

所以我的问题是，从有真实经验的人那里，在 go 中处理这种情况的最佳方法是什么？

我应该提到，它们重复结构的原因只是因为我试图打破它们之间的依赖关系，原始代码只是在一个包中包含该结构，而另一个包引用它。

package a

type cfg struct {
    addr                 string
    loc                  tzconfig
}

type tzconfig struct {
    string string
    tz     *time.location `validate:"nodescent"`
}

func getcfg() cfg {
    t, _ := time.loadlocation(`mst`)
    return cfg{
        addr: "abc",
        host: "a.bc.d",
        loc:  config.tzconfig{
            string: "mst",
            tz:     t,
        },
    }
}

package b

type cfg struct {
    addr                 string
    loc                  tzconfig
}

type tzconfig struct {
    string string
    tz     *time.location `validate:"nodescent"`
}

func dosomethingwithconfig(c cfg) {
    fmt.println(c)
}

package main

main() {
     c := a.GetCfg()
     d := b.DoSomethingWithConfig(b.Cg(c))
     fmt.Println(d)
}

解决方法

恕我直言，@burakserdar 提供的建议非常好，非常适合您的场景。我用这种方式重写了代码。

package common

package common

import "time"

type cfg struct {
    addr string
    loc  tzconfig
}

type tzconfig struct {
    string string
    tz     *time.location `validate:"nodescent"`
}

这里应该放置常用的结构体、函数、方法等。

package a

package a

import (
    "dependencies/common"
    "time"
)

type cfg struct {
    common.cfg
    host string
}

func getcfg() cfg {
    t, _ := time.loadlocation(`mst`)
    return cfg{
        cfg: common.cfg{
            addr: "abc",
            loc: common.tzconfig{
                string: "mst",
                tz:     t,
            },
        },
        host: "a.bc.d",
    }
}

这里有与 a 包相关的特定代码，它继承了 common 包的共享代码，如 import 部分所示。

请注意，我使用结构嵌入功能来获取 common 包中定义的共享字段。

package b

package b

import (
    "dependencies/common"
    "fmt"
)

func dosomethingwithconfig(c common.cfg) string {
    return fmt.sprint(c)
}

这里，没有什么特别值得一提的。

package main

package main

import (
    "dependencies/a"
    "dependencies/b"
    "fmt"
)

func main() {
    c := a.GetCfg()
    d := b.DoSomethingWithConfig(c.Cfg)
    fmt.Println(d)
}

这里，代码应该非常简单。我导入了 a 和 b 包来利用它们的功能。

我想再次澄清，这是一个主观主题，因此没有灵丹妙药的解决方案。对我来说，看起来整洁、清晰。我肯定会选择这种方式。请告诉我并谢谢！