go结构体

1.定义结构体
package main

import (
“fmt”
)

type test struct {
}

func main() {
a := test{}
fmt.Println(a)
}
输出：{}
package main

import (
“fmt”
)

//定义一个person结构，类似于在PHP定义了一个person的class
type Person struct {
name string //默认零值为空字符串
age int //默认零值为0
}

func main() {
a := Person{}
fmt.Println(a)
}
输出：{ 0}
定义结构体的三种方式：
var p Person //直接在内存中定义一个结构体变量
p := new (Person) //定义一个结构体指针
p := &Person{} //定义一个结构体指针
结构体是值类型，需要使用new分配内存
2.访问结构体成员
package main

import (
“fmt”
)

//定义一个person结构，类似于在PHP定义了一个person的class
type Person struct {
name string //默认零值为空字符串
age int //默认零值为0
}

func main() {
a := Person{}
//对Person进行属性操作，类似于javascript的操作
a.name = “GO”
a.age = 8
fmt.Println(a)
}
3.字面量初始化
package main

import (
“fmt”
)

//定义一个person结构，类似于在PHP定义了一个person的class
type Person struct {
name string //默认零值为空字符串
age int //默认零值为0
}

func main() {
//也可以通过字面值进行初始化，这是常用的做法，写法类似于JSON的写法
a := Person{
name: “GO”,
age: 8} //注意，如果没有逗号，则}不能另起新行，否则会报错
fmt.Println(a)
}
输出：{GO 8}
4.结构体作为函数的参数
package main

import (
“fmt”
)

//定义一个person结构，类似于在PHP定义了一个person的class
type person struct {
name string //默认零值为空字符串
age int //默认零值为0
}

func main() {
//也可以通过字面值进行初始化，这是常用的做法，写法类似于JSON的写法 ，注意属性名不能加分号
a := person{
name: “GO”,
age: 8} //注意，如果没有逗号，则}不能另起新行，否则会报错
fmt.Println(“我在A前面输出”, a)
A(a) //A(&a)就是值传递，A函数应写成func A(per *person)
fmt.Println(“我在A后面输出”, a)//很显然,A里面的赋值并没有改变a的值，证明结构是值类型，传值是值拷贝
}

//结构也是值类型，传值的时候也是值拷贝
func A(per person) { //传递per参数，类型为person结构
per.name = “PHP”
fmt.Println(“我在A里面输出”, per)

}
输出：
我在A前面输出 {GO 8}
我在A里面输出 {PHP 8}
我在A后面输出 {GO 8}
5.结构体指针作为函数参数
package main

import (
“fmt”
)

//定义一个person结构，类似于在PHP定义了一个person的class
type person struct {
name string //默认零值为空字符串
age int //默认零值为0
}

func main() {
//如何传递指针
a := &person{ //变量初始化时，加&取地址
name: “GO”,
age: 8} //注意，如果没有逗号，则}不能另起新行，否则会报错
//当传地址的时候，想操作属性时，Go语言可以不需要加*，直接操作
a.age = 9
fmt.Println(“我在A前面输出”, a)
A(a)
fmt.Println(“我在A后面输出”, a) //很显然,A里面的赋值并没有改变a的值，证明结构是值类型，传值是值拷贝
}

//结构也是值类型，传值的时候也是值拷贝
func A(per *person) { //此时为指针类型
per.name = “PHP”
fmt.Println(“我在A里面输出”, per)
}
输出：
我在A前面输出 &{GO 9}
我在A里面输出 &{PHP 9}
我在A后面输出 &{PHP 9}
6.匿名结构体
package main

import (
“fmt”
)

//匿名结构
定义匿名结构体时没有 type 关键字，与其他定义类型的变量一样，如果在函数外部需在结构体变量前加上 var 关键字，在函数内部可省略 var 关键字。
func main() {
a := &struct {
name string
age int
}{
name: “PHP”,
age: 10,
} //定义匿名结构体并且初始化
fmt.Println(a) //很显然,A里面的赋值并没有改变a的值，证明结构是值类型，传值是值拷贝
}
输出：
&{PHP 10}
7，结构体嵌套
package main

import (
“fmt”
)

//结构嵌套
type person struct {
name string
age int
contact struct {
phone, city string
}
}

func main() {
a := person{name: “GO”, age: 8}
a.contact.phone = “1112345678”
a.contact.city = “福州”
fmt.Println(a)
}
输出：
{GO 8 {1112345678 福州}}
8.结构体匿名字段
package main

import (
“fmt”
)

//匿名字段
type person struct {
string
int
}

func main() {
a := person{“GO”, 8} //注意这里的位置不能对调，应与声明的顺序一样
fmt.Println(a)
}
9.结构体之间的比较
结构体之间的比较(不同结构，没有可比性，会报错，哪怕属性值和属性都一样)
只有相同结构的结构体才可以进行比较，也就是说两个结构体变量必须来自同一个结构体定义。结构体之间也可以赋值。
10.结构体之间的“继承“（注意：Go并没有面向对象语言的继承关系，如PHP）
package main

import (
“fmt”
)

type human struct {
sex int
}

type teacher struct {
human
name string
age int
}

type student struct {
human
name string
age int
}

func main() {
a := teacher{name: “PHP”, age: 15, human: human{sex: 0}} //嵌入结构作为匿名字段时，默认字段名就是嵌入的结果名
b := student{name: “GO”, age: 8, human: human{sex: 1}}
a.name = “PYTHON”
b.sex = 0 //如果是嵌入结构，则把原来的字段全部拷贝过来到现在的结构里了，操作字段时无需写成b.human.sex
fmt.Println(a, b)
}

输出：
{{0} PYTHON 15} {{0} GO 8}