妙啊,空结构体还能这么用?Go语言的结构体看这篇就够了

简介: 妙啊,空结构体还能这么用?Go语言的结构体看这篇就够了

本文详解了Go语言结构体的各个知识点,最后介绍了空结构体的3种妙用。希望对你有帮助。

定义

结构体,是一种自定义的数据类型,由多个数据类型组合而成。用于描述一类事物相关属性

定义方式

type 类型名 struct {
    字段名 字段类型
}
//示例:
type Animal struct {
  Name string
  Age  int
}

实例化

结构体和结构体指针,两者的实例化有所区别

提供多种写法,灵活使用:

//结构体实例化
//写法1
//var a Animal 
//a.Name = "aaa"
//a.Age = 18
//写法2
a := Animal{ 
  Name: "dog",
  Age:  18,
}
fmt.Println(fmt.Sprintf("%T - %v", a, a)) //main.Animal - {dog 18}
//结构体指针实例化
//写法1
var b *Animal 
b = new(Animal)
//写法2
//b := new(Animal)  
//写法3
//b := &Animal{}    
b.Name = "cat"                            //在底层是(*b).Name = "cat",这是Go语言帮我们实现的语法糖
fmt.Println(fmt.Sprintf("%T - %v", b, b)) //*main.Animal - &{cat 0}

注意:结构体指针必须手动初始化,分配内存地址

匿名结构体

适用于临时数据存储的场景

var v struct {
  Name string
  Age  int
}
fmt.Println(v)

空结构体

不占用内存空间

var v struct{}
fmt.Println(unsafe.Sizeof(v)) //0
v1 := struct{}{}
fmt.Println(unsafe.Sizeof(v1)) //0

构造函数

Go没有自带的构造函数,采用自实现

方式1

结构体不复杂,可以返回结构体类型,值拷贝性能开销小

func NewPerson(name string, age int8) Person {
  return Person{
    name: name,
    age:  age,
  }
}

定义方式2

结构体复杂,得返回结构体指针类型,避免值拷贝产生的性能开销

func NewPerson(name string, age int8) *Person {
  return &Person{
    name: name,
    age:  age,
    sex:  sex,
    country:country,
    province:province,
    city:city,
    town:town,
    address:address,
  }
}

方法与接收者

方法(Method)是一种作用于特定类型变量的函数。这种特定类型变量叫做接收者(Receiver)。接收者的概念就类似于PHP中的this或者 self

方法与函数区别:函数不属于任何类型,方法属于特定类型。函数没有接收者,方法有接收者。

标准格式

func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
    函数体
}

接收者类型(两种):

  • 非指针类型:发生值拷贝产生副本,方法内修改字段,只在方法内生效;
  • 指针类型:不产生副本,方法内修改字段,同步生效;
func NewPerson(name string, age int8) *Person {
  return &Person{
    name: name,
    age:  age,
  }
}
func (p *Person) Dream() {
  p.name = "aaa"
  fmt.Printf("%s的梦想是学好Go语言\n", p.name)  //aaa的梦想是学好Go语言
}
func main() {
  p1 := NewPerson("小王子", 25)
  p1.Dream()
  fmt.Println(p1) //&{aaa 25}
}

什么时候使用指针类型的接收者

  1. 需要修改接收者中的值
  2. 接收者是拷贝代价比较大的大对象
  3. 保证一致性,在同一个文件中,如果有某个方法使用了指针接收者,那么其他的方法也建议使用指针接收者

注意点

1.接收者类型,可以是任何类型,不仅仅只针对结构体类型。但要注意下,类型和方法定义需要在同一个包下面

type MyInt int
func (i MyInt) SayInt() {
  fmt.Println("my type is MyInt")
}
func main() {
  var i1 MyInt
  i2 := MyInt(10)
  i1.SayInt()
  i2.SayInt()
}
输出结果:
my type is MyInt
my type is MyInt

匿名字段

结构体允许其成员字段在声明时没有字段名而只有类型,这种没有名字的字段就称为匿名字段

type User struct {
  Name    string
  Gender  string
  Address //匿名字段
}
type Address struct {
  Province   string
  City       string
  CreateTime string
}
func main() {
  var u1 User
  u1.Name = "张三"
  u1.Gender = "男"
  u1.Address.City = "北京" //匿名字段默认使用类型名作为字段名
  u1.CreateTime = "2019" //匿名字段可以省略,但注意多个匿名字段下有相同字段名,会编译失败,所以建议不采用省略写法
  fmt.Println(u1)
}

但需要注意字段名冲突问题,所以不建议使用省略写法操作匿名字段

实现面向对象的“继承”特性

Go不是面向对象编程的语言,但可以通过嵌套结构体的方式,来实现面向对象的“继承”特性

