当前位置： 首页 > news >正文

简单易懂，解析Go语言中的struct结构体

news 2025/9/15 20:20:46

目录

  • 4. struct 结构体
    • 4.1 初始化
    • 4.2 内嵌字段
    • 4.3 可见性
    • 4.4 方法与函数
      • 4.4.1 区别
      • 4.4.2 闭包
    • 4.5 Tag 字段标签
      • 4.5.1定义
      • 4.5.2 Tag规范
      • 4.5.3 Tag意义

4. struct 结构体

go的结构体类似于其他语言中的class，主要区别就是go的结构体没有继承这一概念，但可以使用类型嵌入来实现相似功能。

4.1 初始化

使用type关键字来定义一个新的类型，struct将新类型限定为结构体类型。

结构体中的字段可以为任何类型，但是包含一些特殊类型 如：接口，管道，函数，指针的时候要格外注意

//type定义一个新类型
type newInt int//type定义一个简单的结构体
type base struct{value int   
}//type定义一个复杂的结构体
type student struct {Name stringage  intc    interface{}d    func() inte    func()base     //将base类型嵌入到了student类型中
}

4.2 内嵌字段

内嵌字段大体上有两种方式:显式指定(m1)和隐式指定(m2)

  • 显式指定就相当于把目标结构体当作字段，调用时需要先调用这个字段，在调用目标结构体中的信息
  • 隐式指定相当于把目标结构体中的所有字段都在新结构体中创建了一次，并且指向嵌入结构体内部。同时创建同名嵌入结构体对象[指与base同名]
  • 显式创建同名结构体字段 ≠ 隐式指定
type base struct {Value int
}
//显式指定
type m1 struct {b base
}//隐式指定
type m2 struct {base
}//显式指定同名字段
type m3 struct {base base
}

对上述结构体进行调用:

  • 只有隐式指定直接操作被嵌入结构体内的数据；
  • 隐式指定后，直接操作嵌入结构体中的数据和通同名结构体操作作用一样
func main() {a1 := m1{}a2 := m2{}a3 := m3{}//显式指定只能通过嵌入结构体进行操作// a1.Value = 1 //a1.Value undefined (type m2 has no field or method Value)a1.b.Value = 2//隐式指定两种操作数据方法操作的是同一个变量a2.Value = 2a2.base.Value = 3fmt.Println(a2.Value) //3//显式指定同名变量 ≠ 隐式指定 // a3.Value = 3 //a3.Value undefined (type m3 has no field or method Value)a3.base.Value = 4
}

当内嵌字段中的字段与结构体中得字段同名时：

  • 直接调用时是指定当前结构体中显式定义的字段，但嵌入结构体中的字段仍可通过嵌入类型进行调用
  • 方法同理
//数据
func main() {a1 := m1{}a1.Value = "hello world"a1.base.Value = 1fmt.Println(a1)//获取a1中的所有字段类型t := reflect.TypeOf(a1)for i := 0; i < t.NumField(); i++ {field := t.Field(i)fieldType := field.Typefmt.Printf("Field: %s, Type: %s\n", field.Name, fieldType.Name())}
}type base struct {Value int
}type m1 struct {Value stringbase
}
/*
{hello world {1}}
Field: Value, Type: string
Field: base, Type: base*/

//方法
func main() {a1 := m1{}a1.test()a1.base.test()fmt.Println(a1)//获取a1中的所有字段类型t := reflect.TypeOf(a1)for i := 0; i < t.NumField(); i++ {field := t.Field(i)fieldType := field.Typefmt.Printf("Field: %s, Type: %s\n", field.Name, fieldType.Name())}
}type base struct {Value int
}func (b *base) test() {b.Value = 1
}
func (m *m1) test() {m.Value = "hello world"
}type m1 struct {Value stringbase
}
/*
{hello world {1}}
Field: Value, Type: string
Field: base, Type: base*/

