Go语言之struct结构体
struct 结构
- Go中的struct与C语言中的struct非常相似，并且Go没有class
- 使用type
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网站标题：Go语言之struct结构体
文章URL：http://scyanting.com/article/pehooc.html
