Golang学习笔记之结构体(struct)

1//包内使用首字母小写，包外使用首字母大写
2type employee struct {
3    firstName string
4    lastName  string
5    age       int
6}

 1//初始化方式1
 2    var emp1 employee
 3    emp1.firstName = "hello"
 4    emp1.lastName = "world"
 5    emp1.age = 20
 6    fmt.Println(emp1)
 7
 8    //初始化方式2利用键值方式
 9    emp2 := employee{
10        firstName: "Sam",
11        age:       25,
12        lastName:  "Anderson", //使用键值方式这个逗号不可以省略
13    }
14    fmt.Println(emp2)
15
16    //初始化方式3顺序初始化,必须包含全部字段，否则会出错。
17    emp3 := employee{"Thomas", "Paul", 29}
18    fmt.Println(emp3)

 1//匿名结构，可⽤作结构成员或定义变量。
 2type file struct {
 3    name string
 4    size int
 5    attr struct {
 6        perm  int
 7        owner int
 8    }
 9}
10
11func main() {
12//匿名结构
13    f := file{
14        name: "test.txt",
15        size: 1025,
16        // attr: {0755, 1}, //组合文字中缺少类型
17    }
18    f.attr.owner = 1
19    f.attr.perm = 0755
20    var attr = struct {
21        perm  int
22        owner int
23    }{2, 0755}
24    f.attr = attr
25    fmt.Println(f.attr.perm)
26}

 1//匿名字段
 2type person struct {
 3    string
 4    int
 5    employee
 6}
 7func main(){
 8    //匿名字段会把类型用作变量名
 9    p := person{"Hello", 20, emp1}
10    p.string = "Other"
11    fmt.Println(p, p.string) //{Other 20} Other
12    fmt.Println(p.lastName)//等价于p.employee.lastName//输出：hello
13}

 1//结构体嵌套
 2type address struct {
 3    city, state string
 4}
 5type student struct {
 6    name    string
 7    age     int
 8    address address
 9}
10func main(){
11    //结构体嵌套
12    var s student
13    s.name = "小明"
14    s.age = 18
15    s.address = address{
16        city:  "北京",
17        state: "中国",
18    }
19    fmt.Println(s)
20    fmt.Println(s.name)
21    fmt.Println(s.address.city)
22}

 1package main
 2
 3import (
 4    "fmt"
 5)
 6
 7//需要添加注释或者改成非导出变量(首字母小写)
 8type employee struct {
 9    firstName string
10    lastName  string
11    age       int
12}
13
14//匿名字段
15type person struct {
16    string
17    int
18    employee
19}
20
21//结构体嵌套
22type address struct {
23    city, state string
24}
25type student struct {
26    name    string
27    age     int
28    address address
29}
30
31//匿名结构，可⽤作结构成员或定义变量。
32type file struct {
33    name string
34    size int
35    attr struct {
36        perm  int
37        owner int
38    }
39}
40
41func main() {
42    //初始化方式1
43    var emp1 employee
44    emp1.firstName = "hello"
45    emp1.lastName = "world"
46    emp1.age = 20
47    fmt.Println(emp1)
48
49    //初始化方式2利用键值方式
50    emp2 := employee{
51        firstName: "Sam",
52        age:       25,
53        lastName:  "Anderson", //使用键值方式这个逗号不可以省略
54    }
55    fmt.Println(emp2)
56
57    //初始化方式3顺序初始化,必须包含全部字段，否则会出错。
58    emp3 := employee{"Thomas", "Paul", 29}
59    fmt.Println(emp3)
60
61    //结构体指针
62    emp5 := &employee{"Sam", "Anderson", 55}
63    fmt.Println("First Name:", (*emp5).firstName)
64    fmt.Println("Age:", (*emp5).age)
65
66    //匿名字段会把类型用作变量名
67    p := person{"Hello", 20, emp1}
68    p.string = "Other"
69    fmt.Println(p, p.string) //{Other 20} Other
70    fmt.Println(p.lastName)//等价于p.employee.lastName//输出：hello
71
72    //匿名结构
73    f := file{
74        name: "test.txt",
75        size: 1025,
76        // attr: {0755, 1}, //组合文字中缺少类型
77    }
78    f.attr.owner = 1
79    f.attr.perm = 0755
80    var attr = struct {
81        perm  int
82        owner int
83    }{2, 0755}
84    f.attr = attr
85    fmt.Println(f.attr.perm)
86
87    //结构体嵌套
88    var s student
89    s.name = "小明"
90    s.age = 18
91    s.address = address{
92        city:  "北京",
93        state: "中国",
94    }
95    fmt.Println(s)
96    fmt.Println(s.name)
97    fmt.Println(s.address.city)
98
99}