Go 语言之 struct 结构体-原创手记-慕课网

struct 结构

Go中的struct与C语言中的struct非常相似，并且Go没有class

使用type<Name> struct{} 定义结构，名称遵循可见性规则

支持指向自身的指针类型成员

支持匿名结构，可用作成员或定义成员变量

匿名结构也可以用于map的值

可以使用字面值对结构进行初始化

允许直接通过指针来读写结构成员

相同类型的成员可以进行直接拷贝赋值

支持== 与 != 比较运算符，但不支持 > 或 <

支持匿名字段，本质上是定义了以某个类型名为名称的字段

嵌入结构作为匿名字段看起来像继承，但不是继承

可以使用匿名字段指针

测试用例

package main

import "fmt"

//定义了一个空的结构体

type st01 struct {

}

//定义一个非空的结构体

type person struct {

Name string

Age int

}

func main() {

personInfo := person{}

personInfo.Age = 19

personInfo.Name = "xiaoqiang"

fmt.Println(personInfo)

//------------------------------

fmt.Println("=============================")

//直接初始化属于字面值初始化

personInfo2 := person{Name :"spark01", Age: 19}

fmt.Println(personInfo2)

}

结构体，按值传递

//结构体，按值传递

package main

import "fmt"

//定义一个类型

type sparkInfo struct {

SparkClusterName string

SparkNodeNum int

}

func main() {

newSparkInfo := sparkInfo{

SparkNodeNum: 8,

SparkClusterName: "spark-test-001"}

fmt.Println("main:\t", newSparkInfo)

updateSparkInfo(newSparkInfo)

fmt.Println("main:\t", newSparkInfo)

}

//同样，这里是值传递，内部的修改，并不会影响到旧值的

func updateSparkInfo(sparkInfo sparkInfo) {

sparkInfo.SparkNodeNum = 9

fmt.Println("updateSparkInfo:\t", sparkInfo)

}

结构体，按地址传递

//结构体，按地址传递

package main

import "fmt"

type k8sInfo struct {

K8sClusterName string //k8s集群的名称

K8sClusterNumm int //k8s集群的节点个数

}

func main() {

k8sInfo := k8sInfo{

K8sClusterNumm: 1,

K8sClusterName: "k8s-test-001"}

fmt.Println(k8sInfo)

updateK8sClusterInfo(&k8sInfo)

fmt.Println(k8sInfo)

}

//传递的是地址，按地址传递

//修改了，旧的值

func updateK8sClusterInfo(info *k8sInfo) {

info.K8sClusterNumm = 110

fmt.Println("updateK8s:\t", info)

}

结构体，按地址传递

//结构体，按地址传递

package main

import "fmt"

type dockerInfo struct {

DockerClusterName string

DockerClusterNum int

}

func main() {

//一般更习惯这种写法，

//在初始化的时候，就直接获取地址

//这样以后在调用的时候，就不需要添加&号了

dInfo := &dockerInfo{

DockerClusterNum:19,

DockerClusterName:"docker-yizhuang"}

fmt.Println("init docker:\t", dInfo)

updateDockerInfo(dInfo)

fmt.Println("after docker:\t", *dInfo)

}

func updateDockerInfo (info *dockerInfo) {

info.DockerClusterNum = 80

fmt.Println("udpateDocker:\t", info)

}

匿名结构

//匿名结构

package main

import "fmt"

func main() {

//创建一个匿名结构，

//并且进行了初始化

//而且，直接获取地址&

ftp := &struct {

FtpName string

FtpNum int

}{

FtpName:"ftp-beijing",

FtpNum:8}

fmt.Println(ftp)

fmt.Println(*ftp)

fmt.Println("FtpName:\t", ftp.FtpName)

fmt.Println("FtpNum:\t", ftp.FtpNum)

}

匿名结构, 嵌套进别的结构体里

//将匿名结构，嵌套进别的结构体里

package main

import "fmt"

type hadoop struct {

HadoopClusterName string

HadoopClusterNum int

//创建一个匿名结构

HadoopOtherInfo struct {

//同样，当多个变量都一样的时候，也可用省略

//这是Go语言的优点

HadoopVersion, HadoopUrl string

}

func main() {

hdfs := &hadoop{

HadoopClusterName: "Hadoop-test-001",

HadoopClusterNum: 9}

//只能通过这种方式，进行初始化

hdfs.HadoopOtherInfo.HadoopUrl = "http://192.168.1.110:50070"

hdfs.HadoopOtherInfo.HadoopVersion = "v2.7.0"

fmt.Println(hdfs)

fmt.Println(*hdfs)

fmt.Println("HadoopClusterName:\t", hdfs.HadoopClusterName)

fmt.Println("HadoopClusterNum:\t", hdfs.HadoopClusterNum)

fmt.Println("HadoopClusterVersion:\t", hdfs.HadoopOtherInfo.HadoopVersion)

fmt.Println("HadoopClusterUrl:\t", hdfs.HadoopOtherInfo.HadoopUrl)

}

匿名字段

//匿名字段测试

package main

import "fmt"

type students struct {

//这些就是匿名字段，没有定义名字

string

int

}

func main() {

boy := &students{

//初始化的时候，必须按照顺序来进行的

"xiaoqiang", 19}

fmt.Println(boy)

}

相同结构体之间操作，如赋值，比较

// 相同结构体之间操作，如赋值，比较

package main

import "fmt"

type teacherA struct {

string

int

}

type teacherB struct {

string

int

}

func main() {

boyTeacherA := teacherA{"xiaoli",22}

//boyTeacherB := teacherB{"xiaoli",22}

//説明：编译报错了，teacherA, teacherB 类型不相同，不能进行比较的

//fmt.Println(boyTeacherA == boyTeacherB)

boyTeacherB := teacherA{"xiaoli", 23}

fmt.Println(boyTeacherB == boyTeacherA)

}

结构体，实现类似于继承的效果

//结构体，实现类似于继承的效果

package main

import "fmt"

type anminal struct {

//设置一些共有的属性

Name, address string

}

type cat struct {

//anminal Go 语言，默认，anminal是类型，同时也是属性名称

anminal

Sex int // 猫的特有属性，性别是啥

}

type dog struct {

anminal

Hobby string //狗的特有属性，爱好

}

func main() {

//第一种初始化方式

xiaoCat := cat{Sex:0, anminal : anminal{Name:"xiaohong", address:"beijing"}}

xiaoDog := dog{Hobby:"play", anminal:anminal{Name:"xiaohuang", address:"shanghai"}}

//第二种初始化方式

xiaoCat.anminal.Name = "xiaoxiaoxiaohong" //这种方式，是为了防止名字相同时，冲突

xiaoCat.Name = "xiaoxiaohong"

fmt.Println("cat:\t", xiaoCat)

fmt.Println("dog:\t",xiaoDog)

}

struct里含有匿名函数

package main

import "fmt"

type annimal2 struct {

name string

// 这种形式，也是可以的

//有点类似于接口中定义方法

show func()

}

func main() {

dog := annimal2{name:"xiaohuang",

show: func() {

fmt.Println("this is xiaohuang")

}

dog.show()

cat:= annimal2{name:"xiaohong",

show: func() {

fmt.Println("this is xiaohong")

}

cat.show()

}

运行结果：

this is xiaohuang

this is xiaohong

Process finished with exit code 0