开发者

Go语言学习教程之结构体的示例详解

开发者 https://www.devze.com 2022-12-03 13:47 出处:网络 作者: 任沫
目录前言可导出的标识符嵌入字段提升标签结构体与jsON相互转换结构体转JSONJSON转结构体练习代码步骤前言
目录
  • 前言
  • 可导出的标识符
  • 嵌入字段
  • 提升
  • 标签
  • 结构体与jsON相互转换
    • 结构体转JSON
    • JSON转结构体
  • 练习代码步骤

    前言

    结构体是一个序列,包含一些被命名的元素,这些被命名的元素称为字段(field),每个字段有一个名字和一个类型。

    结构体用得比较多的地方是声明与数据库交互时需要用到的Model类型,以及与JSON数据进行相互转换。(当然,项目中任何需要多种数据结构组合在一起使用的地方,都可以选择用结构体)

    代码段1:声明一个待办事项的Model类型:

    type Todo struct {
        ID        uint `gorm:"primarykey"`
        CreatedAt time.Time
        UpdatedAt time.Time
        DeletedAt gorm.DeletedAt `gorm:"index"`
        Title     string
        Detail    string `gorm:"column:todo_detail;comment:待办详情"`
        Done      bool   `gorm:"default:false"`
    }

    结构体类型Todo包含unit类型的字段ID,time.Time类型的字段CreatedAt,string类型的字段Title...,当执行db.AutoMigrate(&Todo{})自动迁移model到数据库中时,对应的创建表的SQL为:

    CREATE TABLE `toDOS` (
      `id` bigint unsigned NOT NULL AUTO_INCREMENT,
      `created_at` datetime(3) DEFAULT NULL,
      `updated_at` datetime(3) DEFAULT NULL,
      `deleted_at` datetime(3) DEFAULT NULL,
      `title` longtext,
      `todo_detail` longtext COMMENT '待办详情',
      `done` tinyint(1) DEFAULT '0',
      PRIMARY KEY (`id`),
      KEY `idx_todos_deleted_at` (`deleted_at`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci 
    

    (关于gorm的约定,本文不会描述,重点是放在结构体本身)

    代码段2:整理所需的数据并转换为JSON格式:

        type Novel struct {
            ID       uint
            Title    string
            Chapters []string
        }
    
        novejavascriptl := Novel{
            ID:    1,
            Title: "我与掘金的二三事",
            Chapters: []string{
                "注册了账号",
                "写了一篇文",
                "又写了一篇文",
                "升级了,开森",
            },
        }
    
        a, err := json.Marshal(novel)
        if err != nil {
            fmt.Println(err)
        }
    
        os.Stdout.Write(a)
    

    执行以上代码打印的内容如下:

    {"ID":1,"Title":"我与掘金的二三事","Chapters":["注册了账号","写了一篇文","又写了一篇文","升级了,开森"]}%  

    可导出的标识符

    允许从另一个包中访问的标识符是可导出的。只有同时满足以下两个条件的标识符为可导出的:

    • 标识符的名称的第一个字符是一个Unicode大写字母。
    • 标识符在包块中声明或者它是一个字段名或方法名。

    所有其他的标识符都是不可导出的。

    以上是可导出标识符的定义,所以对于结构体来说,结构体中的一个字段可导出,字段的名称需要首字母大写。

    只在当前项目中使用的字段可以使用小写字母开头,但是对于需要导出到别的包中进行使用的结构体字段,必须首字母大写,否则其他包无法访问该字段。

    代码段3:

    type Novel struct {
            ID       uint
            Title    string
            Chapters []string
            inited   bool
        }
    
        novel := Novel{
            inited: true,
            ID:     2,
            Title:  "小步慢跑",
            Chapters: []string{
                "ᕕ( ᐛ )ᕗ",
            },
        }
    
        a, err := json.Marshal(novel)
        if err != nil {
            fmt.Println(err)
        }
    
        os.Stdout.Write(a)
    

    打印的内容如下:

    {"ID":2,"Title":"小步慢跑","Chapters":["ᕕ( ᐛ )ᕗ"]}%   

    可以看到字段inited只是在代码中赋值为true了,打印出的内容中并没有inited字段。在json.Marshal转换时,不会对字段inited进行处理,因为外部的包不能访问不可导出字段。

    嵌入字段

    一个声明了类型但是没有显式字段名称的字段称为嵌入字段。一个嵌入字段必须声明一个类型名称T,或者一个指向非接口类型的指针*T,并且T本身不是一个指针类型。

    代码段4:只有标识符列表:

        type Novel struct {
            ID          uint
            Deleted     bool
            CreatedTime time.Time
    
            Title    string
            Chapters []string
        }
    
        novel := Novel{
            ID:          2,
            Deleted:     false,
            CreatedTime: time.Now(),
            Title:       "小步慢跑",
            Chapters: []string{
                "ᕕ( ᐛ )ᕗ",
            },
        }
    
        a, err := json.Marshal(novel)
        if err != nil {
            fmt.Println(err)
        }
    
        os.Stdout.Write(a)
    

    代码段5: 使用了嵌入字段:

        type Common struct {
            ID          uint
            Deleted     bool
            CreatedTime time.Time
        }
    android
        type Novel struct {
            Common
            Title    string
            Chapters []string
        }
    
        common := Common{
            ID:          2,
            Deleted:     false,
            CreatedTime: time.Now(),
        }
        novel := Novel{
            Common: common,
            Title:  "小步慢跑",
            Chapters: []string{
                "ᕕ( ᐛ )ᕗjavascript",
            },
        }
    
        a, err := json.Marshal(novel)
        if err != nil {
            fmt.Println(err)
        }
    
        os.Stdout.Write(a)
    

    以上两段代码打印出的内容是一样的。包含嵌入字段的类型声明中,Common就是嵌入字段,类型的名称就是嵌入字段的名称。

        type Novel struct {
            Common
            Title    string
            Chapters []string
        }

    提升

    结构体x中的嵌入字段的一个字段或者方法被称为提升(promoted)。(首先x.f需要为一个表示字段或者方法f的合法的选择器)

    1.提升字段和结构体的原始字段行为很像,除了它们不能在结构体的复合字面量中作为字段名使用。

    如代码段4中所示,原始字段直接使用结构体字面量进行赋值,但是在使用了嵌入字段的代码段5中,不能直接使用Novel{ID: 2, ...},因为ID是嵌入字段的字段,不能在结构体字面量中使用,否则会报编译错误:

    unknown field ID in struct literal

    但是代码段4和代码段5都可以使用以下方式对字段赋值:

    novel.ID = 2
    

    2.给到一个结构体类型S以及一个定义类型T,提升方法被包括在结构体的方法集合中:

    • 如果S包含一个嵌入字段TS*S的方法集都包含接收器T的提升方法。*S的方法集还包括接收器*T的提升方法。
    • 如果S包含一个嵌入字段*TS*S的方法集都包含接收器T或者*T的提升方法。

    代码段6:

    func promotedA() {
        type Todo struct {
            T1
            *T2
            Title string
        }
        todo := Todo{
            Title: "写一篇小文文",
        }
        todo1 := &Todo{
            Title: "跑步10分钟",
        }
        PrintMethodSet(todo)
        PrintMethodSet(todo1)
    }
    
    type T1 struct{}
    
    func (T1) M1() {
        fmt.Println("m1")
    }
    func (*T1) M2() {
        fmt.Println("m2")
    }
    
    type T2 struct{}
    
    func (T2) M3() {
        fmt.Println("m3")
    }
    func (*T2) M4() {
        fmt.Println("m4")
    }
    
    // 打印类型的方法集
    func PrintMethodSet(x interface{}) {
        v := reflect.ValueOf(x)
        t := v.Type()
        fmt.Printf("类型%s的方法集:\n", t)
    
        for i := 0; i < v.NumMethod(); i++ { // NumMethod()返回值的方法集中,可导出方法的数量
            fmt.Println(
                t.Method(i).Name, // 获取第i个方法的名称
            )
        }
    }

    打印的内容为:

    类型main.Todo的方法集:

    M1

    M3

    M4

    类型*main.Todo的方法集:

    M1

    M2

    M3

    M4

    通过反射可以拿到类型的方法集。关于反射的说明,可以查看我之前写的Go语言中的反射。

    标签

    一个字段声明可能会跟着一个可选的字符串字面量标签(tag),会成为对应的字段声明中的所有字段的一个属性。一个空的标签被认为就是没有标签。标签通过反射接口可见,并参与结构类型标识,但在其他方面被忽略。

    按照惯例,标签字符串是可选的空格分隔符分隔的并列的key:"value"对。每个键都是一个非空的字符串,由除了空格(U+0020 ' '),引号(U+0022 '"')和冒号(U+003A ':')外的非控制字符组成。每个值使用引号引起来并使用字符串字面量语法。

    代码段7:

        type Todo struct {
            Title  string `gorm:""`
            Detail string `gorm:"column:todo_detail;comment:待办详情" json:"detail"`
            Done   bool   `gorm:"default:false" json:"done"`
        }
        todo := Todo{}
        t := reflect.TypeOf(todo)
        for i := 0; i < t.NumField(); i++ { // NumField返回结构体的字段的数量
            field := t.Field(i)
            fmt.Println(
                fmt.Sprintf("字段 %s 对应的标签值:  ", field.Name),
                field.Tag.Get("gorm"),
                field.Tag.Get("json")) // 获取标签中的键"gorm"和"json"对应的值
        }

    打印的内容如下:

    字段 Title 对应的标签值:    

    字段 Detail 对应的标签值:   column:todo_detail;comment:待办详情 detail

    字段 Done 对应的标签值:   default:false done

    结构体与JSON相互转换

    结构体转JSON

    在代码段2中就将结构体转换为了JSON,使用了encoding/json包的json.Marshal方法。

        type Novel struct {
            ID       uint
            Title    string
            Chapters []string
        }
    
        novel := Novel{
            ID:    1,
            Title: "我与掘金的二三事",
            Chapters: []string{
                "注册了账号",
                "写了一篇文",
                "又写了一篇文",
                "升级了,开森",
            },
        }
    
        a, err := json.Marshal(novel)
        if err != nil {
            fmt.Println(err)
        }
    
        os.Stdout.Write(a)
    

    json.Marshal可以用于将Go对象转换为JSON编码的数据,不只是结构体,还包括布尔值、数组等,这里只说结构体相关的部分。

    每一个结构体字段的编码方式可以由存储在结构体标签中的"json"键下的格式化字符串决定。格式化字符串给出字段的名字,可能还VXdXsJsBe会跟着一个由逗号分隔的选项。名称可以为空,以方便在不覆盖默认字段名称的情况下指定选项。

    "omitempty"选项指明字段是一个空值的时候,需要在编码时被省略。空值为false、0、空指针、以及任何空的数组、切片、映射或字符串。

    如果字段的标签是"-",字段永远会被省略。注意一个名字为"-"的字段可以使用标签"-,"进行生成。

    在代码段2的基础上修改结构体的类型声明,观察得到的结果:

    代码段8:

        type Novel struct{
            ID       uint `json:"novel_id"`
            Title    string
            Chapters []string
        }

    打印的内容:

    {"novel_id":1,"Title":"我与掘金的二三事","Chapters":["注册了账号python","写了一篇文","又写了一篇文","升级了,开森"]}% 

    使用"json"的值novel_id作为ID字段转换为JSON后的字段名。

    代码段9:

        type Novel struct {
            ID       uint `json:"novel_id"`
            Title    string
            Chapters []string `json:"novel_chapters,omitempty"`
        }
    
        novel := Novel{
            ID:       1,
            Title:    "我与掘金的二三事",
            Chapters: []string{},
        }
    
        a, err := json.Marshal(novel)
        if err != nil {
            fmt.Println(err)
        }
    
        os.Stdout.Write(a)
    

    打印的内容:

    {"novel_id":1,"Title":"我与掘金的二三事"}%  

    因为[]string{} 是一个空数组,是一个空值,因为使用了omitempty,所以该字段在转换时被忽略了。

    代码段10:

        type Novel struct {
            ID       uint     `json:",omitempty"`
            Title    string   `json:"-"`
            Chapters []string `json:"-,"`
        }
    
        novel := Novel{
            ID:       1,
            Title:    "我与掘金的二三事",
            Chapters: []string{},
        }
    
        a, err := json.Marshal(novel)
        if err != nil {
            fmt.Println(err)
        }
    
        os.Stdout.Write(a)
    

    打印的内容:

    {"ID":1,"-":[]}%  

    字段ID省略了指定名字的部分,所以转化的JSON字段与结构体的字段名一样;字段Title由于使用了-标签值,会在转换的时候永远被忽略;字段Chapters转换的JSON数据使用的字段名为-

    JSON转结构体

    func Unmarshal(data []byte, v any) error
    

    Unmarshal解析JSON编码的数据并将其存储到v指向的值中。

    还是在代码段2的基础上进行修改,把转换为JSON的数据又转换回来:

    代码段11:

        type Novel struct {
            ID       uint
            Title    string
            Chapters []string
        }
    
        novel := Novel{
            ID:    1,
            Title: "我与掘金的二三事",
            Chapters: []string{
                "注册了账号",
            },
        }
    
        a, err := json.Marshal(novel)
        if err != nil {
            fmt.Println(err)
        }
        os.Stdout.Write(a)
        fmt.Println("")
    
        err = json.Unmarshal(a, &novel)
        if err != nil {
            fmt.Println(err)
        }
        fmt.Println(novel)
    
        novel1JSON := []byte(`{"ID":2,"Title":"小步慢跑","Chapters":["ᕕ( ᐛ )ᕗ"]}`)
        var novel1 Novel
        err = json.Unmarshal(novel1JSON, &novel1)
        if err != nil {
            fmt.Println(err)
        }
        fmt.Println(novel1)
    

    打印的内容为:

    {"ID":1,"Title":"我与掘金的二三事","Chapters":["注册了账号"]}

    {1 我与掘金的二三事 [注册了账号]}

    {2 小步慢跑 [ᕕ( ᐛ )ᕗ]}

    练习代码步骤

    1.创建一个文件夹并cd到文件夹目录下:

    $ mkdir practice
    $ cd practice
    

    2.使用go mod init 初始化模块,模块名称为practice,这会创建一个go.mod文件,这个文件可以用于对代码进行依赖追踪。

    $ go mod init practice
    

    此时go.mod文件的内容为:

    module practice
    
    go 1.18

    3.创建一个属于main包的文件main.go,当运行main包的时候,会默认执行其中的main函数。

    package main
    
    import "fmt"
    
    func mai开发者_Go学习n() {
        fmt.Println("小步慢跑(ง o)ว")
    }

    main包所在的文件目录下执行go run .,表示编译和运行当前目录下的main包:

    $ go run .

    4.导入gorm库中的包:gorm核心程序,gorm mysql数据库驱动程序:

    package main
    
    import (
        "fmt"
    
        "gorm.io/driver/mysql"
        "gorm.io/gorm"
    )
    
    //...(此处为省略的使用gorm的代码)
    

    导入新的包时,执行go mod tidy下载新增的包并更新go.mod文件,此时go.mod文件内容为:

    module todo
    
    go 1.18
    
    require (
        gorm.io/driver/mysql v1.3.5
        gorm.io/gorm v1.23.8
    )
    
    require (
        github.com/go-sql-driver/mysql v1.6.0 // indirect
        github.com/jinzhu/inflection v1.0.0 // indirect
        github.com/jinzhu/now v1.1.5 // indirect
    )

    执行go mod vendormain模块的根目录下创建一个名为vendor的目录,其中包含主模块所需的包的副本。

    5.完整的代码地址:https://github.com/renmo/myBlog/tree/master/2022-07-31-struct

    以上就是Go语言学习教程之结构体的示例详解的详细内容,更多关于Go语言 结构体的资料请关注我们其它相关文章!

    0

    精彩评论

    暂无评论...
    验证码 换一张
    取 消

    关注公众号