在Golang中，封装模型的常用函数可以通过使用结构体和方法来实现。结构体是一种自定义的数据类型，可以用来封装相关的数据和方法。方法是与结构体关联的函数，可以在方法内部访问和操作结构体的成员。通过将函数定义为结构体的方法，我们可以将函数与特定的结构体关联起来，实现封装模型中的常用操作。在Golang中，我们可以使用接收者来指定方法所属的结构体。接收者可以是值类型或指针类型，根据需要选择合适的接收者类型。通过定义结构体的方法，我们可以在封装模型中实现常见的操作，如获取或设置字段的值，执行特定的操作等。这样，我们可以通过调用结构体的方法来访问和操作封装的数据，实现更加灵活和可复用的代码。
问题内容
我有 2 个包作为模型：
类别：
package class
import (
"encoding/json"
"student_management/model/base"
)
type classes struct {
classes []class
}
type class struct {
id int `json:"student_id"`
name int `json:"name"`
homeroomteacherid int `json:"homeroom_teacher_id"`
}
func readdata() (chan class, int) {
var classes classes
bytevalue := base.readjson("db/student_class.json")
json.unmarshal(bytevalue, &classes)
classchannel := make(chan class)
go func () {
for i := 0; i < len(classes.classes); i++ {
classchannel <- classes.classes[i]
}
close(classchannel)
}()
return classchannel, len(classes.classes)
}
老师：
立即学习“go语言免费学习笔记（深入）”；
package teacher
import (
"encoding/json"
base "student_management/model/base"
)
type teachers struct {
teachers []teacher `json:"teachers"`
}
type teacher struct {
base.persions
homeroomteacher bool `json:"homeroom_teacher"`
}
func readdata() (chan teacher, int) {
var teachers teachers
bytevalue := base.readjson("db/teachers.json")
json.unmarshal(bytevalue, &teachers)
teacherchannel := make(chan teacher)
go func () {
for i := 0; i < len(teachers.teachers); i++ {
teacherchannel <- teachers.teachers[i]
}
close(teacherchannel)
}()
return teacherchannel, len(teachers.teachers)
}
因此您可以看到 readdata 函数被重复执行。现在我可以使用 class.readdata() 和 teacher.readdata() 从通道调用数据。
如何编写一次 readdata() 函数供两个包使用？
我尝试创建一个使用泛型的基础包，如下所示：
package base
func ReadData[Models any, Model any](fileName string, m Models) (chan interface{}, int) {
byteValue := ReadJSON(fileName)
json.Unmarshal(byteValue, &m)
channel := make(chan Model)
go func () {
for i := 0; i < len(m.Models); i++ {
channel <- m.Models[i]
}
close(channel)
}()
return channel, len(models.Models)
}
但是找不到m.models，我的意思是teachers.teachers或classes.classes无法使用
请告诉我在这种情况下该怎么办
解决方法
使用泛型（go 1.18 中引入）。创建一个 readdata() 函数，使用参数类型表示要从 json 解码并在通道上传递的值。
注意：您应该检查错误并报告错误（包括来自 base.readjson() 的错误）。
func readdata[t any](filename, fieldname string) (chan t, int, error) {
var m map[string][]t
bytevalue := base.readjson(filename)
if err := json.unmarshal(bytevalue, &wrapper); err != nil {
return nil, 0, err
}
values := m[fieldname]
valueschannel := make(chan t)
go func() {
for _, v := range values {
valueschannel <- v
}
close(valueschannel)
}()
return valueschannel, len(values), nil
}
调用示例：
ch, n, err := readdata[class.class]("db/student_class.json", "classes")
// or
ch, n, err := readdata[teacher.teacher]("db/teachers.json", "teachers")
请注意，返回读取值的数量应该是多余的。由于您正确关闭了返回的通道，调用者可以在返回的通道上使用 for range ，该通道将正确接收在其上发送的所有值，然后终止。
另请注意，由于返回通道时所有值都已准备就绪（已解码），因此这种并发性是多余的，只会降低效率。您有一个解码值的切片，只需返回它并让调用者选择它希望如何处理它（并发或非并发）。
所以你的 readdata() 应该如下所示：
func readdata[t any](filename, fieldname string) ([]t, error) {
var m map[string][]t
bytevalue := base.readjson(filename)
if err := json.unmarshal(bytevalue, &wrapper); err != nil {
return nil, err
}
return m[fieldname]
}
另请注意，如果输入 json 对象只有一个字段，则无需传递 fieldname，您可以从解码后的 m 映射中获取值，如下所示：
func readdata[t any](filename string) ([]t, error) {
var m map[string][]t
bytevalue := base.readjson(filename)
if err := json.unmarshal(bytevalue, &wrapper); err != nil {
return nil, err
}
for _, v := range m {
return v, nil
}
return nil, errors.new("empty json")
}
然后调用它很简单：
classes, err := ReadData[class.Class]("db/student_class.json")
// or
teachers, err := ReadData[teacher.Teacher]("db/teachers.json") 