type Animal struct {
  Name string
  Age  int
}
func (a Animal) Say() {
  fmt.Println(fmt.Sprintf("1-my name is %s and age is %d", a.Name, a.Age))
}
type Cat struct {
  Animal //嵌套结构体实现继承
}
func main() {
  c1 := Cat{}
  c1.Name = "加菲猫"
  c1.Age = 5
  c1.Say()
  //输出结果:
  //1-my name is 加菲猫 and age is 5
}

子类还可以重写父类的Say方法,并且还能拥有自己的Run方法

func (c Cat) Say() {
  fmt.Println(fmt.Sprintf("2-my name is %s and age is %d", c.Name, c.Age))
}
func (c Cat) Run() {
  fmt.Println(fmt.Sprintf("my name is %s,还是跑步高手", c.Name))
}
func main() {
  c1 := Cat{}
  c1.Name = "加菲猫"
  c1.Age = 5
  c1.Say()
  c1.Run()
  //输出结果:
  //2-my name is 加菲猫 and age is 5
  //my name is 加菲猫,还是跑步高手
}

标签tag

通过反射机制,识别结构体的标签,容错能力较差,需要注意使用

标准格式

`key1:"value1" key2:"value2"`

使用注意事项

  • 外层使用 反引号 包起来,里边value需要使用 双引号 包起来;
  • KV之间使用冒号,多个KV之间使用空格(注意:冒号前后不要加其他符号)

使用示例

goframe v2的标准路由注册就是使用标签tag的方式定义的,大家感兴趣可以看下我们开源项目的代码:

github.com/wangzhongya…

结构体与JSON系列化

给结构体添加json标签,然后做json序列化操作:

  • 首字母大写字段(公开) :会转换成json标签指定的字段名,若未指定,则使用自身字段名;
  • 首字小写字段(私有) :不会输出,因为这类字段仅在定义当前结构体的包中可访问;

简单示例

type CardInfo struct {
  Title  string `json:"title"`
  Desc   string
  height int `json:"height"`
}
func main() {
  c1 := CardInfo{
    Title:  "成长之星",
    Desc:   "balabala",
    height: 100,
  }
  data, _ := json.Marshal(c1)
  fmt.Println(string(data)) //{"title":"成长之星","Desc":"balabala"}
  str := "{"title":"title111", "desc":"desc222", "height":20}"
  c2 := CardInfo{}
  _ = json.Unmarshal([]byte(str), &c2)
  fmt.Println(c2) //{title111 desc222 0}
}

空结构体

上文为大家简单介绍了空结构体,使用unsafe.SizeOf()方法,明确知道了空结构体,它不占用存储空间。

(即“宽度”为0,宽度描述了一个类型的实例所占用的存储空间的字节数)

s := struct{}{}
fmt.Println(unsafe.Sizeof(s)) //0

在项目代码中,我们经常都会看到空结构体struct{}{}的使用,它有什么作用,适合什么场景使用呢?

空结构体作用

请大家注意:结构体包含一个指针和指针指向的数据,下文所说的不占用内存其实指的是指针指向的数据为null,但是空结构体最为一个变量它的指针肯定是占用内存空间的,只是单用很小。

因为空结构体的值不占据内存空间的特性,因此被广泛作为各种场景下的占位符使用

  1. 一是节省资源
  2. 二是空结构体本身就具备很强的语义:即这里不需要任何值,仅作为占位符。

空结构体使用场景

主要使用场景有3个

  1. 实现集合类型
  2. 实现空通道
  3. 实现方法接收者

下面逐个为大家详解

1.实现集合类型

Go语言本身是没有集合类型(Set),通常是使用map来替代

但有个问题:就是集合类型,只需要用到key(键),不需要用到value(值)

如果value使用bool来表示,实际会占用1个字节的空间,为了节省空间,这时空结构体就可以大显身手了

type Set map[int]struct{}
func main() {
  s := make(Set)
  s.add(1)
  s.add(2)
  s.add(3)
  s.remove(2)
  fmt.Println(s.exist(1))
  fmt.Println(s)
  //输出:
  //true
  //map[1:{} 3:{}]
}
func (s Set) add(num int) {
  s[num] = struct{}{}
}
func (s Set) remove(num int) {
  delete(s, num)
}
func (s Set) exist(num int) bool {
  _, ok := s[num]
  return ok
}

空结构体作为占位符,不会额外增加不必要的内存开销,很方便的就把问题给解决了

2.实现空通道

在Go语言 channel的使用场景中,常常会遇到通知型 channel,其不需要发送任何数据,只是用于协调 Goroutine 的运行,用于流转各类状态或是控制并发情况。

这类情况就特别适合使用空结构体,只做个占位,不浪费内存空间

func main() {
  ch := make(chan struct{})
  go worker(ch)
  // Send a message to a worker.
  ch <- struct{}{}
  // Receive a message from the worker.
  <-ch
  println("AAA")
  //输出:
  //BBB
  //AAA
}
func worker(ch chan struct{}) {
  // Receive a message from the main program.
  <-ch
  println("BBB")
  // Send a message to the main program.
  close(ch)
}

