为了账号安全,请及时绑定邮箱和手机立即绑定

Go 语言之 struct 结构体

标签:
Go


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

©著作权归作者所有:来自51CTO博客作者故新的原创作品,如需转载,请注明出处,否则将追究法律责任


点击查看更多内容
TA 点赞

若觉得本文不错,就分享一下吧!

评论

作者其他优质文章

正在加载中
  • 推荐
  • 评论
  • 收藏
  • 共同学习,写下你的评论
感谢您的支持,我会继续努力的~
扫码打赏,你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫,即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消