结构类型（struct）

  • 为了将分散的零件组成一个完整的结构体，Go 提供了 struct 类型。
  • struct 允许你将不同类型的东西组合在一起。
  • 声明结构 
  1. package main
  3. import "fmt"
  5. func main() {
  6.     var curiosity struct {
  7.         lat  float64
  8.         long float64
  9.     }
  11.     curiosity.lat = -4.5895
  12.     curiosity.long = 137.4417
  14.     fmt.Println(curiosity.lat, curiosity.long)
  15.     fmt.Println(curiosity)
  16. }

通过类型复用结构体

  1. package main
  3. import "fmt"
  5. func main() {
  6.     type location struct {
  7.         lat  float64
  8.         long float64
  9.     }
  11.     var spirit location
  12.     spirit.lat = -14.5684
  13.     spirit.long = 175.472636
  15.     var opportunity location
  16.     opportunity.lat = -1.9462
  17.     opportunity.long = 354.4734
  19.     fmt.Println(spirit, opportunity)
  20. }

通过复合字面值初始化 struct

  • 两种形式：
    • 通过成对的字段和值进行初始化 
  1. package main
  3. import "fmt"
  5. func main() {
  6.     type location struct {
  7.         lat, long float64
  8.     }
  10.     opportunity := location{lat: -1.9462, long: 354.4734}
  11.     fmt.Println(opportunity)
  13.     insight := location{lat: 4.5, long: 135.9}
  14.     fmt.Println(insight)
  15.     spirit := location{-14.5684, 175.472636}
  16.     fmt.Println(spirit)
  17.     curiosity := location{-4.5895, 137.4417}
  19.     fmt.Printf("%v\n", curiosity)
  20.     fmt.Printf("%+v\n", curiosity)
  21. }
  1. -  按字段定义的顺序进行初始化（例子 21.4）
  • 打印 struct（例子 21.5）
    • %v，打印出 {-4.5895 137.4417}
    • %+v，打印出 {lat:-4.5895 long:137.4417}

struct 的复制

  1. package main
  3. import "fmt"
  5. func main() {
  6.     type location struct {
  7.         lat  float64
  8.         long float64
  9.     }
  10.     bradbury := location{-4.5895, 137.4417}
  11.     curiosity := bradbury
  13.     curiosity.long += 0.0106
  15.     fmt.Println(bradbury, curiosity)
  16. }

由结构体组成的 slice

  1. package main
  3. func main() {
  4.     lats := []float64{-4.5895, -14.5684, -1.9462}
  5.     longs := []float64{137.4417, 175.472636, 354.4734}
  7.     _ = lats
  8.     _ = longs
  9.     type location struct {
  10.         name string
  11.         lat  float64
  12.         long float64
  13.     }
  15.     locations := []location{
  16.         {name: "Bradbury Landing", lat: -4.5895, long: 137.4417},
  17.         {name: "Columbia Memorial Station", lat: -14.5684, long: 175.472636},
  18.         {name: "Challenger Memorial Station", lat: -1.9462, long: 354.4734},
  19.     }
  21.     _ = locations
  22. }

将 struct 编码为 JSON

  • JSON（JavaScript Object Notation，JavaScript 对象表示法）
  • 常用于 Web API
  • json 包的 Marshal 函数可以将 struct 中的数据转化为 JSON 格式。
  • Marshal 函数只会对 struct 中被导出的字段进行编码。 
  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6.     "os"
  7. )
  9. func main() {
  10.     type location struct {
  11.         Lat, Long float64
  12.     }
  14.     curiosity := location{-4.5895, 137.4417}
  16.     bytes, err := json.Marshal(curiosity)
  17.     exitOnError(err)
  19.     fmt.Println(string(bytes))
  20. }
  22. // exitOnError prints any errors and exits.
  23. func exitOnError(err error) {
  24.     if err != nil {
  25.         fmt.Println(err)
  26.         os.Exit(1)
  27.     }
  28. }

使用 struct 标签来自定义 JSON

  • Go 语言中的 json 包要求 struct 中的字段必须以大写字母开头，类似 CamelCase 驼峰型命名规范。
  • 但有时候我们需要 snake_case 蛇形命名规范，那么该怎么办？
  • 可以为字段注明标签，使得 json 包在进行编码的时候能够按照标签里的样式修改字段名。 
  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6.     "os"
  7. )
  9. func main() {
  10.     type location struct {
  11.         Lat  float64 `json:"latitude"`
  12.         Long float64 `json:"longitude"`
  13.     }
  15.     curiosity := location{-4.5895, 137.4417}
  17.     bytes, err := json.Marshal(curiosity)
  18.     exitOnError(err)
  20.     fmt.Println(string(bytes))
  21. }
  23. // exitOnError prints any errors and exits
  24. func exitOnError(err error) {
  25.     if err != nil {
  26.         fmt.Println(err)
  27.         os.Exit(1)
  28.     }
  29. }

作业题

  • 编写一个程序：
    • 能够以 JSON 格式打印出 例子 21.8 中 3 台 探测器的着陆点。
    • 被打印的 JSON 数据必须包含每个着陆点的名称，并使用例子 21.10 中展示的 struct 标签特性。
    • 请使用 json 包中的 MarshalIndent 函数让打印输出变得更加美观和易读。
  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6.     "os"
  7. )
  9. func main() {
  10.     type location struct {
  11.         Name string  `json:"name"`
  12.         Lat  float64 `json:"latitude"`
  13.         Long float64 `json:"longitude"`
  14.     }
  16.     locations := []location{
  17.         {Name: "Bradbury Landing", Lat: -4.5895, Long: 137.4417},
  18.         {Name: "Columbia Memorial Station", Lat: -14.5684, Long: 175.472636},
  19.         {Name: "Challenger Memorial Station", Lat: -1.9462, Long: 354.4734},
  20.     }
  22.     bytes, err := json.MarshalIndent(locations, "", "  ")
  23.     if err != nil {
  24.         fmt.Println(err)
  25.         os.Exit(1)
  26.     }
  28.     fmt.Println(string(bytes))
  29. }