例子1

  1. type firmWareResp struct {
  2.         Result struct {
  3.             Code    int    `json:"code"`
  4.             Message string `json:"message"`
  5.         } `json:"result"`
  6.         Data FirmWareResp `json:"data"`
  7. }
  9. type FirmWareResp struct {
  10.     Total int            `json:"total"`
  11.     List  []firmWareList `json:"list"`
  12. }
  14. resp := &firmWareResp{}
  15. err := json.Unmarshal([]byte(result), resp)

在上面的例子中，我们在struct中直接定义一个新的结构体，并使用了嵌套组合的用法，利用json unmarshal直接赋值。这种方式是十分简便的，不需要初始化结构体。那假如说我们的匿名结构体（Result）需要初始化呢？

例子2

  1. type Account struct {
  2.     Id uint32
  3.     Name string
  4.     Nested struct {
  5.        Age uint8
  6.     }
  7. }
  9. account := &Account{
  10.     Id: 10,
  11.     Name: "jim",
  12.     Nested: struct{Age uint8}{Age, 20},
  13. }
  15. //匿名struct直接初始化的时候需要给出结构体
  16. //更清晰的使用方法是：
  17. //acc := new(Account)
  18. // acc.Id = 10
  19. // acc.Name = "jim"
  20. // acc.Nested.Age = 20

例子3

  1. type Handler{}
  2.     seqNum   uint16
  3.     mx         sync.RWMutex
  4.     lastActive time.Time
  5. }
  6. // 这里使用了组合，我们在使用Handler结构体的时候，可以直接使用sync.RWMutex这个读写锁，不需要初始化
  8. h := Handler{}
  9. h.mx.Lock()
  10. h.lastActive = time.Now()
  11. h.mx.Unlock()

例子4

  1. type ModelListPara struct {
  2.     Key string `json:"key" form:"key"`
  3.     QueryPagePara
  4. }
  6. type QueryPagePara struct {
  7.     Page     int `form:"page" json:"page" binding:""`
  8.     PageSize int `form:"pageSize" json:"pageSize" binding:""`
  9. }
  11. var params request.PresignPara
  12. err := c.ShouldBind(&params)
  14. //这是组合的另外一种用法，我们可以直接定义新的变量，非常简便

例子5

  1. // 我们应该怎么去初始化一个结构体数组呢？我一直都在思考这个问题
  2. type AuthRequest struct {
  3.         Plain string
  4.         Same string
  5.     }
  7.     requests := []AuthRequest{
  8.         AuthRequest {
  9.             "test",
  10.             "test",
  11.         },
  12.     }
  14.     fmt.Println(requests[0].Plain) //成功打印出test

参考：golang初始化结构体数组

例子6

  1. // 有时候在处理http request的时候，经常会处理一个data的字段，这个字段数据类型回事interface{}, 这样就可以得到不同的data. 这时候我们应该怎么去写呢？不好意思，实现不了...
  3. type TerraResp struct {
  4.     Result struct {
  5.         Code    int    `json:"code"`
  6.         Message string `json:"msg"`
  7.         Desc    string `json:"desc"`
  8.     } `json:"result"`
  9. }
  11. type TokenResp struct {
  12.     Data ObtainTokenRsp `json:"data"`
  13.     TerraResp
  14. }
  16. type ObtainTokenRsp struct {
  17.     CloudName       string `json:"cloudName"`
  18.     AccessKeyID     string `json:"accessKeyID"`
  19.     SecretAccessKey string `json:"secretAccessKey"`
  20.     SessionToken    string `json:"sessionToken"`
  21.     Region          string `json:"region"`
  22.     CloudBucketName string `json:"cloudBucketName"`
  23.     CallbackParam   string `json:"callbackParam"`
  24.     StorePath       string `json:"storePath"`
  25.     ExpireTime      int64  `json:"expireTime"`
  26. }
  28. //这种代码的构造方式，已经算是比较优雅的了