4.3 可见性

  • 首字母大写表示该字段/方法/结构体为可导出的，反之为不可导出的
  • 在同一个包内，不区分是否可导出，都可访问；包外只能访问可导出的字段/方法/结构体
  • 不可导出的字段不可以进行序列化（转化为json）
  • 可通过可导出的方法去操作不可导出的字段
// test/test1.go
package testtype User struct {Name stringage  int
}func (u *User) Test() {u.Name = "hello"u.age = 18
}func (u *User) test() {u.Name = "world"u.age = 81
}type student struct {Name stringage  int
}

//main.go
package mainimport ("fmt""test/test"
)func main() {a := test.User{}//b := test.student{} // 不能在包外访问未导出结构体a.Name = "123"//a.age = 123 // 不能在包外访问未导出字段a.Test()//a.test() // 不能在包外访问未导出方法fmt.Println(a)/*{hello 18}*/
}

4.4 方法与函数

4.4.1 区别

  • 方法定义是必须有一个接收器(receiver)；函数不需要
  • 大部分情况下，方法的调用需要有一个对象；函数不需要
  • 由于go中的所有传递都是值传递，也就是将数据复制一份再调用，所以如果想要修改原本对象的值，就要传递指针，进行引用传递
func 函数名 (参数) 返回值类型 {函数体} //函数定义
func (接收器) 方法名  (参数) 返回值类型 {函数体} // 方法定义

func main() {a := User{}a.setName() // 方法调用fmt.Println(a)setName(&a) // 函数调用fmt.Println(a)
}
/*{world 0}{hello 0}*/type User struct {Name stringage  int
}
//函数
func setName(u *User) {u.Name = "hello"
}
//方法
func (u *User) setName() {u.Name = "world"
}

值传递时可以通过返回值的方式修改目标对象

func main() {a := User{}a = a.setName() //需要显式给原变量赋值fmt.Println(a)a = setName(a)  //需要显式给原变量赋值fmt.Println(a)
}type User struct {Name stringage  int
}func setName(u User) User {u.Name = "hello"return u
}
func (u User) setName() User {u.Name = "world"return u
}

4.4.2 闭包

说到函数和方法，就必须说一下闭包

什么是闭包？

简单来说，就是函数内部引用函数外部变量，导致变量生命周期发生变化。这样的函数就叫做闭包

常见于函数返回值为另一个函数时

package mainimport "fmt"func main() {b := test()fmt.Println(b())fmt.Println(b())
}func test() func() int {a := 1return func() int {a++return a}
}

上面的函数导致变量a无法正常释放，导致变量逃逸

go build -gcflags="-m" main.go
# command-line-arguments
./main.go:11:6: can inline test
./main.go:13:9: can inline test.func1
./main.go:6:11: inlining call to test
./main.go:13:9: can inline main.test.func1
./main.go:7:15: inlining call to main.test.func1
./main.go:7:13: inlining call to fmt.Println
./main.go:8:15: inlining call to main.test.func1
./main.go:8:13: inlining call to fmt.Println
./main.go:6:11: func literal does not escape
./main.go:7:13: ... argument does not escape
./main.go:7:15: ~R0 escapes to heap
./main.go:8:13: ... argument does not escape
./main.go:8:15: ~R0 escapes to heap
./main.go:12:2: moved to heap: a
./main.go:13:9: func literal escapes to heap

4.5 Tag 字段标签

4.5.1定义

在reflect包中提供了获取字段名称、类型、Tag的方法（上文展示过获取名称和类型）

结构体StructField表示结构体的一个字段(reflect/type.go)

// A StructField describes a single field in a struct.
type StructField struct {// Name is the field name.Name string// PkgPath is the package path that qualifies a lower case (unexported)// field name. It is empty for upper case (exported) field names.// See https://golang.org/ref/spec#Uniqueness_of_identifiersPkgPath stringType      Type      // field typeTag       StructTag // field tag stringOffset    uintptr   // offset within struct, in bytesIndex     []int     // index sequence for Type.FieldByIndexAnonymous bool      // is an embedded field
}type StructTag string

4.5.2 Tag规范

