关键词：
结构体
在定义结构体之前，我们先来看看什么是类型定义和类型别名
go语言类型定义
类型定义的语法
type NewType Type
举例
func main()
//类型定义
type MyInt int
//i为MyInt类型
var i MyInt
i = 100
fmt.Printf("i: %v i: %T\\n", i, i)
go语言类型别名
类型别名语法
type NewType = Type
举例
func main()
//类型别名定义
type MyInt2 = int
//i还是int类型
var i MyInt2
i = 100
fmt.Printf("i: %v i: %T\\n", i, i)
go语言类型定义和类型别名的区别
- 1.类型定义相当于定义了一个全新的类型，与之前的类型不同；但是类型别名并没有定义一个新的类型，而是使用一个别名来替换之前的类型
- 2.类型别名只会在代码中存在，在编译完成之后并不会存在该别名
- 3.因为类型别名和原来的类型是一致的，所以原来类型所拥有的方法，类型别名中也可以调用，但是如果是重新定义的一个类型，那么不可以调用之前的任何方法
结构体
go语言结构体的定义
结构体的定义和类型定义类似，只不过多了一个struct关键字
- 语法结构如下：
type struct_variable_type struct
member definition;
member definition;
...
member definition;
- type：结构体定义关键字
- struct_variable_type：结构体类型名称
- struct：结构体定义关键字
- member definition：成员定义
举例
下面我们定义一个人的结构体Person
type Person struct
id int
name string
age int
email string
以上我们定义一个Person结构体，有四个成员，来描述一个Person的信息。类型相同可以合并到一行，例如：
type Person struct
id, age int
name, email string
声明一个结构体变量
声明一个结构体变量和声明一个普通变量相同，例如：
var tom Person
fmt.Printf("tom: %v\\n", tom)
kite := Person
fmt.Printf("kite: %v\\n", kite)
结果
tom: 0 0
kite: 0 0
结构体成员，在没有赋值之前都是零值。
结构体的初始化
- 未初始化的结构体
成员都是默认值 int 0 float 0.0 bool false string nil nil
package main
import "fmt"
func main()
type Person struct
id, age int
name, email string
var tom Person
fmt.Printf("tom: %v\\n", tom)
- 使用键值对对结构体进行初始化
package main
import "fmt"
func main()
type Person struct
id, age int
name, email string
kite := Person
id: 1,
name: "kite",
age: 20,
email: "zjc.com",
fmt.Printf("kite: %v\\n", kite)
- 使用值的列表初始化
注意：
- 必须初始化结构体的所有字段。
- 初始值的填充顺序必须与字段在结构体中的声明顺序一致。
- 该方式不能和键值初始化方式混用。
package main
import "fmt"
func main()
type Person struct
id, age int
name, email string
kite := Person
1,
20,
"kite",
"zjc.com",
fmt.Printf("kite: %v\\n", kite)
- 部分成员初始化
package main
import "fmt"
func main()
type Person struct
id, age int
name, email string
kite := Person
id: 1,
name: "kite",
fmt.Printf("kite: %v\\n", kite)
访问结构体成员
可以使用点运算符(.)，来访问结构体成员，例如：
package main
import "fmt"
func main()
type Person struct
id, age int
name, email string
var tom Person
tom.id = 1
tom.name = "tom"
tom.age = 20
tom.email = "zjc.com"
fmt.Printf("tom: %v\\n", tom)
匿名结构体
如果结构体是临时使用，可以不用起名字，直接使用，例如：
package main
import "fmt"
func main()
var dog struct
id int
name string
dog.id = 1
dog.name = "旺财"
fmt.Printf("dog: %v\\n", dog)
结构体指针
举例
package main
import "fmt"
func main()
type Person struct
id int
name string
var tom = Person1, "tom"
var p_person *Person
p_person = &tom
fmt.Printf("tom: %v\\n", tom)
fmt.Printf("p_person: %p\\n", p_person)
fmt.Printf("*p_person: %v\\n", *p_person)
使用new关键字创建结构体指针
我们还可以通过使用new关键字对结构体进行实例化，得到的是结构体的地址，例如：
package main
import "fmt"
func main()
type Person struct
id int
name string
var p_person = new(Person)
fmt.Printf("p_person: %T\\n", p_person)
访问结构体指针成员
访问结构体指针成员，也使用点运算符(.)，例如：
package main
import "fmt"
func main()
type Person struct
id int
name string
var p_person = new(Person)
fmt.Printf("p_person: %T\\n", p_person)
p_person.id = 1
p_person.name = "tom"
fmt.Printf("*p_person: %v\\n", *p_person)
结构体作为函数参数
定义
go结构体可以像普通变量一样，作为函数的参数，传递给函数，这里分为两种情况：
- 直接传递结构体，这是是一个副本（拷贝），在函数内部不会改变外面结构体内容。
- 传递结构体指针，这时在函数内部，能够改变外部结构体内容。
直接传递结构体
package main
import "fmt"
type Person struct
id int
name string
func showPerson(person Person)
person.id = 1
person.name = "kite"
fmt.Printf("person: %v\\n", person)
func main()
person := Person1, "tom"
fmt.Printf("person: %v\\n", person)
fmt.Println("----------------")
showPerson(person)
fmt.Println("----------------")
fmt.Printf("person: %v\\n", person)
运行结果：
person: 1 tom
----------------
person: 1 kite
----------------
person: 1 tom
从运行结果可以看出，函数内部改变了结构体内容，函数外面并没有被改变。
传递结构体指针
package main
import "fmt"
type Person struct
id int
name string
func showPerson(person *Person)
person.id = 1
person.name = "kite"
fmt.Printf("person: %v\\n", person)
func main()
person := Person1, "tom"
fmt.Printf("person: %v\\n", person)
fmt.Println("----------------")
showPerson(&person)
fmt.Println("----------------")
fmt.Printf("person: %v\\n", person)
运行结果
person: 1 tom
----------------
person: &1 kite
----------------
person: 1 kite
从运行结果，我们可以看到，调用函数后，参数被改变了。
嵌套结构体
go语言没有面向对象编程思想，也没有继承关系，但是可以通过结构体嵌套来实现这种效果。
下面通过实例演示如何实现结构体嵌套，加入有一个人Person结构体，这个人还养了一个宠物Dog结构体。
下面我们来看一下：
Dog结构体
type Dog struct
name string
color string
age int
Person结构体
type person struct
dog Dog
name string
age int
package main
import "fmt"
type Dog struct
name string
color string
age int
type person struct
dog Dog
name string
age int
访问它们
func main()
var tom person
tom.dog.name = "花花"
tom.dog.color = "黑白花"
tom.dog.age = 2
tom.name = "tom"
tom.age = 20
fmt.Printf("tom: %v\\n", tom)
运行结果
tom: 花花 黑白花 2 tom 20
golang继承
golang本质上没有oop的概念，也没有继承的概念，但是可以通过结构体嵌套实现这个特性。
package main
import "fmt"
type Animal struct
name string
age int
func (a Animal) eat()
fmt.Println("eat...")
func (a Animal) sleep()
fmt.Println("sleep")
type Dog struct
Animal
type Cat struct
Animal
func main()
dog := Dog
Animal
name: "dog",
age: 2,
,
cat := Cat
Animalname: "cat",
age: 3,
dog.eat()
dog.sleep()
cat.eat()
cat.sleep()
golang构造函数
golang没有构造函数的概念，可以使用函数来模拟构造函数的的功能。
例如
package main
import "fmt"
type Person struct
name string
age int
func NewPerson(name string, age int) (*Person, error)
if name == ""
return nil, fmt.Errorf("name 不能为空")
if age < 0
return nil, fmt.Errorf("age 不能小于0")
return &Personname: name, age: age, nil
func main()
person, err := NewPerson("tom", 20)
if err == nil
fmt.Printf("person: %v\\n", *person)
本篇文章借鉴https://blog.csdn.net/geek99_guo/article/details/121752993?spm=1001.2014.3001.5502写的，如有不对可以评论留言
go语言学习之旅--结构体(代码片段)
结构体go语言类型定义go语言类型别名go语言类型定义和类型别名的区别结构体go语言结构体的定义声明一个结构体变量结构体的初始化访问结构体成员匿名结构体结构体指针举例使用new关键字创建结构体指针访问结构体指针成员... 查看详情
go语言学习笔记十：结构体(代码片段)
Go语言学习笔记十：结构体Go语言的结构体语法和C语言类似。而结构体这个概念就类似高级语言Java中的类。结构体定义结构体有两个关键字type和struct，中间夹着一个结构体名称。大括号里面写上所有的成员变量，并且指定这些... 查看详情
go语言结构体(代码片段)
Go语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。Go语言结构体与C语言相似伪代码如下参考：定义结构体typestruct_variable_typestructmemberdefinitionmemberdefinition...memberdefinition实例... 查看详情
go语言结构体(代码片段)
文章目录一、Go语言结构体二、结构体的实例化三、初始化结构体成员方法四、模拟构造函数五、Go语言方法和接收器5.1基础概念5.2为结构体添加方法六、为任意类型添加方法七、Go语言使用事件系统实现事件的响应和处理7.1基础... 查看详情
go语言学习-结构体(代码片段)
结构体go语言中的结构体，是一种复合类型，有一组属性构成，这些属性被称为字段。结构体也是值类型，可以使用new来创建。定义:typenamestructfield1type1field2type2...我们可以看到每一个字段都由一个名字和一个类型构成，不过实际... 查看详情
go语言学习笔记—基础—复合数据类型—结构体：定义结构体(代码片段)
go通过自定义的方式形成新的类型，结构体是类型中带有成员的复合类型。go使用结构体和结构体成员，描述真实世界的实体和实体对应的各种属性。go中的类型可以被实例化。使用new或&得到类型实例，其类型是对... 查看详情
go语言基础：结构体(代码片段)
文章目录结构体类型别名和自定义类型自定义类型类型别名类型定义和类型别名的区别结构体结构体的定义结构体实例化基本实例化匿名结构体创建指针类型结构体取结构体的地址实例化结构体初始化使用键值对初始化结构体内... 查看详情
go语言基础：结构体(代码片段)
文章目录结构体类型别名和自定义类型自定义类型类型别名类型定义和类型别名的区别结构体结构体的定义结构体实例化基本实例化匿名结构体创建指针类型结构体取结构体的地址实例化结构体初始化使用键值对初始化结构体内... 查看详情
go语言结构体(代码片段)
文章目录一、Go语言结构体二、结构体的实例化三、初始化结构体成员方法四、模拟构造函数五、Go语言方法和接收器5.1基础概念5.2为结构体添加方法六、为任意类型添加方法七、Go语言使用事件系统实现事件的响应和处理7.1基础... 查看详情
go语言学习笔记—基础—复合数据类型—结构体：结构体方法（行为）(代码片段)
go中的方法是一种作用于特定类型变量（也即接收器receiver）的函数。如果把特定类型理解为结构体或类时，接收器receiver类似于python中的self。在go中，接收器receiver可以是任何类型和结构体；任何类型都可以拥... 查看详情
go基础结构体方法封装结构体内嵌接口(代码片段)
结构体、方法封装、结构体内嵌、接口结构体、方法封装、结构体内嵌、接口结构体定义结构体结构体变量的声明、赋值方法封装结构体的组合与内嵌组合内嵌（即：继承）接口相关资料结构体定义结构体在很多语言... 查看详情
go语言结构体(代码片段)
typeFeedstruct Namestring`json:"site"`URIstring`json:"link"`Typestring`json:"type"```里面的部分被称为标记（tag)标记描述了JSON解码的元数据，用于创建Feed类型值的 查看详情
go语言结构体(代码片段)
typeFeedstruct Namestring`json:"site"`URIstring`json:"link"`Typestring`json:"type"```里面的部分被称为标记（tag)标记描述了JSON解码的元数据，用于创建Feed类型值的切片 查看详情
go语言--第6章结构体(代码片段)
第6章结构体（struct）Go语言通过自定义的方式形成新的类型结构体是类型中带有成员的复合类型，使用结构体和结构体成员描述真实世界的实体和实体对应的各种属性Go语言中类型可以被实例化，使用new或&构造的类型实... 查看详情
go语言基础函数，数组，指针，结构体(代码片段)
...指针的使用空指针指针数组将指针传入函数进行值的交换结构体自定义类型和类型别名结构体初始化匿名结构体结构体的内存布局结构体内存对齐各变量类型所占用空间结构体内存对齐构 查看详情
go语言之struct结构体(代码片段)
struct结构Go中的struct与C语言中的struct非常相似，并且Go没有class使用type<Name>struct定义结构，名称遵循可见性规则支持指向自身的指针类型成员支持匿名结构，可用作成员或定义成员变量匿名结构也可以用于map的值可以使用字... 查看详情
go语言学习之旅--初识golang(代码片段)
Go语言简介特点编码风格Go安装测试Go（又称Golang）是Google的RobertGriesemer，RobPike及KenThompson开发的一种静态强类型、编译型语言。Go语言语法与C相近，但功能上有：内存安全，GC（垃圾回收），结... 查看详情
go语言学习笔记—基础—复合数据类型—结构体：使用匿名结构体分离json数据(代码片段)
手机拥有屏幕、电池、指纹识别等信息，把这些信息填充为json格式的数据。如果需要选择性地分离json中的数据较麻烦，但使用go的匿名结构体可以方便实现。json数据分离packagemainimport( "encoding/json" "fmt" "test... 查看详情