日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產(chǎn)品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
Go語言基礎之結構體（秋日篇）

 前言

Hey，大家好呀，碼農(nóng)我是星期八，咱們接著上次繼續(xù)說,看一下結構體還有什么其他操作。沒來得及上車的小伙伴請戳：Go語言基礎之結構體(春日篇)、Go語言基礎之結構體(夏日篇)。

匿名字段結構體

如果以后再遇到匿名這個詞，就把他當作沒有名字的意思。

匿名加字段結構體代碼。

 
 
 
 
    
  
  
  
  
  1. package main
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. import "fmt"
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. type Student struct {
    6. 
  
  
  
  
  6.     string
    7. 
  
  
  
  
  7.     int
    8. 
  
  
  
  
  8.     //string //error:duplicate field string
    9. 
  
  
  
  
  9.     //int    //error:duplicate field string
    10. 
  
  
  
  
  10. }
    11. 
  
  
  
  
  11. 
  
  
  
  
  12. func main() {
    13. 
  
  
  
  
  13.     var s1 = Student{
    14. 
  
  
  
  
  14.         "666"，
    15. 
  
  
  
  
  15.         0，
    16. 
  
  
  
  
  16. }
    17. 
  
  
  
  
  17.     fmt.Println(s1)
    18. 
  
  
  
  
  18. }
    19.

第8行和第9行代碼，如果去掉注釋會報錯。

這就說明了個問題，如果是匿名字段結構體，匿名字段類型是不能重復的，如上述代碼所示。

結構體嵌套

結構體嵌套，就如名字一樣，一個結構體，嵌套了另外一個結構體。

假設

一個學生的信息，假設有姓名，年齡，性別，這三個字段。

這個學生必定要歸屬一個班級的，假設這個班級的信息有年級，幾班，班主任姓名。

創(chuàng)建結構體

根據(jù)上述敘述，我們知道一定是有兩個結構體的，至少一個是學生，一個是班級。

班級結構體

 
 
 
 
    
  
  
  
  
  1. type Classes struct {
    2. 
  
  
  
  
  2.     Grade       int    //年級
    3. 
  
  
  
  
  3.     Class       int    //班級
    4. 
  
  
  
  
  4.     TeacherName string //班主任姓名
    5. 
  
  
  
  
  5. }
    6.

學生結構體

 
 
 
 
    
  
  
  
  
  1. type Student struct {
    2. 
  
  
  
  
  2.     Name   string  //姓名
    3. 
  
  
  
  
  3.     Age    int     //年齡
    4. 
  
  
  
  
  4.     Gender string  //性別
    5. 
  
  
  
  
  5.     class  Classes //所屬班級
    6. 
  
  
  
  
  6. }
    7.

可以看到第5行代碼，結構體的字段類型直接是一個結構體，這就是結構體嵌套、

當一個結構體不能完整描述一個對象時，或者說本來就是獨立的對象有關聯(lián)時，就需要結構體嵌套。

嵌套結構體賦值

方式一，直接賦值嵌套結構體

 
 
 
 
    
  
  
  
  
  1. func main() {
    2. 
  
  
  
  
  2.     var s1 = Student{
    3. 
  
  
  
  
  3.         Name:   "張三"，
    4. 
  
  
  
  
  4.         Age:    18，
    5. 
  
  
  
  
  5.         Gender: "男"，
    6. 
  
  
  
  
  6.         class: Classes{
    7. 
  
  
  
  
  7.             Grade:       2020，
    8. 
  
  
  
  
  8.             Class:       1，
    9. 
  
  
  
  
  9.             TeacherName: "張三的老師"，
    10. 
  
  
  
  
  10.         }，
    11. 
  
  
  
  
  11. }
    12. 
  
  
  
  
  12.     fmt.Println(s1)
    13. 
  
  
  
  
  13. }
    14.

方式二，分開賦值

 
 
 
 
    
  
  
  
  
  1. func main() {
    2. 
  
  
  
  
  2.     var c1 = Classes{
    3. 
  
  
  
  
  3.         Grade:       2020，
    4. 
  
  
  
  
  4.         Class:       1，
    5. 
  
  
  
  
  5.         TeacherName: "張三的老師"，
    6. 
  
  
  
  
  6. }
    7. 
  
  
  
  
  7.     var s2 = Student{
    8. 
  
  
  
  
  8.         Name:   "張三"，
    9. 
  
  
  
  
  9.         Age:    18，
    10. 
  
  
  
  
  10.         Gender: "男"，
    11. 
  
  
  
  
  11.         class:  c1，
    12. 
  
  
  
  
  12. }
    13. 
  
  
  
  
  13.     fmt.Println(s2)
    14. 
  
  
  
  
  14. }
    15.

兩次執(zhí)行結果

其實方式一和方式二的本質是一樣的，只不過是方式二將嵌套的結構體單獨賦值了而已。

匿名嵌套字段

