Go基础编程：结构体
结构体(struct)是自定义方式形成新的数据类型，结构体是类型中带有成员的复合类型。Go 语言结构体是一种聚合的数据类型，是由零个或多个任意类型的值聚合成的实体。每个值称为结构体的成员。来描述真实世界的实体和实体对应的各种属性。
结构体属性也叫<code>字段</code>或<code>成员</code>,每个字段都有名称和类型，每个名称是唯一的。可以是任何类型，如普通类型、复合类型、函数、map、interface、struct等，所以我们可以理解为go语言中的“类”。
<h4>定义</h4>结构体定义方式如下：
<pre><code class="lang-go hljs">type name struct{ fieldName1 type1 fieldName2 type2 ... }</code></code></pre>如下，定义User 结构体：
<pre><code class="lang-go hljs">type User struct { Name string age int }</code></code></pre>实例化
上面定义只是类型，就想是一个<code>int</code>一样，需要定义一个类型变量才可以使用，类似Java的类。
直接定义变量使用
<pre><code class="lang-go hljs">package main import ( "fmt" ) type User struct { Name string age int } func main() { var user1 User //定义User 类型变量user var user2 *User //类型指针，未分配内存，不能直接使用 fmt.Println(user1, user2) //{ 0} <nil> }</code></code></pre>定义默认成员变量
<pre><code class="lang-go hljs">var user1 = User{Name: "abc"} fmt.Println(user1) func NewUser() *User { return &User{Name:"abc",age:20} }</code></code></pre>使用内建函数<code>new()</code>分配内存返回类型变量指针
<pre><code class="lang-go hljs">var user = new(User) fmt.Println(user) //&{ 0}</code></code></pre>访问成员
使用<code>.</code>来访问
<pre><code class="lang-go hljs">var user User user.Name = "abc" user.age = 20 fmt.Println(user) //{abc 20}</code></code></pre>首字母大小写问题，成员大写表示包外可见（即面向对象的公有属性),小写包外不可见
零值：结构体的零值是<code>nil</code>
初始值:结构体的初始值是非<code>nil</code>时，各成员对应类型的初始值
空结构体:空结构体就是没有字段的结构体，空结构体不占内存
<pre><code class="lang-go hljs">package main import ( "fmt" "unsafe" ) func main() { user1 := struct{}{} user2 := struct{}{} fmt.Printf("%p,%dn", &user1, unsafe.Sizeof(user1)) //0x585218,0 fmt.Printf("%p,%dn", &user2, unsafe.Sizeof(user2)) //0x585218,0 }</code></code></pre>从上面可以看出空结构体内存地址和大小都是一样的。根据这个特性，使用空结构体可以作为信号量，起到信号作用但不占内存。如空结构体类型的<code>chan</code>
匿名结构体
匿名结构体没有类型名称，无须通过 type 关键字定义就可以直接使用。
<pre><code class="lang-go hljs">user := struct { Name string }{Name: "abc"} fmt.Println(user) //{abc}</code></code></pre>比较
如果结构体的全部成员都是<code>可以比较</code>的，且成员的<code>顺序</code>、<code>类型</code>、<code>数量</code>完全一样才可以比较，两个结构体将可以使用==或!=运算符进行比较。
<pre><code class="lang-go hljs">package main import ( "fmt" ) func main() { user1 := struct { Name string }{Name: "abc"} user2 := struct { Name string }{Name: "abc"} fmt.Println(user1 == user2) //true }</code></code></pre>成员名称不一样
<pre><code class="lang-go hljs">package main import ( "fmt" ) func main() { user1 := struct { Name string }{Name: "abc"} user2 := struct { name string }{name: "abc"} fmt.Println(user1 == user2) //invalid operation: user1 == user2 (mismatched types struct { Name string } and struct { name string }) }</code></code></pre>成员数量不一样
<pre><code class="lang-go hljs">package main import ( "fmt" ) func main() { user1 := struct { Name string }{Name: "abc"} user2 := struct { Name string age int }{Name: "abc"} fmt.Println(user1 == user2) //invalid operation: user1 == user2 (mismatched types struct { Name string } and struct { Name string; age int }) }</code></code></pre>成员类型不能比较
<pre><code class="lang-go hljs">package main import ( "fmt" ) func main() { user1 := struct { Name string m map[int]int }{Name: "abc"} user2 := struct { Name string m map[int]int }{Name: "abc"} fmt.Println(user1 == user2) //invalid operation: user1 == user2 (struct containing map[int]int cannot be compared) }</code></code></pre>顺序不一样
<pre><code class="lang-go hljs">package main import ( "fmt" ) func main() { user1 := struct { Name string age int }{Name: "abc"} user2 := struct { age int Name string }{Name: "abc"} fmt.Println(user1 == user2) //invalid operation: user1 == user2 (mismatched types struct { Name string; age int } and struct { age int; Name string }) }</code></code></pre>其实整个结构体就是一个类型（如int)，成员顺序、类型这些不一样，整体的结构体就不一样，故对于强类型语言来说就是不能比较的，对应类型完全一样还需要注意成员是否是可以比较，如slice、map等
Go语言没有面向对象这个概念，但可以把结构体看做是一个类，可以实现面向对象的特性，如通过组合和嵌入实现继承
匿名字段
匿名字段是结构体没有显示的名字，是结构体嵌入一个或多个结构体，如下面
B直接嵌入A ，B是匿名字段
<pre><code class="lang-go hljs">package main import ( "fmt" ) type A struct { Name string B } type B struct { Age int Name string } </code></code></pre>访问成员变量
<pre><code class="lang-go hljs">func main() { var a = A{Name:"a",B:B{Name:"b",Age:20}} fmt.Printf("%#vn", a) //main.A{Name:"", B:main.B{Age:0}} fmt.Println(a.Name) //a fmt.Println(a.B.Name) //b fmt.Println(a.Age) //20 }</code></code></pre>只有一个成员名称的情况下，Go语法糖可以省略嵌入结构体
<pre><code class="lang-go hljs">fmt.Println(a.B.Age) //20 fmt.Println(a.Age) //20</code></code></pre>对应有多个相同名称的成员，不能省略，因为编译器不知道是哪个
<pre><code class="lang-go hljs">type C struct { A B } func main() { var c = C{A:A{Name:"a"},B:B{Name:"b",Age:20}} fmt.Println(c.Name) //ambiguous selector c.Name }</code></code></pre>正确做法是
<pre><code class="lang-go hljs">func main() { var c = C{A:A{Name:"a"},B:B{Name:"b",Age:20}} fmt.Println(c.A.Name) //a fmt.Println(c.B.Name) //b }</code></code></pre><h4>组合</h4>上面是没有名字的嵌入结构体，还可以给嵌入结构体命名,访问必须要带上具体的字段，不能省略。
<pre><code class="lang-go hljs">package main import ( "fmt" ) type A struct { Btype B } type B struct { Age int Name string } func main() { var a = A{Btype:B{Name:"b",Age:20}} fmt.Println(a.Name) //.Name undefined (type A has no field or method Name) } </code></code></pre><h4>标签</h4>如下面在字段后面用`` 包起来的是标签，主要是通过反射来序列化和反序列化，具体由反射章节来讲。
<pre><code class="lang-go hljs">type User struct { Id int `json:"id"` Account string `json:"account" form:"account"` Nickname string `gorm:"nickname" json:"nickname" form:"nickname"` }</code></code></pre><h4>方法</h4>方法一般都是面向对象编程(OOP)的一个特性，Go语言的方法其实与一个值或变量关联的特殊的函数。这个值或变量叫做<code>接收者</code>
<pre><code class="lang-go hljs">func ([typeName] 接收者) name (param) [return]{}</code></code></pre>接收者是自定义的类型
<pre><code class="lang-go hljs">package main import ( "fmt" ) type A struct {} //结构体 type B int //int func (a A) show() { fmt.Println("a............") } func (b B) show() { fmt.Println("b............") } func main() { var a A var b B a.show() b.show() }</code></code></pre>接收者不能直接用内置类型
<pre><code class="lang-go hljs">func (c int) show() { //cannot define new methods on non-local type int fmt.Println("b............") }</code></code></pre>接收者<code>值</code>可以是值类型或指针类型
<pre><code class="lang-go hljs">package main import ( "fmt" ) type A struct {} type B struct {} func (a A) show() { //值类型 fmt.Println("a............") } func (b *B) show() { //指针类型 fmt.Println("b............") } func main() { var a A var b B a.show() b.show() }</code></code></pre>对与<code>B</code>来说,下面两种调用方式是等价的，本质上他们都是一样的，<code>b.show()</code>的写法是省略了<code>(&b)</code>,只不过由语法糖来补全
<pre><code class="lang-go hljs">func main() { var b B b.show() (&b).show() }</code></code></pre>方法可以访问接收者自身的信息，如下
<pre><code class="lang-go hljs">package main import ( "fmt" ) type User struct { Id int Account string Nickname string } func (u User)show() { fmt.Println(u.Nickname) } func main() { var a = User{Nickname:"测试"} a.show() //测试 }</code></code></pre>值类型接收者拷贝类型的全部，修改<code>不会</code>影响原数据;指针拷贝的是地址，修改<code>会</code>影响原数据
<pre><code class="lang-go hljs">package main import ( "fmt" ) type User struct { Id int Account string Nickname string } func (u User)show() { fmt.Println(u) } func (u User)setName1() { u.Nickname="值类型" } func (u *User)setName2() { u.Nickname="指针类型" } func main() { var a = User{Nickname:"测试"} a.setName1() a.show() a.setName2() a.show() }</code></code></pre>接受者<code>类型</code>本身不能为指针
<pre><code class="lang-go hljs">package main import ( "fmt" ) type A int type B *int //变量类型为指针 func (a A) show() { fmt.Println("a............") } func (b B) show() { //invalid receiver type B (B is a pointer type) fmt.Println("b............") }</code></code></pre>方法的参数和返回值这些和函数一样，具体看函数章节
到此这篇关于“Go基础编程：结构体”的文章就介绍到这了,更多文章或继续浏览下面的相关文章，希望大家以后多多支持JQ教程网！
您可能感兴趣的文章：
Go 零基础编程入门教程
GO语言零基础从入门到精通视频教程
golang基础教程
2018年最全Go语言教程零基础入门到进阶实战视频
Golang笔记：语法，并发思想，web开发，Go微服务相关
想系统学习GO语言(Golang
应用编程基础课第三讲：Go编程基础
Go语言发展历史、核心、特性及学习路线
【Go语言入门系列】（八）Go语言是不是面向对象语言？
从零开始学习GO语言-搭建Go语言开发环境-快速开发入门第一个小程序