Go 结构体基础 1

墨蓝 2023-10-10 21:58 30阅读 0赞

#### 阅读目录 ####

*  定义
 *   *  实例化
     *   *  结构体实例化
         *  结构体指针实例化
 *  匿名结构体
 *  空结构体
 *   *  空结构体使用场景
     *   *  1 实现集合类型
         *  2 实现空通道
         *  3 实现方法接收者
 *  构造函数
 *   *  方式1 结构体不复杂，可以返回结构体类型，值拷贝性能开销小。
     *   *  定义方式2 结构体复杂，得返回结构体指针类型，避免值拷贝产生的性能开销。
 *  方法与接收者
 *   *  接收者类型（两种）
 *  匿名字段
 *  实现面向对象的“继承”特性
 *  标签 tag
 *  结构体与 JSON 系列化

只用占位不用实际含义，那么我们就都可以使用空结构体，可以极大的节省不必要的内存开销。

## 定义 ##

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

定义方式：

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"，这是Go语言帮我们实现的语法糖
    b.Name = "cat" 
    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

空结构体的值不占据内存空间的特性，因此被广泛作为各种场景下的占位符使用。  
空结构体本身就具备很强的语义：即这里不需要任何值，仅作为占位符。

### 空结构体使用场景 ###

#### 1 实现集合类型 ####

Go语言本身是没有集合类型（Set），通常是使用 map 来替代。

但有个问题：  
就是集合类型，只需要用到key（键），不需要用到value（值）。  
如果 value 使用 bool 来表示，实际会占用1个字节的空间，为了节省空间，这时空结构体就可以大显身手了。

package main
    
    import "fmt"
    
    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 的运行，用于流转各类状态或是控制并发情况。

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

package main
    
    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 来替代，但它们都会占用内存空间，所以使用空结构体是比较合适的。

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

package main
    
    import "fmt"
    
    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没有自带的构造函数，采用自实现。

### 方式1 结构体不复杂，可以返回结构体类型，值拷贝性能开销小。 ###

package main
    
    import "fmt"
    
    type Person struct {
        
    	name string
    	age  int8
    }
    
    func NewPerson(name string, age int8) Person {
        
    	return Person{
        
    		name: name,
    		age:  age,
    	}
    }
    
    func main() {
        
    	person := NewPerson("Alice", 25)
    	fmt.Println(person)
    }

#### 定义方式2 结构体复杂，得返回结构体指针类型，避免值拷贝产生的性能开销。 ####

package main
    
    import "fmt"
    
    type Person struct {
        
    	name     string
    	age      int8
    	sex      string
    	country  string
    	province string
    	city     string
    	town     string
    	address  string
    }
    
    func NewPerson(name string, age int8, sex string, country string, province string, city string, town string, address string) *Person {
        
    	return &Person{
        
    		name:     name,
    		age:      age,
    		sex:      sex,
    		country:  country,
    		province: province,
    		city:     city,
    		town:     town,
    		address:  address,
    	}
    }
    
    func main() {
        
    	person := NewPerson("Alice", 25, "Female", "USA", "California", "Los Angeles", "Beverly Hills", "123 Main St")
    	fmt.Println(person)
    }

## 方法与接收者 ##

方法（Method）是一种作用于特定类型变量的函数。

这种特定类型变量叫做接收者（Receiver）。

接收者的概念就类似于PHP中的this或者 self。

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

标准格式：

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

### 接收者类型（两种） ###

> 非指针类型：发生值拷贝产生副本，方法内修改字段，只在方法内生效；  
> 指针类型：不产生副本，方法内修改字段，同步生效；

package main
    
    import (
    	"fmt"
    )
    
    type Person struct {
        
    	name string
    	age  int
    }
    
    func NewPerson(name string, age int) *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 保证一致性，在同一个文件中，如果有某个方法使用了指针接收者，那么其他的方法也建议使用指针接收者。

注意点：

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

package main
    
    import "fmt"
    
    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

## 匿名字段 ##

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

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

package main
    
    import "fmt"
    
    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) // {张三 男 { 北京 2019}}
    }

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

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

package main
    
    import "fmt"
    
    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 方法：

package main
    
    import "fmt"
    
    type Animal struct {
        
    	Name string
    	Age  int
    }
    
    type Cat struct {
        
    	Animal //嵌套结构体实现继承
    }
    
    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之间使用空格； （注意：冒号前后不要加其他符号）

package main
    
    import (
    	"fmt"
    	"reflect"
    )
    
    type Person struct {
        
    	Name   string `json:"name" validate:"required"`
    	Age    int    `json:"age" validate:"gte=0"`
    	Gender string `json:"gender" validate:"oneof=male female"`
    }
    
    func main() {
        
    	p := Person{
        
    		Name:   "Alice",
    		Age:    25,
    		Gender: "female",
    	}
    
    	PrintTags(p)
    }
    
    func PrintTags(obj interface{
        }) {
        
    	t := reflect.TypeOf(obj)
    
    	for i := 0; i < t.NumField(); i++ {
        
    		field := t.Field(i)
    		fmt.Printf("Field: %s, Tag: %s\n", field.Name, field.Tag.Get("json"))
    	}
    }

> 需要注意的是，标签的值仅限于字符串，且使用反引号（\`\`）括起来。标签值可以根据需要进行自定义，例如用于序列化、验证、ORM 等场景。但是，标签的解析和使用需要通过反射来实现。

PS D:\TEXT\go_test> go run .\main.go
    Field: Name, Tag: name
    Field: Age, Tag: age
    Field: Gender, Tag: gender
    PS D:\TEXT\go_test>

## 结构体与 JSON 系列化 ##

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

首字母大写字段（公开） ：  
会转换成 json 标签指定的字段名，若未指定，则使用自身字段名；

首字小写字段（私有） ：  
不会输出，因为这类字段仅在定义当前结构体的包中可访问；

package main
    
    import (
    	"encoding/json"
    	"fmt"
    )
    
    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}
    }