StructTag本质上就是字符串，理论上任何形式都符合规范。但通常情况下约定，Tag的格式应该是key:“value”

  • key:非空字符串，不能包含控制字符，空格，引号，冒号
  • value：双引号包围的字符串
  • 冒号前后不能有空格，多个value用逗号隔开，key之间用空格隔开
  • key一般表示用途，value表示控制指令；

4.5.3 Tag意义

  • Go语言反射机制可以给结构体成员赋值，用Tag可以决定赋值的动作
  • 可以使用定义好的Tag规则，参考规则就可以继续不同的操作
//仅对Tag值为true的字段赋值（Tag决定赋值动作）
type Person struct {Name string `assign:"true"`Age  int    `assign:"false"`
}func assignValues(v interface{}) {val := reflect.ValueOf(v).Elem() // 获取指针指向的值typ := val.Type()for i := 0; i < val.NumField(); i++ {field := val.Field(i)tag := typ.Field(i).Tag.Get("assign") // 获取字段的tagif tag == "true" {// 根据字段类型赋值switch field.Kind() {case reflect.String:field.SetString("Default Name")case reflect.Int:field.SetInt(25)}}}
}func main() {p := &Person{}assignValues(p)fmt.Printf("Person: %+v\n", p)
}
/*
Person: &{Name:Default Name Age:0}*/

下方例子使用了json:“kind,omitempty”，这个tag规定了字段为空不进行序列化；

import ("encoding/json""fmt"
)type Person struct {Name  string `json:"kind,omitempty"` //为空时不进行序列化Value intage   int
}func main() {// 创建一个 Person 实例p := Person{Name: "", Value: 100, age: 100}// 序列化为 JSONjsonData, _ := json.Marshal(p)fmt.Println(string(jsonData)) /*{"Value":100}*/
}
http://www.lryc.cn/news/543112.html

相关文章：

  • java给钉钉邮箱发送邮件
  • C++和OpenGL实现3D游戏编程【连载23】——几何着色器和法线可视化
  • 大连本地知识库的搭建--数据收集与预处理_01
  • github 推送的常见问题以及解决
  • stm32单片机个人学习笔记16（SPI通信协议）
  • Linux | RHEL / CentOS 中 YUM history / downgrade 命令回滚操作
  • BGP状态和机制
  • 温湿度监控设备融入智慧物联网
  • smolagents学习笔记系列（五）Tools-in-depth-guide
  • 前端面试真题 2025最新版
  • 面试八股文--数据库基础知识总结(1)
  • 10. docker nginx官方镜像使用方法
  • [Web 安全] PHP 反序列化漏洞 —— PHP 反序列化漏洞演示案例
  • es-head（es库-谷歌浏览器插件）
  • 第二十：【路由的props配置】
  • Vue 2全屏滚动动画实战：结合fullpage-vue与animate.css打造炫酷H5页面
  • AF3 DataPipeline类process_pdb 方法解读
  • 抓包工具 wireshark
  • OpenBMC：BmcWeb app获取socket
  • 《深度学习实战》第2集-补充：卷积神经网络（CNN）与图像分类 实战代码解析和改进
  • nodejs：express + js-mdict 作为后端，vue 3 + vite 作为前端，在线查询英汉词典
  • 《深度剖析Linux 系统 Shell 核心用法与原理_666》
  • 索提诺比率（Sortino Ratio）：更精准的风险调整收益指标（中英双语）
  • minio作为K8S后端存储
  • 一周学会Flask3 Python Web开发-Jinja2模板访问对象
  • RAGS评测后的数据 如何利用influxdb和grafan 进行数据汇总查看
  • 第25周JavaSpringboot实战-电商项目 4.商品分类管理
  • C语言--正序、逆序输出为奇数的位。
  • C#快速调用DeepSeek接口，winform接入DeepSeek查询资料 C#零门槛接入DeepSeek C#接入DeepSeek源代码下载
  • H13-821 V3.0 HCIP 华为云服务架构题库