Go基础编程：结构体

时间  2020-12-08
标签 编程 json segmentfault 函数 测试 指针 code orm 对象 继承 栏目 JavaScript 繁體版
原文   原文链接

结构体(struct)是自定义方式造成新的数据类型，结构体是类型中带有成员的复合类型。Go 语言结构体是一种聚合的数据类型，是由零个或多个任意类型的值聚合成的实体。每一个值称为结构体的成员。来描述真实世界的实体和实体对应的各类属性。编程

结构体属性也叫字段或成员,每一个字段都有名称和类型，每一个名称是惟一的。能够是任何类型，如普通类型、复合类型、函数、map、interface、struct等，因此咱们能够理解为go语言中的“类”。json

定义

结构体定义方式以下：segmentfault

type name struct{
     fieldName1 type1
     fieldName2 type2
     ...
}

以下，定义User 结构体：函数

type User struct {
     Name string
     age  int
}

实例化测试

上面定义只是类型，就想是一个int同样，须要定义一个类型变量才可使用，相似Java的类。指针

直接定义变量使用code

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>
}

定义默认成员变量orm

var user1 = User{Name: "abc"}
fmt.Println(user1)

func NewUser() *User {
    return &User{Name:"abc",age:20}
}

使用内建函数new()分配内存返回类型变量指针对象

var user = new(User)
fmt.Println(user) //&{ 0}

访问成员继承

使用.来访问

var user User
user.Name = "abc"
user.age = 20
fmt.Println(user) //{abc 20}

首字母大小写问题，成员大写表示包外可见（即面向对象的公有属性),小写包外不可见

零值：结构体的零值是nil

初始值:结构体的初始值是非nil时，各成员对应类型的初始值

空结构体:空结构体就是没有字段的结构体，空结构体不占内存

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
}

从上面能够看出空结构体内存地址和大小都是同样的。根据这个特性，使用空结构体能够做为信号量，起到信号做用但不占内存。如空结构体类型的chan

匿名结构体

匿名结构体没有类型名称，无须经过 type 关键字定义就能够直接使用。

user := struct {
     Name string
 }{Name: "abc"}
fmt.Println(user) //{abc}

比较

若是结构体的所有成员都是能够比较的，且成员的顺序、类型、数量彻底同样才能够比较，两个结构体将可使用==或!=运算符进行比较。

package main
​
import (
    "fmt"
)
​
func main() {
     user1 := struct {
     Name string
     }{Name: "abc"}
     user2 := struct {
     Name string
     }{Name: "abc"}
     fmt.Println(user1 == user2) //true
}

成员名称不同

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 })
}

成员数量不同

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 })
}

成员类型不能比较

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)
}

顺序不同

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 })
}

其实整个结构体就是一个类型（如int)，成员顺序、类型这些不同，总体的结构体就不同，故对于强类型语言来讲就是不能比较的，对应类型彻底同样还须要注意成员是不是能够比较，如slice、map等

Go语言没有面向对象这个概念，但能够把结构体看作是一个类，能够实现面向对象的特性，如经过组合和嵌入实现继承

匿名字段

匿名字段是结构体没有显示的名字，是结构体嵌入一个或多个结构体，以下面

B直接嵌入A ，B是匿名字段

package main
​
import (
    "fmt"
)
​
type A struct {
     Name string
     B
}
type B struct {
     Age int
     Name string
}

访问成员变量

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 
}

只有一个成员名称的状况下，Go语法糖能够省略嵌入结构体

fmt.Println(a.B.Age) //20
fmt.Println(a.Age)   //20

对应有多个相同名称的成员，不能省略，由于编译器不知道是哪一个

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
}

正确作法是

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
}

组合

上面是没有名字的嵌入结构体，还能够给嵌入结构体命名,访问必需要带上具体的字段，不能省略。

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)
}

标签

以下面在字段后面用`` 包起来的是标签，主要是经过反射来序列化和反序列化，具体由反射章节来说。

type User struct {
 Id int `json:"id"`
 Account string `json:"account" form:"account"`
 Nickname string `gorm:"nickname" json:"nickname" form:"nickname"`
}

方法

方法通常都是面向对象编程(OOP)的一个特性，Go语言的方法其实与一个值或变量关联的特殊的函数。这个值或变量叫作接收者

func ([typeName] 接收者) name (param) [return]{}

接收者是自定义的类型

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()
}

接收者不能直接用内置类型

func (c int) show()  {  //cannot define new methods on non-local type int
    fmt.Println("b............")
}

接收者值能够是值类型或指针类型

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()
}

对与B来讲,下面两种调用方式是等价的，本质上他们都是同样的，b.show()的写法是省略了(&b),只不过由语法糖来补全

func main() {
     var b  B
     b.show()
     (&b).show()
}

方法能够访问接收者自身的信息，以下

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() //测试
}

值类型接收者拷贝类型的所有，修改不会影响原数据;指针拷贝的是地址，修改会影响原数据

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()
}

接受者类型自己不能为指针

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............")
}

方法的参数和返回值这些和函数同样，具体看函数章节

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程