Go语言学习18-结构体的匿名字段、嵌套与JSON

0x00 结构体的匿名字段(了解)

这个玩意儿用的比较少,而且缺陷很大,不建议使用,能看得懂即可。

先来看一个正常的结构体:

type person struct {
	name string
	age  int
}

func main() {
	p1 := person{
		"LiMing",
		20,
	}
	fmt.Println("p1", p1.name)
	fmt.Println("p1", p1.age)
}

那么匿名字段结构体就是,将结构体里面的字段名称去掉,即把name和age去掉。那么问题来了,下面代码块中的???填什么?

type person struct {
	 string
	 int
}

func main() {
	p1 := person{
		"LiMing",
		20,
	}
	fmt.Println("p1",???)
}

答案是填:

type person struct {
	string
	int
}

func main() {
	p1 := person{
		"LiMing",
		20,
	}
	fmt.Println("p1", p1.string)
	fmt.Println("p1", p1.int)

}

看到这儿是不是就惊了!哪有这么玩儿的,把人家的数据类型当作字段名,这要闹哪样啊。

最大的弊端,假设里面的字段,出现了同为string或者同为int类型的字段,就无法使用了。好了,到此为止,了解一下即可。

注意、总结:这里匿名字段的说法并不代表没有字段名,而是默认会采用类型名作为字段名,结构体要求字段名称必须唯一,因此一个结构体中同种类型的匿名字段只能有一个。

0x01 嵌套结构体

在说结构体嵌套前,先看一个例子,可以看出来这两个结构体中,都会有province和city两个字段。

type person struct {
	name     string
	age      int
	province string
	city     string
}

type company struct {
	name     string
	province string
	city     string
}

那我就完全可以将这两个字段新封装成一个结构体

type address struct {
	province string
	city     string
}

然后那两个结构体再进行调用即可

type person struct {
	name    string
	age     int
	address address	//第一个address肯定是一个变量,字段名
}

type company struct {
	name    string
	address address
}

给对应的结构体赋值,输出等

type address struct {
	province string
	city     string
}
type person struct {
	name    string
	age     int
	address address	//这里也可以直接写成一个address,表示匿名嵌套结构体
}
func main() {
	p1 := person{
		name: "你好",
		age:  90000,
		address: address{
			province: "云南",
			city:     "曲靖",
		},
	}
	fmt.Println(p1, p1.name, p1.address.province)
    //如果上面使用了匿名嵌套结构体,那么下面就可以使用p1.city来直接输出
    //先在自己的结构体找这个字段,找不到就去匿名嵌套的结构体中查找该字段
    //看自己的需求了
}

image-20220223164741726

0x02 匿名嵌套结构体字段冲突

这是啥玩意儿,看着名字老长了。其实就是,在type新建结构体的时候,有两个字段一样的嵌套结构体,里面的字段一模一样。那么这时候在后面的调用,就不能直接使用p1.city等这样直接了当的指定方式了,因为你根本不知道你指定的是哪个??这时候你只能一个一个写,写清楚才可以,不然根本识别不了。

type address struct {
	province string
	city     string
}

type workPlace struct {
	province string
	city     string
}

type person struct {
	name string
	age  int
	address
	workPlace
}
type company struct {
	name string
	add  address
}

func main() {
	p1 := person{
		name: "nihao",
		age:  18,
		address: address{
			province: "shandong",
			city:     "威海",
		},
	}
	// fmt.Println(p1.city)这时候不能这么写了
	//因为workPlace和address字段冲突
	//这就是匿名嵌套结构体字段冲突
	fmt.Println(p1.address.province)
	fmt.Println(p1.workPlace.province)
}

0x03 结构体模拟实现其他语言的“继承”

Go语言中使用结构体也可以实现其他编程语言中面向对象的继承。

先看下面这段代码,就是说,新建了一个animal结构体和一个dog结构体,然后都新建了对应的方法。

type animal struct {
	name string
}

