golang-嵌套结构体

结构体嵌套

golang中没有类，他通过结构体来实现其他编程语言中类的相干功能。
具名结构体

根本语法

根本语法
golang的结构体嵌套特殊简单。

1. type 结构体类型1 struct{
2.     字段 类型1
3.     字段 类型2
4. }
6. //这样就实现了结构体的嵌套
7. type 结构体类型2 struct{
8.     字段 类型1
9.     字段 类型2
10.     字段 结构体类型1
11. }

复制代码

举例

1. package struct_knowledge
3. import "fmt"
5. type Worker struct{
6.         salary int
7.         profession string
8. }
9. //具名嵌套结构体
10. type Human struct{
11.         Name string
12.         Age int
13.         Work Worker
14. }
16. func (w Worker) GetSalary(){
17.         fmt.Printf("工资为%d\n",w.salary)
18. }
20. //访问具名结构体
21. func VisitNestingStruct(){
22.         var human Human
23.        
24.     //访问字段
25.     /*
26.             报错:human.salary undefined(type Human has no filed or method GetSalary)
27.     */
28.     //human.salary = 25
29.    
30.         //通过字段连锁访问
31.         human.Work.salary = 20
32.         fmt.Printf("结构体的实例为%v\n",human)
34.         //通过字面量访问
35.         human = Human{
36.                 Age: 20,
37.                 Name: "张三",
38.                 Work: Worker{
39.                         salary: 1000,
40.                         profession: "no work",
41.                 },
42.         }
43.         fmt.Printf("结构体的实例为%v\n",human)
45.         //通过位置赋值
46.         human = Human{
47.                 "lisa",
48.                 45,
49.                 Worker{
50.                         salary: 10000,
51.                         profession: "waiter",
52.                 },
53.         }
54.         fmt.Printf("结构体的实例为%v\n",human)
56.         // 调用方法
57.         /*
58.                 报错:human.GetSalary undefined(type Human has no filed or method GetSalary)
59.         */
60.         // human.GetSalary()
61.         human.Work.GetSalary()
62. }

复制代码

结果

1. 结构体的实例为struct_knowledge.Human{Name:"", Age:0, Work:struct_knowledge.Worker{salary:20, profession:""}}
2. 结构体的实例为struct_knowledge.Human{Name:"张三", Age:20, Work:struct_knowledge.Worker{salary:1000, profession:"no work"}}
3. 结构体的实例为struct_knowledge.Human{Name:"lisa", Age:45, Work:struct_knowledge.Worker{salary:10000, profession:"waiter"}}
4. 工资为10000

复制代码

访问规则

具名嵌套结构体的访问只能通过

1. 嵌套结构体字段名.字段
2. 嵌套结构体字段名.方法()

复制代码

不能通过最外层结构体直接访问。
举例

1. type Worker struct{
2.         salary int
3.         profession string
4. }
5. //具名嵌套结构体
6. type Human struct{
7.         Name string
8.         Age int
9.         Work Worker
10. }

复制代码

Human实例不能直接访问Worker实例的字段或方法，须要通过

1. Human实例.Work.字段
2. Human实例.Work.方法

复制代码

匿名结构体

根本语法

就是不写用字段汲取嵌套结构体而是直接写范例名，比方

1. type 结构体类型A struct{
2.     字段1 类型1
3.     字段2 类型2
4.     ...
5. }
7. type 结构体类型B struct{
8.     字段1 类型1
9.     结构体类型A
10. }

复制代码

举例

1. package struct_knowledge
3. import "fmt"
5. type StructA struct{
6.         name string
7.         age int
8. }
10. type StructB struct{
11.         price int
12.         StructA
13. }
15. func VisitStructB(){
16.         var st StructB
17.         fmt.Printf("嵌套结构体的值为%#v\n",st)
18. }

复制代码

结果

1. 嵌套结构体的值为struct_knowledge.StructB{price:0, StructA:struct_knowledge.StructA{name:"", age:0}}

复制代码

访问规则

名称访问

匿名结构体假如我们将他按照匿名字段明确，那么他就可以分析成如下情势:

1. type 结构体类型A struct{
2.     字段1 类型1
3.     字段2 类型2
4.     ...
5. }
7. type 结构体类型B struct{
8.     字段1 类型1
9.     结构体类型A
10. }
11. //按照匿名字段明确type 结构体范例B struct{    字段1 范例1    结构体A 结构体范例A}

复制代码

以是我们仍然可以通过如下情势修改和访问:

1. 结构体B实例.结构体A.字段
2. 结构体B实例.结构体A.方法()

复制代码

举例