上述我們的Student結構體是這樣寫的。

 
 
 
 
    
  
  
  
  
  1. type Student struct {
    2. 
  
  
  
  
  2.     Name   string  //姓名
    3. 
  
  
  
  
  3.     Age    int     //年齡
    4. 
  
  
  
  
  4.     Gender string  //性別
    5. 
  
  
  
  
  5.     class  Classes //所屬班級
    6. 
  
  
  
  
  6. }
    7.

但是其實第5行代碼的字段是可以省略的，就像這樣。

 
 
 
 
    
  
  
  
  
  1. type Student struct {
    2. 
  
  
  
  
  2.     Name   string  //姓名
    3. 
  
  
  
  
  3.     Age    int     //年齡
    4. 
  
  
  
  
  4.     Gender string  //性別
    5. 
  
  
  
  
  5.     Classes //所屬班級
    6. 
  
  
  
  
  6. }
    7.

但是在賦值時，就要注意了，因為Student結構體已經(jīng)沒有字段名了，所以就不能使用上述的方式賦值了

需要這種。

 
 
 
 
    
  
  
  
  
  1. func main() {
    2. 
  
  
  
  
  2.     var s1 = Student{
    3. 
  
  
  
  
  3.         Name:   "張三"，
    4. 
  
  
  
  
  4.         Age:    18，
    5. 
  
  
  
  
  5.         Gender: "男"，
    6. 
  
  
  
  
  6.         Classes: Classes{
    7. 
  
  
  
  
  7.             Grade:       2020，
    8. 
  
  
  
  
  8.             Class:       1，
    9. 
  
  
  
  
  9.             TeacherName: "張三的老師"，
    10. 
  
  
  
  
  10.     }，
    11. 
  
  
  
  
  11.   }
    12. 
  
  
  
  
  12. }
    13.

沒錯，第5行的字段名是Classes結構體名。

執(zhí)行結果還是一樣的。

 

補充

上述是直接通過定義變量時就直接賦值了。

其實不管是結構體，還是嵌套結構體，都還有一種方法，就是通過.的方式賦值，代碼如下。

結構體嵌套

默認的結構體嵌套，結構體還是有字段名的。

 
 
 
 
    
  
  
  
  
  1. type Student struct {
    2. 
  
  
  
  
  2.   Name    string //姓名
    3. 
  
  
  
  
  3.   Age     int    //年齡
    4. 
  
  
  
  
  4.   Gender  string //性別
    5. 
  
  
  
  
  5.   class Classes        //所屬班級
    6. 
  
  
  
  
  6. }
    7.

所以賦值代碼如下。

 
 
 
 
    
  
  
  
  
  1. func main() {
    2. 
  
  
  
  
  2.   var s1 Student
    3. 
  
  
  
  
  3.   s1.Name = "張三"
    4. 
  
  
  
  
  4.   s1.Age = 18
    5. 
  
  
  
  
  5.   s1.Gender = "男"
    6. 
  
  
  
  
  6.   s1.class.Grade = 2020
    7. 
  
  
  
  
  7.   s1.class.Class = 1
    8. 
  
  
  
  
  8.   s1.class.TeacherName = "張三的老師"
    9. 
  
  
  
  
  9.   fmt.Println(s1)
    10. 
  
  
  
  
  10. }
    11.

第6行代碼開始，通過s1找到class這個字段，再根據(jù)class找到class具體對應的值進行賦值。

匿名嵌套字段

匿名嵌套字段是沒有字段名的，是有一個字段類型。

 
 
 
 
    
  
  
  
  
  1. type Student struct {
    2. 
  
  
  
  
  2.   Name    string //姓名
    3. 
  
  
  
  
  3.   Age     int    //年齡
    4. 
  
  
  
  
  4.   Gender  string //性別
    5. 
  
  
  
  
  5.   Classes        //所屬班級
    6. 
  
  
  
  
  6. }
    7.

所以賦值跟上述也不太一樣，是這樣的。

 
 
 
 
    
  
  
  
  
  1. func main() {
    2. 
  
  
  
  
  2.   var s1 Student
    3. 
  
  
  
  
  3.   s1.Name = "張三"
    4. 
  
  
  
  
  4.   s1.Age = 18
    5. 
  
  
  
  
  5.   s1.Gender = "男"
    6. 
  
  
  
  
  6.   s1.Classes.Grade = 2020
    7. 
  
  
  
  
  7.   s1.Classes.Class = 1
    8. 
  
  
  
  
  8.   s1.Classes.TeacherName = "張三的老師"
    9. 
  
  
  
  
  9.   fmt.Println(s1)
    10. 
  
  
  
  
  10. }
    11.

通過s1直接找到Classes這個結構體，再根據(jù)這個結構體找到里面具體的值，進行賦值。

其實跟定義變量時賦值相似。

但是終究執(zhí)行結果，還是一樣的，只是賦值形式不同。

結論