func (a animal) move() {
	fmt.Printf("%s会动!", a.name)
}

type dog struct {
	feet uint8
}

func (d dog) wang() {
	fmt.Println("wangwangwang!")
}

这时候注意,dog是属于animal的,所以注意看下面这段代码

type animal struct {
	name string
}

func (a animal) move() {
	fmt.Printf("%s会动!", a.name)
}

type dog struct {
	feet uint8
    animal			//这里直接嵌一个animal 这里直接嵌一个animal 这里直接嵌一个animal 这里直接嵌一个animal 这里直接嵌一个animal
}

func (d dog) wang() {
	fmt.Println("wangwangwang!",d.name)	//按理说,dog结构体中根本就没有name这个字段,而animal里面有,所以这里实现的就是一个类似继承的作用
}

综合练习,可以看出来,相当于继承了。

这段代码,包含了结构体几乎所有的关键知识点,可以重点敲几遍!

package main

import "fmt"

type animal struct {
	name string
}

func (a animal) move() {
	fmt.Printf("%s会动!", a.name)
}

type dog struct {
	feet uint8
	animal
}

func (d dog) wang() {
	fmt.Println("wangwangwang!", d.name)

}
func main() {
	d1 := dog{
		animal: animal{
			name: "wangcai",
		},
		feet: 4,
	}
	fmt.Println(d1)
	d1.wang()
	d1.move()
}

0x04 结构体与JSON(JavaScript Object Notation)

JSON其实最开始是在JS表示对象的一种模式,后来就越来越多地被引用到了前后端分离的、跨语言的一种数据格式了。

看下面这张图,说的就是,后端的语言开发出的网站,传到前端,前端的JS根本就不认识,那么怎么才能进行沟通呢??这就是引出来个JSON。

描述: JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式,其优点是易于人阅读和编写,同时也易于机器解析和生成。

Tips : JSON键值对是用来保存JS对象的一种方式,键/值对组合中的键名写在前面并用双引号""包裹,使用冒号:分隔,然后紧接着值;多个键值之间使用英文,分隔。在Go中我们可以通过结构体序列号生成json字符串,同时也能通过json字符串反序列化为结构体得实例化对象,在使用json字符串转换时, 我们需要用到"encoding/json"包。

image-20220223174501724

其实后端和前端,之间相互传递的就是一个一个的对象,或者说是字符串。我们上json.cn这个网站来看看,试试。

image-20220223174909815

我们在左边输入的这条字符串,交给前端,前端就会将其转换成JS的OBJ对象,从而让前端执行某些事情。

所以我们的根本目的,就是让Go语言,如何生成、转换成左边那么一长条字符串!

目的有二:

1、序列化:把Go语言中的结构体变量——>json格式的字符串

2、反序列化:json格式的字符串——>go语言中能够识别的结构体

可以看到在下面这段代码中,先声明和初始化一个结构体,然后将其专为序列化的json格式字符串。使用到的是encoding/json包中的json.Marshal函数。

但是我们可以看到在终端输出的结果,为什么会是这个样子??

package main

import (
	"encoding/json"
	"fmt"
)

type person struct {
	name string
	age  int
}

func main() {
	p1 := person{
		name: "北京",
		age:  10000,
	}
	slice, err := json.Marshal(p1)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}
	fmt.Println(slice)
	fmt.Printf("%#v", string(slice))

}

image-20220224130522953

是因为,我们将p1这样的结构体放入了json.Marshal这个方法中,而p1调用person内部的属性时,属性名需要转为大写,不然会调用失败。可以理解为不为大写,就不是public,而是private

也就是下面这段代码的写法,这样子在终端输出的内容就很正确了。不过为什么会有反斜杠呢,那只是为了在终端中展示出来,真实环境下是不用的。

package main

import (
	"encoding/json"
	"fmt"
)

type person struct {
	Name string		//这里都换成了大写的字段
	Age  int
}