由于该 channel 使用的是空结构体,因此也不会带来额外的内存开销

3.实现方法接收者

使用结构体类型的变量作为方法接收者,有时结构体可以不包含任何字段属性。这种情况,可以用int或者string来替代,但它们都会占用内存空间,所以使用空结构体是比较合适的。

并且也有利于未来针对该类型进行公共字段等的增加,容易扩展和维护

type T struct{}
func methodUse() {
  t := T{}
  t.Print()
  t.Print2()
  //输出:
  //哈哈哈Print
  //哈哈哈Print2
}
func (t T) Print() {
  fmt.Println("哈哈哈Print")
}
func (t T) Print2() {
  fmt.Println("哈哈哈Print2")
}

总结

本文详解了Go语言结构体的各种知识点,最后针对空结构体的作用和使用场景,进行了详细的讲解。在之后的实际项目开发过程中,只用占位不用实际含义,那么我们就都可以使用空结构体,可以极大的节省不必要的内存开销。

希望对大家有帮助,兄弟们觉好留赞哦。

参考链接:juejin.cn/post/719926…

相关文章
|
3天前
|
安全 Go 调度
Go语言中的并发编程
Go语言自带了强大的并发编程能力,它的协程机制可以让程序轻松地实现高并发。本文将从并发编程的基础概念出发,介绍Go语言中的协程机制、通道和锁等相关知识点,帮助读者更好地理解并发编程在Go语言中的实践应用。
|
1天前
|
数据采集 Web App开发 Go
Go语言与chromedp结合:实现Instagram视频抓取的完整流程
使用Go语言和chromedp库,本文展示了如何抓取Instagram的视频文件,同时通过代理IP保障爬虫稳定和隐私。步骤包括安装chromedp、配置代理(如亿牛云),创建Chrome会话,导航至Instagram,提取视频URL,然后下载视频。关键操作有设置代理服务器、启动Chrome会话、抓取和下载视频。提供的代码示例详细解释了实现过程,有助于开发者学习Instagram数据采集。
Go语言与chromedp结合:实现Instagram视频抓取的完整流程
|
1天前
|
缓存 Go 调度
浅谈在go语言中的锁
【5月更文挑战第11天】本文评估了Go标准库`sync`中的`Mutex`和`RWMutex`性能。`Mutex`包含状态`state`和信号量`sema`,不应复制已使用的实例。`Mutex`适用于保护数据,而`RWMutex`在高并发读取场景下更优。测试显示,小并发时`Mutex`性能较好,但随着并发增加,其性能下降;`RWMutex`的读性能稳定,写性能在高并发时低于`Mutex`。
131 0
浅谈在go语言中的锁
|
2天前
|
存储 安全 编译器
go语言中进行不安全的类型操作
【5月更文挑战第10天】Go语言中的`unsafe`包提供了一种不安全但强大的方式来处理类型转换和底层内存操作。包含两个文档用途的类型和八个函数,本文也比较了不同变量和结构体的大小与对齐系数,强调了字段顺序对内存分配的影响。
62 8
go语言中进行不安全的类型操作
|
2天前
|
Go
配置go语言下载包 - 蓝易云
这个命令会将包下载到你的GOPATH目录下,并自动安装它。
58 1
|
5天前
|
Ubuntu Unix Linux
【GO基础】1. Go语言环境搭建
【GO基础】1. Go语言环境搭建
|
6天前
|
JSON 前端开发 Go
lucky - go 语言实现的快速开发平台
go 语言实现的快速开发平台,自动生成crud代码,前端页面通过json配置,无需编写前端代码。
11 0
|
7天前
|
存储 Java Go
Go 语言切片如何扩容?(全面解析原理和过程)
Go 语言切片如何扩容?(全面解析原理和过程)
17 2
|
7天前
|
负载均衡 Go 调度
使用Go语言构建高性能的Web服务器:协程与Channel的深度解析
在追求高性能Web服务的今天,Go语言以其强大的并发性能和简洁的语法赢得了开发者的青睐。本文将深入探讨Go语言在构建高性能Web服务器方面的应用,特别是协程(goroutine)和通道(channel)这两个核心概念。我们将通过示例代码,展示如何利用协程处理并发请求,并通过通道实现协程间的通信和同步,从而构建出高效、稳定的Web服务器。
|
7天前
|
算法 Go 分布式数据库
构建高可用的分布式数据库集群:使用Go语言与Raft共识算法
随着数据量的爆炸式增长,单一数据库服务器已难以满足高可用性和可扩展性的需求。在本文中,我们将探讨如何使用Go语言结合Raft共识算法来构建一个高可用的分布式数据库集群。我们不仅会介绍Raft算法的基本原理,还会详细阐述如何利用Go语言的并发特性和网络编程能力来实现这一目标。此外,我们还将分析构建过程中可能遇到的挑战和解决方案,为读者提供一个完整的实践指南。