在实际案例的操作过程中，我们可能会遇到“如何掌握Go语言结构体，有哪些要点和方法”这样的问题，那么我们该如何处理和解决这样的情况呢？这篇小编就给大家总结了一些方法，具有一定的借鉴价值，希望对大家有所帮助，接下来就让小编带领大家一起了解看看吧。一、结构体
Python 1、结构体的定义与使用
// 定义
type Person struct {
Name string
Age int
Sex string
}
func main() {
// 使用
var per Person
per.Name="XiaoYang"
fmt.Println(per)
}
2、定义并赋初值
type Person struct {
Name string
Age int
Sex string
}
func main() {
var per1 Person = Person{Name: "XiaoYang"} // 按关键字传参，可以少传
var per2 Person = Person{"Bob", 20, "男"} // 按位置传参，全传
fmt.Println(per1) // 输出：{XiaoYang 0 }
fmt.Println(per2) // 输出：{Bob 20 男}
}
3、匿名结构体（只使用一次，没有名字）
// 定义个匿名结构体并实例化之后赋值给了 hobby 变量
hobby := struct {
HobbyId int
HobbyName string
}{HobbyId: 1, HobbyName: "篮球"}
fmt.Println(hobby) // 输出：{1 篮球}
fmt.Println(hobby.HobbyName) // 输出：篮球
4、结构体的零值
定义好的结构体没有被初始化时，该结构体的字段将默认赋值为零值
copy type Person struct {
Name string
Age int
Sex string
}
func main() {
var per Person=Person{"Bob", 20, "男"}
fmt.Println(per) // 输出：{Bob 20 男}
test(per) // 输出：{Bob 20 男}
fmt.Println(per) // 输出：{Bob 20 男}
}
func test(per Person) {
per.Age=20
fmt.Println(per)
}
5、结构体的指针
// & 放在变量前，表示取该变量的地址
// * 放在类型前，表示指向该类型的指针（变量定义，指定类型时才会用到） *[3]int 和 [3]*int
// * 放在变量前，表示解引用（取出指针指向的具体的值）
type Person struct {
Name string
Age int
Sex string
}
func main() {
var per1 *Person
fmt.Println(per1) // 输出：<nil> 表示指针类型
// 定义并初始化
var per2 *Person = &Person{}
fmt.Println(per2) // 输出：&{ 0 }
// 把per2的名字改成XiaoYang
(*per2).Name = "XiaoYang"
// 也支持直接使用
per2.Name = "Bob"
fmt.Println(per2) // 输出：&{Bob 0 }
}
6、匿名字段（字段没有名字，只有类型）
可用于【变量提升 / 提升字段】类似于面向对象的继承
// 定义一个结构体，匿名字段类型就是字段名字，所有类型不能重复
type Person struct {
string
int
Sex string
}
func main() {
per := Person{"XiaoYang", 20, "男"} // 字段匿名，类型就是字段名
fmt.Println(per) // 输出：{XiaoYang 20 男}
fmt.Println(per.string) // 输出：XiaoYang
}
7、嵌套结构体（结构体中套结构体）
type Person struct {
Name string
Age int
Sex string
Hobby Hobby // Person中嵌套Hobby结构体字段
}
type Hobby struct {
HobbyId int
HobbyName string
}
func main() {
per := Person{Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{1,"篮球"}}
fmt.Println(per) // 输出：{XiaoYang 20 男 {1 篮球}}
fmt.Println(per.Name) // 输出：XiaoYang
fmt.Println(per.Hobby.HobbyName) // 输出：篮球
}
8、字段提升
结构体中有匿名的结构体类型字段，则该匿名结构体里的字段就称为提升字段，可以从外部直接访问
type Person struct {
Name string
Age int
Sex string
Hobby // Person中嵌套Hobby匿名结构体字段
}
type Hobby struct {
HobbyId int
HobbyName string
}
func main() {
per := Person{Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{1,"篮球"}}
// 打印爱好的名字（Hobby是一个匿名字段，会字段提升）
fmt.Println(per.HobbyName) // 输出：篮球
// per.hobby 类似于面向对象中的super()
fmt.Println(per.Hobby.HobbyName) // 输出：篮球
}
// ------------------------------------------------------------------------------------
// 当子类和父类中的字段名一样时，就像面向对象的继承，子类继承父类（结构体嵌套，匿名字段），子类可以直接调用父类中的属性或方法
type Person struct {
Name string
Age int
Sex string
Hobby // Person中嵌套Hobby匿名字段
}
type Hobby struct {
HobbyId int
Name string
}
func main() {
per := Person{Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{1,"篮球"}}
fmt.Println(per.Name) // 输出：XiaoYang ——>优先使用自己的
fmt.Println(per.Hobby.Name) // 输出：篮球 ——>指定打印Hobby的名字
}
9、结构体相等性
结构体是值类型。
如果它的每一个字段都是可比较的，则该结构体也是可以比较的。
如果两个结构体变量的对应字段相等，则两个变量也是相等的。
如果结构体包含不可比较的字段，则结构体变量也不可比较。
type Person struct {
Name string
Age int
Sex string
// 包含不可比较的字段
Test []int ——>这是引用类型不可比较
}
func main() {
// 值类型可以直接==比较，引用类型只能跟nil用==比较
per1 := Person{Name: "XiaoYang"}
per2 := Person{Name: "XiaoYang"}
per3 := Person{Name: "XiaoYang", Age: 20}
fmt.Println(per1 == per2) // 输出：ture ——>包含不可比较类型都会直接报错
fmt.Println(per1 == per3) // 输出：false
}
二、方法
方法就是一个特殊函数，在函数的基础上加了一些东西
func1、方法的定义和使用
type Person struct {
Name string
Age int
Sex string
}
// 定义一个方法：给Person结构体绑定一个方法，oneself（名字随便取）类似于Python类中的self
func (oneself Person) printName() {
// 在方法内使用oneself
fmt.Println(oneself.Name)
}
func main() {
// 使用，对象调用方法
per := Person{}
per.Name = "XiaoYang"
// 绑定给对象的方法
per.printName() // 输出：XiaoYang
}
2、有了函数为啥还需要方法？
方法功能都能实现，但是呢？它就能指定给某个对象了 。
type Person struct {
Name string
Age int
Sex string
}
// 方法
func (oneself Person) printName() {
fmt.Println(oneself.Name)
}
// 函数
func printName(oneself Person) {
fmt.Println(oneself.Name)
}
func main() {
per := Person{Name: "XiaoYang"}
per.printName() // 方法的特殊之处，可以自动传递值
printName(per) // 函数需要手动传递值
}
3、指针接收器与值接收器
type Person struct {
Name string
Age int
Sex string
}
// 值接收器修改名字
func (oneself Person) changeName(name string) {
oneself.Name = name
}
// 指针接收器修改年龄
func (oneself *Person) changeAge(age int) {
oneself.Age = age
}
func main() {
per := Person{Name: "XiaoYang", Age: 20}
fmt.Println(per) // 输出：{XiaoYang 20 }
per.changeName("Bob")// 由于这个是值接收器，它是copy一份传递过去所以修改的是copy的不会改掉原来的
per.changeAge(18) // 指针接收器，它传递的是指针
fmt.Println(per) // 输出：{XiaoYang 18 }
}
/*
什么时候用指针接收器，什么时候使用值接收器：
-想改原来的，就用指针
-不想改原来的，就用值
*/
5、匿名字段的方法（方法提升）
type Person struct {
Name string
Age int
Sex string
Hobby // 匿名字段
}
type Hobby struct {
Id int
Name string
}
// 打印Person的名字
func (oneself Person) printName() {
fmt.Println(oneself.Name)
}
// 打印Hobby的名字
func (oneself Hobby) printHobbyName() {
fmt.Println(oneself.Name)
}
// 打印Hobby的名字
func (oneself Hobby) printName() {
fmt.Println(oneself.Name)
}
func main() {
per := Person{Name: "XiaoYang", Hobby: Hobby{1, "篮球"}}
per.printName() // 输出：XiaoYang
per.printHobbyName() // 输出：篮球
// 如果方法重名了，优先使用结构体自己的
per.printName() // 输出：XiaoYang
per.Hobby.printName() // 输出：篮球
}
6、在方法中使用值接收器 与 在函数中使用值参数
type Person struct {
Name string
Age int
Sex string
}
// 在方法中使用值接收器
func (oneself Person) printName() {
fmt.Println(oneself.Name)
}
// 在函数中使用值参数
func printName(oneself Person) {
fmt.Println(oneself.Name)
}
func main() {
per1 := &Person{Name: "XiaoYang"} // per1是个指针
per2 := Person{Name: "Bob"}
printName(*per1) // 输出：XiaoYang
per1.printName() // 输出：XiaoYang ———> 值收器:可以用值来调，也可以用指针来调
per2.printName() // 输出：Bob
}
7、在方法中使用指针接收器 与 在函数中使用指针参数
type Person struct {
Name string
Age int
Sex string
}
// 在方法中使用指针接收器
func (oneself *Person) printName() {
fmt.Println(oneself.Name)
}
func (oneself *Person)changeName(name string) {
oneself.Name=name
}
// 在函数中使用指针参数
func printName(oneself *Person) {
fmt.Println(oneself.Name)
}
func main() {
per1 := Person{Name: "XiaoYang"}
per2 := &Person{Name: "Bob"} // per1是个指针
per1.printName() // 值可以调用
printName(&per1)
per2.printName() // 指针可以调用
printName(per2)
per1.changeName("Alen") // 可以修改
fmt.Println(per1)
per2.changeName("YS") // 可以修改
fmt.Println(per2)
}
总结：
- -不管是值类型接收器还是指针类型接收器，都可以用值来调用，或者指针来调用。
- -不管是值还是指针来调用，只要是值类型接收器，改的就是新的，只要是指针类型接收器，改的是原来的。
8、非结构体上绑定方法
intstring 但是自己定义的类型可以绑定方法
type Myint int
func (i *Myint) add() {
(*i)++
}
func main() {
var a Myint = 10
fmt.Println(a) // 输出：10
a.add()
a.add()
a.add()
fmt.Println(a) // 输出：13
}
关于“如何掌握Go语言结构体，有哪些要点和方法”的内容就介绍到这，感谢各位的阅读，相信大家对如何掌握Go语言结构体，有哪些要点和方法已经有了进一步的了解。大家如果还想学习更多知识，欢迎关注群英网络，小编将为大家输出更多高质量的实用文章！
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：mmqy2019@163.com进行举报，并提供相关证据，查实之后，将立刻删除涉嫌侵权内容。