func main() {
	p1 := person{
		Name: "北京",
		Age:  10000,	//同理,这里也是大写的字段
	}
	slice, err := json.Marshal(p1)
	if err != nil {
		fmt.Printf("%v", err)
		return
	}
	fmt.Println(slice)
	fmt.Printf("%#v", string(slice))

}

image-20220224130802975

这时你应该发现了个问题,就是输出的字段也变成大写了。我能不能让输出的字段也变成小写呢??可以,只不过比较复杂,例如下面这段代码,严格遵循这段代码即可。

结构体标签(Tag)

Tag是结构体的元信息,可以在运行的时候通过反射的机制读取出来,Tag在结构体字段的后方定义,由一对反引号包裹起来,具体的格式如下:key1:"value1" key2:"value2",可以看到它由一个或多个键值对组成。键与值使用冒号分隔,值用双引号括起来。同一个结构体字段可以设置多个键值对tag,不同的键值对之间使用空格分隔。 看下面这段代码:

type person struct{
    Name string	`json:"name" db:"name" ini:"name"`	//当我使用json解析时,按照这个规则来
    Age int
}

image-20220224131909510

反序列化

这里有两个疑问点

1、为什么要写[]byte?首先json.Unmarshal这个函数,前者是个字符切片,规定好了就必须要用[]byte类型!后者是个值value。

什么时候用string,什么时候用[]byte

  • string可以直接比较,[]byte不行,[]byte不能当map的key值
  • 需要操作的粒度为字符串的某个字符时候,用[]byte
  • string不可为nil值
  • []byte的切片特性更加灵活
  • 如果有大量的字符串操作,就用[]byte

image-20220225222846988

2、为什么要是&p2?是因为函数总是复制值过去,如果想要真正的更改对应的值,需要写成指针。

str1 := `{"name":"beijing"}`
var p2 person
json.Unmarshal([]byte(str1), &p2)

0x05 综合练习

package main

import (
	"encoding/json"
	"fmt"
)

// 结构体转json字符串的三种示例
// 结构体中的字段首字母大小写影响的可见性,表示不能对外使用
type Person1 struct{ name, sex string }

// 结构体对象字段可以对外使用
type Person2 struct{ Name, Sex string }

// 但json字符串中键只要小写时可以采用此种方式
type Person3 struct {
	Name string `json:"name"`
	Sex  string `json:"age"`
}

// # 结构体实例化对象转JSON字符串
func serialize() {
	// 示例1.字段首字母大小写影响的可见性
	person1 := &Person1{"weiyigeek", "男孩"}
	person2 := &Person2{"WeiyiGeek", "男生"}
	person3 := &Person3{"WeiyiGeek", "男人"}

	//序列化
	p1, err := json.Marshal(person1)
	p2, err := json.Marshal(person2)
	p3, err := json.Marshal(person3)
	if err != nil {
		fmt.Printf("Marshal Failed :%v", err)
		return
	}

	// 由于返回是一个字节切片,所以需要强转为字符串
	fmt.Printf("person1 -> %v\nperson2 -> %v\nperson3 -> %v\n", string(p1), string(p2), string(p3))
}

// # JSON字符串转结构体实例化对象

type Person4 struct {
	Name string    `json:"name"`
	Sex  string    `json:"sex"`
	Addr [3]string `json:"addr"`
}

func unserialize() {
	jsonStr := `{"name": "WeiyiGeek","sex": "man","addr": ["中国","重庆","渝北"]}`
	p4 := Person4{}

	// 在其内部修改p4的值
	err := json.Unmarshal([]byte(jsonStr), &p4)
	if err != nil {
		fmt.Printf("Unmarhal Failed: %v", err)
		return
	}
	fmt.Printf("jsonStr -> Person4 : %#v\nPerson4.name : %v\n", p4, p4.Name)
}

func main() {
	serialize()
	unserialize()
}
posted @ 2022-02-26 15:53  sukusec不觉水流  阅读(61)  评论(0编辑  收藏  举报