根據(jù)嵌套結構體和匿名嵌套結構體再賦值時可以發(fā)現(xiàn)。

如果嵌套結構體有字段名，通過字段名找具體的字段，進行賦值。

如果是嵌套結構體匿名字段，通過嵌套結構體的名字，找具體字段，進行賦值。

嵌套結構體字段沖突

這個沖突的問題，其實還是比較少見的，這個問題通常情況下，只會出現(xiàn)在匿名嵌套場景中。

還是上述的結構體，但是賦值可以是這樣操作的。

 
 
 
 
    
  
  
  
  
  1. func main() {
    2. 
  
  
  
  
  2.   var s1 Student
    3. 
  
  
  
  
  3.   s1.Name = "張三"
    4. 
  
  
  
  
  4.   s1.Age = 18
    5. 
  
  
  
  
  5.   s1.Gender = "男"
    6. 
  
  
  
  
  6.   s1.Classes.Grade = 2020
    7. 
  
  
  
  
  7.   s1.Classes.Class = 1
    8. 
  
  
  
  
  8.   s1.Classes.TeacherName = "張三的老師"
    9. 
  
  
  
  
  9.   //######### 分割 ##########
    10. 
  
  
  
  
  10.   s1.Grade = 2020    //省去了Classes
    11. 
  
  
  
  
  11.   s1.Class = 1    //省去了Classes
    12. 
  
  
  
  
  12.   s1.TeacherName = "張三的老師"  //省去了Classes
    13. 
  
  
  
  
  13.   fmt.Println(s1)
    14. 
  
  
  
  
  14. }
    15.

第10行，直接通過s1.Grade賦值，其實是省去了一個Classes，但是這種操作，只有在匿名嵌套結構體中可以使用。

但是如果我將結構體改成這樣子。

 
 
 
 
    
  
  
  
  
  1. //班級
    2. 
  
  
  
  
  2. type Classes struct {
    3. 
  
  
  
  
  3.   Grade       int    //年級
    4. 
  
  
  
  
  4.   Class       int    //班級
    5. 
  
  
  
  
  5.   TeacherName string //班主任姓名
    6. 
  
  
  
  
  6. }
    7. 
  
  
  
  
  7. 
  
  
  
  
  8. //課程
    9. 
  
  
  
  
  9. type Course struct {
    10. 
  
  
  
  
  10.   CourseName  string //課程名字
    11. 
  
  
  
  
  11.   TeacherName string //任課老師姓名
    12. 
  
  
  
  
  12. }
    13. 
  
  
  
  
  13. 
  
  
  
  
  14. //學生
    15. 
  
  
  
  
  15. type Student struct {
    16. 
  
  
  
  
  16.   Name    string //姓名
    17. 
  
  
  
  
  17.   Age     int    //年齡
    18. 
  
  
  
  
  18.   Gender  string //性別
    19. 
  
  
  
  
  19.   Classes        //所屬班級
    20. 
  
  
  
  
  20.   Course         //任課老師
    21. 
  
  
  
  
  21. }
    22.

Student結構體有兩個匿名嵌套結構體，一個是Classes，一個是Course。

但是有一個字段，是沖突的，就是TeacherName，如果還是通過懶的方式賦值，會發(fā)生什么呢?

 
 
 
 
    
  
  
  
  
  1. func main() {
    2. 
  
  
  
  
  2.   var s1 Student
    3. 
  
  
  
  
  3.   s1.Name = "張三"
    4. 
  
  
  
  
  4.   s1.Age = 18
    5. 
  
  
  
  
  5.   s1.Gender = "男"
    6. 
  
  
  
  
  6.   s1.Grade = 2020
    7. 
  
  
  
  
  7.   s1.Class = 1
    8. 
  
  
  
  
  8.   s1.TeacherName = "張三的老師"
    9. 
  
  
  
  
  9.   fmt.Println(s1)
    10. 
  
  
  
  
  10. }
    11.

第8行，直接找TeacherName字段，這時候就會出問題了。

意思很簡單，就是不知道是Classes的TeacherName還是Course的TeacherName。

這時候，就必須要指定了。

 
 
 
 
    
  
  
  
  
  1. s1.Classes.TeacherName = "張三的班主任"
    2. 
  
  
  
  
  2. s1.Course.TeacherName = "張三的任課老師"
    3.

總結

個人建議，還是盡量不要使用匿名嵌套結構體。

如果使用了匿名嵌套結構體，盡可能的采用標準方式賦值，不要采用懶得方式。

如果采用了懶的方式，一定要注意有沒有字段沖突。

最后的總結

上述我們學習了Go基礎之結構體的匿名字段結構體，結構體嵌套，匿名結構體嵌套，匿名嵌套結構體字段沖突。

各位小伙伴一定要實踐一下，親手打一下代碼，堅持就是勝利，奧里給!


網(wǎng)頁標題：Go語言基礎之結構體（秋日篇）
本文來源：http://www.5511xx.com/article/djpjghj.html