1. package struct_knowledge
3. import "fmt"
5. type StructA struct{
6.         name string
7.         age int
8. }
10. type StructB struct{
11.         price int
12.         StructA
13. }
15. /*
16.         我们可以按照访问具名结构体的方法访问
17.         匿名结构体的名字就是 类型同名
18. */
19. func VisitStructByName(){
20.         var st StructB
22.         //连锁访问
23.         st.StructA.age = 25
24.         fmt.Printf("结构体的实例为%#v\n",st)
26.         //字面量访问
27.         st = StructB{
28.                 price: 1000,
29.                 StructA: StructA{
30.                         age:25,
31.                         name:"lisi",
32.                 },
33.         }
34.         fmt.Printf("结构体的实例为%#v\n",st)
36.         //位置访问
37.         st = StructB{
38.                 1000,
39.                 StructA{
40.                         age:30,
41.                         name:"sam",
42.                 },
43.         }
44.         fmt.Printf("结构体的实例为%#v\n",st)
45. }

复制代码

结果

1. 结构体的实例为struct_knowledge.StructB{price:0, StructA:struct_knowledge.StructA{name:"", age:25}}
2. 结构体的实例为struct_knowledge.StructB{price:1000, StructA:struct_knowledge.StructA{name:"lisi", age:25}}
3. 结构体的实例为struct_knowledge.StructB{price:1000, StructA:struct_knowledge.StructA{name:"sam", age:30}}

复制代码

直接访问

匿名结构体与具名结构体最大的差异就是：

1. 我们可以直接通过外层结构体访问匿名结构体的字段或方法(前提没有产生同名冲突)。

复制代码

举例

1. package struct_knowledge
3. import "fmt"
5. type StructA struct{
6.         name string
7.         age int
8. }
10. type StructB struct{
11.         price int
12.         StructA
13. }
15. func (c StructA) GetAge(){
16.         fmt.Printf("StructA的年龄为%v\n",c.age)
17. }
19. func VisitStructByNoName(){
20.         var st StructB
21.         //在不出现名字冲突的情况下，外层结构体可以直接访问匿名结构体的字段和方法
22.         st.age = 25
23.         st.GetAge()
24.         fmt.Printf("结构体的实例为%#v\n",st)
26.         //但仅限于这种成员访问，字面量和位置就不适用
27.         /*
28.                 报错:
29.                 unknow field age in struct literal of type StructB
30.                 unknow field name in struct literal of type StructB
31.         */
32.         // st = StructB{
33.         //         price: 1000,
34.         //         age:30,
35.         //         name:"lisa",
36.         // }
37. }

复制代码

结果

1. StructA的年龄为25
2. 结构体的实例为struct_knowledge.StructB{price:0, StructA:struct_knowledge.StructA{name:"", age:25}}

复制代码

字段辩论

这种环境紧张出如今匿名结构体中，由于同一结构体中字段唯一，以是结构体中不能出现同名字段。
但是匿名结构体嵌套后，由于他可以匿名访问，以是就产生了字段和方法辩论。
这也是匿名结构体答应具名访问的缘故因由。
办理方案
当出现字段辩论时，访问匿名结构体的同名字段或方法须要接纳具名访问。
举例

1. package struct_knowledge
3. import "fmt"
5. type StructOne struct{
6.         name string
7.         age int
8.         price int
9. }
11. type StructTwo struct{
12.         name string
13.         age int
14. }
16. type StructThree struct{
17.         name string
18.         StructOne
19.         StructTwo
20. }
22. func VisitStructThree(){
23.         var st StructThree
24.         fmt.Printf("结构体的实例为%#v\n",st)
26.         //访问不同名字段，可以直接匿名访问
27.         st.price  = 20
29.         /*
30.                 但是访问同名字段或方法，就需要指明结构体
31.                 如果最外层结构体有就访问的是最外层
32.         */
33.         st.name = "lisa"
35.         /*
36.                 如果访问同名字段或方法，
37.                 但最外层结构体也没有就会报错
39.                 ambiguous selector st.age
40.         */
41.         // st.age = 25
42. }

复制代码

结果

1. 结构体的实例为struct_knowledge.StructThree{name:"", StructOne:struct_knowledge.StructOne{name:"", age:0, price:0}, StructTwo:struct_knowledge.StructTwo{name:"", age:0}}
2. 结构体的实例为struct_knowledge.StructThree{name:"lisa", StructOne:struct_knowledge.StructOne{name:"", age:0, price:20}, StructTwo:struct_knowledge.StructTwo{name:"", age:0}}

复制代码

辩论字段访问规则

1.假如要访问的同名字段大概方法顶层有，直接访问则接纳顶层的字段或方法。
2.假如要访问的同名字段大概方法顶层没有，直接访问就会报错。

1. # ambiguous的中文含义:模糊不清的，模棱两可的
2. ambiguous selector st.xxx

复制代码

办理字段辩论标题

要访问嵌套结构体的同名字段大概方法，可以接纳具名访问法，比方

1. 外层结构体实例.匿名结构体类型.字段
2. 外层结构体实例.匿名结构体类型.方法()

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。