在 Go 中理解耦的最佳方法是在兩個不同的套件中使用類似的結構，但結構中的子項使其變得困難？

在 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 套件來利用它們的功能。

我想再次澄清，這是一個主觀主題，因此沒有靈丹妙藥的解決方案。對我來說，看起來整潔、清晰。我一定會選擇這種方式。請告訴我並謝謝！

以上是在 Go 中理解耦的最佳方法是在兩個不同的套件中使用類似的結構，但結構中的子項使其變得困難？的詳細內容。更多資訊請關注PHP中文網其他相關文章！