Go 无法将结构类型参数传递给另一个包中的函数

我有两个包：offer.go和parser.go。我有一个struct

Data

类型的变量

cart

。我想把它作为一个参数传递给另一个包

解析器

中的函数。然而，我无法做到这一点。请调查以下情况：

开价

package offer

import "go_tests/Parser"

type Data struct {
    Id       int
    Quantity int
    Mrp      float64
    Discount float64
}
cart := make(map[int]Data)
//cart has some data in it
//passing it to parser
Parser.BXATP(offer_id, rule.Description, cart, warehouseId)

语法分析器

package Parser

type Data struct {
    Id       int
    Quantity int
    Mrp      float64
    Discount float64
}

func BXATP(offer_id int, rule string, cart map[int]Data, warehouseId int){
 //my code is here
}

但是，运行此命令时，会出现以下错误：

 cannot use cart (type map[int]Data) as type map[int]Parser.Data in argument to Parser.BXATP

我找到了此链接，但解决方案在我的案例中似乎不起作用：

我将解析器更改为：

func BXATP(offer_id int, rule string, cart map[int]struct {
    Id       int
    Quantity int
    Mrp      float64
    Discount float64
}, warehouseId int)

但现在的错误是：

 cannot use cart (type map[int]Data) as type map[int]struct { Id int; Quantity int; Mrp float64; Discount float64 } in argument to Parser.BXATP

---

我不明白如何做到这一点。任何帮助都将不胜感激。

为什么在两个包中定义了

数据？如果您需要完全相同的结构，只需将其放在一个包中即可。如果将其保留在
解析器中
，则可以执行以下操作：

package offer

import "go_tests/Parser"

cart := make(map[int]Parser.Data)
//cart has some data in it
//passing it to parser
Parser.BXATP(offer_id, rule.Description, cart, warehouseId)

在不同的包中定义的类型是不同的，即使它们共享名称和底层结构。所以
Parser.Data
与
offer.Data
不兼容，为什么在两个包中定义了
Data
？如果您需要完全相同的结构，只需将其放在一个包中即可。如果将其保留在
解析器中
，则可以执行以下操作：

package offer

import "go_tests/Parser"

cart := make(map[int]Parser.Data)
//cart has some data in it
//passing it to parser
Parser.BXATP(offer_id, rule.Description, cart, warehouseId)

在不同的包中定义的类型是不同的，即使它们共享名称和底层结构。因此，
Parser.Data
与
offer.Data
不兼容。您需要将每个结构字段分配给另一个结构字段，请参见示例：

package parser

import "./offer"

type Data struct {
    Id       int
    Quantity int
    Mrp      float64
    Discount float64
}
 func main(){

     offer_data := &offer.Data{} 

     parser_data :=  &Data{
         Id: offer_data.Id,
         Quantity: offer_data.Quantity,
         Mrp: offer_data.Mrp,
         Discount: offer_data.Discount,
     }
 }

您需要将每个结构字段分配给另一个结构字段，请参见示例：

package parser

import "./offer"

type Data struct {
    Id       int
    Quantity int
    Mrp      float64
    Discount float64
}
 func main(){

     offer_data := &offer.Data{} 

     parser_data :=  &Data{
         Id: offer_data.Id,
         Quantity: offer_data.Quantity,
         Mrp: offer_data.Mrp,
         Discount: offer_data.Discount,
     }
 }

我在包中使用type
Data
，在许多其他地方，代码也与解析器无关。是否有一种方法可以在解析器包中使用来自offer包的
数据
？这会导致循环导入错误。您无法将
offer
导入
Parser
，因为
offer
已经在导入
Parser
。一种解决方案是将类型移出到第三个包中，并将其导入
提供
和
解析器
。此外，您仍然可以在
提供
中使用
数据
。只需在
offer
中的所有位置使用
Parser.Data
，然后从
offer
中删除
Data
。它们仍然是相同的结构，所以除非在类型上定义了方法，否则这不重要。是的，我知道。实际上，我试着将要约导入解析器。我想是否还有其他解决办法。不管怎样，谢谢。我在许多其他地方使用包中的type
Data
，这些地方的代码与解析器无关。是否有一种方法可以在解析器包中使用来自offer包的
数据
？这会导致循环导入错误。您无法将
offer
导入
Parser
，因为
offer
已经在导入
Parser
。一种解决方案是将类型移出到第三个包中，并将其导入
提供
和
解析器
。此外，您仍然可以在
提供
中使用
数据
。只需在
offer
中的所有位置使用
Parser.Data
，然后从
offer
中删除
Data
。它们仍然是相同的结构，所以除非在类型上定义了方法，否则这不重要。是的，我知道。实际上，我试着将要约导入解析器。我想是否还有其他解决办法。无论如何，谢谢。