golang中封装模型的常用函数如何实现？

在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)
}

老师：

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")

以上是golang中封装模型的常用函数如何实现？的详细内容。更多信息请关注PHP中文网其他相关文章！