Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。 结构体是由一系列具有相同类型或不同类型的数据构成的数据集合

定义结构体

结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：

  1. type struct_variable_type struct {
  2.    member definition
  3.    member definition
  4.    ...
  5.    member definition
  6. }

一旦定义了结构体类型，它就能用于变量的声明，语法格式如下

  1. variable_name := structure_variable_type {value1, value2...valuen}
  2. 或
  3. variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}

结构体表示一项记录，比如保存图书馆的书籍记录，每本书有以下属性：

  • ID 书籍ID
  • Title 标题
  • Author 作者
  • Subject 学科 ```go package main import “fmt”

type Books struct { title string author string subject string book_id int }

func main() { // 创建一个新的结构体 fmt.Println(Books{“Go 语言”, “www.runoob.com”, “Go 语言教程”, 6495407})

// 也可以使用 key => value 格式 fmt.Println(Books{title: “Go 语言”, author: “www.runoob.com”, subject: “Go 语言教程”, book_id: 6495407})

// 忽略的字段为 0 或 空 fmt.Println(Books{title: “Go 语言”, author: “www.runoob.com”}) }

/ 输出结果为： {Go 语言 www.runoob.com Go 语言教程 6495407} {Go 语言 www.runoob.com Go 语言教程 6495407} {Go 语言 www.runoob.com 0} /

  3. <a name="NhOMl"></a>
  4. ### 访问结构体成员
  5. 如果要访问结构体成员，需要使用点号 **.** 操作符，格式为
  6. ```go
  7. 结构体.成员名"

结构体类型变量使用 struct 关键字定义，实例如下：

  1. package main
  2. import "fmt"
  4. type Books struct {
  5.    title string
  6.    author string
  7.    subject string
  8.    book_id int
  9. }
  11. func main() {
  12.    var Book1 Books        // 声明 Book1 为 Books 类型
  13.    var Book2 Books        // 声明 Book2 为 Books 类型
  15.    // book 1 描述
  16.    Book1.title = "Go 语言"
  17.    Book1.author = "www.runoob.com"
  18.    Book1.subject = "Go 语言教程"
  19.    Book1.book_id = 6495407
  21.    // book 2 描述
  22.    Book2.title = "Python 教程"
  23.    Book2.author = "www.runoob.com"
  24.    Book2.subject = "Python 语言教程"
  25.    Book2.book_id = 6495700
  27.    // 打印 Book1 信息
  28.    fmt.Printf( "Book 1 title : %s\n", Book1.title)
  29.    fmt.Printf( "Book 1 author : %s\n", Book1.author)
  30.    fmt.Printf( "Book 1 subject : %s\n", Book1.subject)
  31.    fmt.Printf( "Book 1 book_id : %d\n", Book1.book_id)
  33.    // 打印 Book2 信息
  34.    fmt.Printf( "Book 2 title : %s\n", Book2.title)
  35.    fmt.Printf( "Book 2 author : %s\n", Book2.author)
  36.    fmt.Printf( "Book 2 subject : %s\n", Book2.subject)
  37.    fmt.Printf( "Book 2 book_id : %d\n", Book2.book_id)
  38. }
  40. /* 
  41. 以上实例执行运行结果为：
  42. Book 1 title : Go 语言
  43. Book 1 author : www.runoob.com
  44. Book 1 subject : Go 语言教程
  45. Book 1 book_id : 6495407
  46. Book 2 title : Python 教程
  47. Book 2 author : www.runoob.com
  48. Book 2 subject : Python 语言教程
  49. Book 2 book_id : 6495700
  50. */

结构体作为函数参数

你可以像其他数据类型一样将结构体类型作为参数传递给函数。并以以上实例的方式访问结构体变量：

  1. package main
  2. import "fmt"
  4. type Books struct {
  5.    title string
  6.    author string
  7.    subject string
  8.    book_id int
  9. }
  11. func main() {
  12.    var Book1 Books        // 声明 Book1 为 Books 类型
  13.    var Book2 Books        // 声明 Book2 为 Books 类型
  15.    // book 1 描述
  16.    Book1.title = "Go 语言"
  17.    Book1.author = "www.runoob.com"
  18.    Book1.subject = "Go 语言教程"
  19.    Book1.book_id = 6495407
  21.    // book 2 描述
  22.    Book2.title = "Python 教程"
  23.    Book2.author = "www.runoob.com"
  24.    Book2.subject = "Python 语言教程"
  25.    Book2.book_id = 6495700
  28.    printBook(Book1) // 打印 Book1 信息
  29.    printBook(Book2) // 打印 Book2 信息
  30. }
  32. func printBook( book Books ) {
  33.    fmt.Printf( "Book title : %s\n", book.title)
  34.    fmt.Printf( "Book author : %s\n", book.author)
  35.    fmt.Printf( "Book subject : %s\n", book.subject)
  36.    fmt.Printf( "Book book_id : %d\n", book.book_id)
  37. }
  39. /* 
  40. Book title : Go 语言
  41. Book author : www.runoob.com
  42. Book subject : Go 语言教程
  43. Book book_id : 6495407
  44. Book title : Python 教程
  45. Book author : www.runoob.com
  46. Book subject : Python 语言教程
  47. Book book_id : 6495700
  48. */

结构体指针

你可以定义指向结构体的指针类似于其他指针变量，格式如下：

  1. var struct_pointer *Books

以上定义的指针变量可以存储结构体变量的地址。查看结构体变量地址，可以将 & 符号放置于结构体变量前：

  1. struct_pointer = &Book1

使用结构体指针访问结构体成员，使用 “.” 操作符：

  1. struct_pointer.title

接下来让我们使用结构体指针重写以上实例，代码如下：

  1. package main
  2. import "fmt"
  4. type Books struct {
  5.    title string
  6.    author string
  7.    subject string
  8.    book_id int
  9. }
  11. func main() {
  12.    var Book1 Books        // Declare Book1 of type Book
  13.    var Book2 Books        // Declare Book2 of type Book
  15.    // book 1 描述
  16.    Book1.title = "Go 语言"
  17.    Book1.author = "www.runoob.com"
  18.    Book1.subject = "Go 语言教程"
  19.    Book1.book_id = 6495407
  21.    // book 2 描述
  22.    Book2.title = "Python 教程"
  23.    Book2.author = "www.runoob.com"
  24.    Book2.subject = "Python 语言教程"
  25.    Book2.book_id = 6495700
  27.    printBook(&Book1) // 打印 Book1 信息
  28.    printBook(&Book2) // 打印 Book2 信息
  29. }
  30. func printBook( book *Books ) {
  31.    fmt.Printf( "Book title : %s\n", book.title)
  32.    fmt.Printf( "Book author : %s\n", book.author)
  33.    fmt.Printf( "Book subject : %s\n", book.subject)
  34.    fmt.Printf( "Book book_id : %d\n", book.book_id)
  35. }
  37. /* 
  38. Book title : Go 语言
  39. Book author : www.runoob.com
  40. Book subject : Go 语言教程
  41. Book book_id : 6495407
  42. Book title : Python 教程
  43. Book author : www.runoob.com
  44. Book subject : Python 语言教程
  45. Book book_id : 6495700
  46. */

结构体是作为参数的值传递

  1. package main
  3. import "fmt"
  5. type Books struct {
  6.     title string
  7.     author string
  8.     subject string
  9.     book_id int
  10. }
  12. func changeBook(book Books,title string) {
  13.     book.title = title
  14. }
  16. func main() {
  17.     var book1 Books
  18.     book1.title = "book1"
  19.     book1.author = "zuozhe"
  20.     book1.book_id = 1
  22.     changeBook(book1,"title被修改了")
  23.     fmt.Println(book1)
  24. }
  26. /* 
  27. 期盼结果: 
  28. {title被修改了 zuozhe  1}
  30. 实际结果为：
  31. {book1 zuozhe  1}
  32. */

如果想在函数里面改变结果体数据内容，需要传入指针：

  1. package main
  3. import "fmt"
  5. type Books struct {
  6.     title string
  7.     author string
  8.     subject string
  9.     book_id int
  10. }
  12. func changeBook(book *Books,title string) {
  13.     book.title = title
  14. }
  16. func main() {
  17.     var book1 Books
  18.     book1.title = "book1"
  19.     book1.author = "zuozhe"
  20.     book1.book_id = 1
  22.     changeBook(&book1,"title被修改了")
  23.     fmt.Println(book1)
  24. }
  26. /* 
  27. 运行结果: 
  28. {title被修改了 zuozhe  1}
  29. */

struct 中定义成员变量

struct 类似于 java 中的类，但是不需要通过 getter, setter 来设置访问权限。要访问成员变量，可以：

  • 通过 struct变量.成员变量来访问、重新赋值
  • 通过 struct指针.成员变量来访问、重新赋值 ```go type Rect struct{ //定义矩形类 x,y float64 //类型只包含属性，并没有方法 width,height float64 }

func (r Rect) getArea() float64{ //为Rect类型绑定Area的方法，Rect为指针引用可以修改传入参数的值 return r.width*r.height //方法归属于类型，不归属于具体的对象，声明该类型的对象即可调用该类型的方法 }

//_ package main import ( “fmt” )

type Rect struct{
x,y float64
width,height int }

func (r Rect) getArea() int{ return r.widthr.height }

func main() { var rectExample Rect rectExample.x = 10 rectExample.width = 20 rectExample.height = 30 rectExample.x = 40 fmt.Println(rectExample.getArea()) }

  2. <a name="HjgZM"></a>
  3. ### Golang自定义结构体转map
  4. 在Golang中，如何将一个结构体转成map？ 本文介绍两种方法。第一种是是使用json包解析解码编码。第二种是使用反射，使用反射的效率比较高
  5. <a name="fCPr5"></a>
  6. #### json包的marshal，unmarshal
  7. ```go
  8. package main
  9. import (
  10.     "fmt"
  11.     "time"
  12.     "encoding/json"
  13.     // "reflect"
  14.     // "strconv"
  15.     // "strings"
  16.     // "testing"
  17. )
  19. const timeLayout = "2006-01-02 15:04:05"
  21. type User struct {
  22.     Name      string       `map:"name,omitempty"`        // string
  23.     Github    GithubPage   `map:"github,dive,omitempty"` // struct dive
  24.     NoDive    StructNoDive `map:"no_dive,omitempty"`     // no dive struct
  25.     MyProfile Profile      `map:"my_profile,omitempty"`  // struct implements its own method
  26. }
  28. type GithubPage struct {
  29.     URL  string `map:"url"`
  30.     Star int    `map:"star"`
  31. }
  33. type StructNoDive struct {
  34.     NoDive int
  35. }
  37. type Profile struct {
  38.     Experience string    `map:"experience"`
  39.     Date       time.Time `map:"time"`
  40. }
  42. // its own toMap method
  43. func (p Profile) StructToMap() (key string, value interface{}) {
  44.     return "time", p.Date.Format(timeLayout)
  45. }
  48. func newUser() User {
  49.     name := "user"
  51.     MyGithub := GithubPage{
  52.         URL:  "https://github.com/liangyaopei/structmap",
  53.         Star: 1,
  54.     }
  56.     NoDive := StructNoDive{NoDive: 1}
  58.     dateStr := "2020-07-21 12:00:00"
  59.     date, _ := time.Parse(timeLayout, dateStr)
  60.     profile := Profile{
  61.         Experience: "my experience",
  62.         Date:       date,
  63.     }
  65.     return User{
  66.         Name:      name,
  67.         Github:    MyGithub,
  68.         NoDive:    NoDive,
  69.         MyProfile: profile,
  70.     }
  71. }
  74. func main() {
  75.     user := newUser()
  76.     data, _ := json.Marshal(&user)
  77.     m := make(map[string]interface{})
  78.     json.Unmarshal(data, &m)
  79.     fmt.Println(m)
  80. }

先将结构体序列化成 [] byte 数组，再从 [] byte 数组序列化成结构体

  1. data, _ := json.Marshal(&user)
  2. m := make(map[string]interface{})
  3. json.Unmarshal(data, &m)
  • 使用简单 劣势
  • 效率比较慢
  • 不能支持一些定制的键，也不能支持一些定制的方法，例如将struct的域展开等

使用反射

本文实现了使用反射将结构体转成 map 的方法。通过标签(tag)和反射，将上文示例的 newUser() 返回的结果转化成下面的一个map。其中包含struct的域的展开，定制化struct的方法
1.标签识别
使用readTag方法读取域(field)的标签，如果没有标签，使用域的名字。然后读取tag中的选项。目前支持3个选项

  • ‘-‘:忽略当前这个域
  • omitempty : 当这个域的值为空，忽略这个域
  • dive : 递归地遍历这个结构体，将所有字段作为键

如果选中了一个选项，就讲这个域对应的二进制位置为1

  1. const (
  2.     OptIgnore    = "-"
  3.     OptOmitempty = "omitempty"
  4.     OptDive      = "dive"
  5. )
  7. const (
  8.     flagIgnore = 1 << iota
  9.     flagOmiEmpty
  10.     flagDive
  11. )
  13. func readTag(f reflect.StructField, tag string) (string, int) {
  14.     val, ok := f.Tag.Lookup(tag)
  15.     fieldTag := ""
  16.     flag := 0
  18.     // no tag, use field name
  19.     if !ok {
  20.         return f.Name, flag
  21.     }
  22.     opts := strings.Split(val, ",")
  24.     fieldTag = opts[0]
  25.     for i := 1; i < len(opts); i++ {
  26.         switch opts[i] {
  27.         case OptIgnore:
  28.             flag |= flagIgnore
  29.         case OptOmitempty:
  30.             flag |= flagOmiEmpty
  31.         case OptDive:
  32.             flag |= flagDive
  33.         }
  34.     }
  35.     return fieldTag, flag
  36. }

2.结构体的域(field)的遍历
遍历结构体的每一个域(field)，判断field的类型(kind)。如果是string,int等的基本类型，直接取值，并且把标签中的值作为key

  1. for i := 0; i < t.NumField(); i++ {
  2.         ...
  3.         switch fieldValue.Kind() {
  4.         case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int, reflect.Int64:
  5.             res[tagVal] = fieldValue.Int()
  6.         case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint, reflect.Uint64:
  7.             res[tagVal] = fieldValue.Uint()
  8.         case reflect.Float32, reflect.Float64:
  9.             res[tagVal] = fieldValue.Float()
  10.         case reflect.String:
  11.             res[tagVal] = fieldValue.String()
  12.         case reflect.Bool:
  13.             res[tagVal] = fieldValue.Bool()
  14.         default:
  15.         }
  16.     }
  17. }

3.内嵌结构体的转换
如果是结构体，先检查有没有实现传入参数的方法，如果实现了，就调用这个方法。如果没有实现，就递归地调用StructToMap方法，然后根据是否展开(dive)，来把返回结果写入res的map

  1. for i := 0; i < t.NumField(); i++ {
  2.         fieldType := t.Field(i)
  4.         // ignore unexported field
  5.         if fieldType.PkgPath != "" {
  6.             continue
  7.         }
  8.         // read tag
  9.         tagVal, flag := readTag(fieldType, tag)
  11.         if flag&flagIgnore != 0 {
  12.             continue
  13.         }
  15.         fieldValue := v.Field(i)
  16.         if flag&flagOmiEmpty != 0 && fieldValue.IsZero() {
  17.             continue
  18.         }
  20.         // ignore nil pointer in field
  21.         if fieldValue.Kind() == reflect.Ptr && fieldValue.IsNil() {
  22.             continue
  23.         }
  24.         if fieldValue.Kind() == reflect.Ptr {
  25.             fieldValue = fieldValue.Elem()
  26.         }
  28.         // get kind
  29.         switch fieldValue.Kind() {
  30.         case reflect.Struct:
  31.             _, ok := fieldValue.Type().MethodByName(methodName)
  32.             if ok {
  33.                 key, value, err := callFunc(fieldValue, methodName)
  34.                 if err != nil {
  35.                     return nil, err
  36.                 }
  37.                 res[key] = value
  38.                 continue
  39.             }
  40.             // recursive
  41.             deepRes, deepErr := StructToMap(fieldValue.Interface(), tag, methodName)
  42.             if deepErr != nil {
  43.                 return nil, deepErr
  44.             }
  45.             if flag&flagDive != 0 {
  46.                 for k, v := range deepRes {
  47.                     res[k] = v
  48.                 }
  49.             } else {
  50.                 res[tagVal] = deepRes
  51.             }
  52.         default:
  53.         }
  54.     }
  55.     ...
  56. }
  58. // call function
  59. func callFunc(fv reflect.Value, methodName string) (string, interface{}, error) {
  60.     methodRes := fv.MethodByName(methodName).Call([]reflect.Value{})
  61.     if len(methodRes) != methodResNum {
  62.         return "", nil, fmt.Errorf("wrong method %s, should have 2 output: (string,interface{})", methodName)
  63.     }
  64.     if methodRes[0].Kind() != reflect.String {
  65.         return "", nil, fmt.Errorf("wrong method %s, first output should be string", methodName)
  66.     }
  67.     key := methodRes[0].String()
  68.     return key, methodRes[1], nil
  69. }

4.array,slice类型的转换
如果是array,slice类型，类似地，检查有没有实现传入参数的方法，如果实现了，就调用这个方法。如果没有实现，将这个field的tag作为key，域的值作为value

  1. switch fieldValue.Kind() {
  2.         case reflect.Slice, reflect.Array:
  3.             _, ok := fieldValue.Type().MethodByName(methodName)
  4.             if ok {
  5.                 key, value, err := callFunc(fieldValue, methodName)
  6.                 if err != nil {
  7.                     return nil, err
  8.                 }
  9.                 res[key] = value
  10.                 continue
  11.             }
  12.             res[tagVal] = fieldValue
  13.             ....
  14. }

5.其他类型
对于其他类型，例如内嵌的map，直接将其返回结果的值

  1. switch fieldValue.Kind() {
  2.         ...
  3.         case reflect.Map:
  4.             res[tagVal] = fieldValue
  5.         case reflect.Chan:
  6.             res[tagVal] = fieldValue
  7.         case reflect.Interface:
  8.             res[tagVal] = fieldValue.Interface()
  9.         default:
  10.         }

完整案例

创建 structmap.go 文件,写入代码

  1. package structmap
  3. import (
  4.     "fmt"
  5.     "reflect"
  6.     "strings"
  7. )
  9. const (
  10.     methodResNum = 2
  11. )
  13. const (
  14.     OptIgnore    = "-"
  15.     OptOmitempty = "omitempty"
  16.     OptDive      = "dive"
  17. )
  19. const (
  20.     flagIgnore = 1 << iota
  21.     flagOmiEmpty
  22.     flagDive
  23. )
  25. // StructToMap convert a golang sturct to a map
  26. // key can be specified by tag, LIKE `map:"tag"`.
  27. // If there is no tag, struct filed name will be used instead
  28. // methodName is the name the field has implemented.
  29. // If implemented, it uses the method to get the key and value
  30. func StructToMap(s interface{}, tag string, methodName string) (res map[string]interface{}, err error) {
  31.     v := reflect.ValueOf(s)
  33.     if v.Kind() == reflect.Ptr && v.IsNil() {
  34.         return nil, fmt.Errorf("%s is a nil pointer", v.Kind().String())
  35.     }
  36.     if v.Kind() == reflect.Ptr {
  37.         v = v.Elem()
  38.     }
  39.     // only accept struct param
  40.     if v.Kind() != reflect.Struct {
  41.         return nil, fmt.Errorf("s is not a struct but %s", v.Kind().String())
  42.     }
  44.     t := v.Type()
  45.     res = make(map[string]interface{})
  46.     for i := 0; i < t.NumField(); i++ {
  47.         fieldType := t.Field(i)
  49.         // ignore unexported field
  50.         if fieldType.PkgPath != "" {
  51.             continue
  52.         }
  53.         // read tag
  54.         tagVal, flag := readTag(fieldType, tag)
  56.         if flag&flagIgnore != 0 {
  57.             continue
  58.         }
  60.         fieldValue := v.Field(i)
  61.         if flag&flagOmiEmpty != 0 && fieldValue.IsZero() {
  62.             continue
  63.         }
  65.         // ignore nil pointer in field
  66.         if fieldValue.Kind() == reflect.Ptr && fieldValue.IsNil() {
  67.             continue
  68.         }
  69.         if fieldValue.Kind() == reflect.Ptr {
  70.             fieldValue = fieldValue.Elem()
  71.         }
  73.         // get kind
  74.         switch fieldValue.Kind() {
  75.         case reflect.Slice, reflect.Array:
  76.             _, ok := fieldValue.Type().MethodByName(methodName)
  77.             if ok {
  78.                 key, value, err := callFunc(fieldValue, methodName)
  79.                 if err != nil {
  80.                     return nil, err
  81.                 }
  82.                 res[key] = value
  83.                 continue
  84.             }
  85.             res[tagVal] = fieldValue
  86.         case reflect.Struct:
  87.             _, ok := fieldValue.Type().MethodByName(methodName)
  88.             if ok {
  89.                 key, value, err := callFunc(fieldValue, methodName)
  90.                 if err != nil {
  91.                     return nil, err
  92.                 }
  93.                 res[key] = value
  94.                 continue
  95.             }
  96.             // recursive
  97.             deepRes, deepErr := StructToMap(fieldValue.Interface(), tag, methodName)
  98.             if deepErr != nil {
  99.                 return nil, deepErr
  100.             }
  101.             if flag&flagDive != 0 {
  102.                 for k, v := range deepRes {
  103.                     res[k] = v
  104.                 }
  105.             } else {
  106.                 res[tagVal] = deepRes
  107.             }
  108.         case reflect.Map:
  109.             res[tagVal] = fieldValue
  110.         case reflect.Chan:
  111.             res[tagVal] = fieldValue
  112.         case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int, reflect.Int64:
  113.             res[tagVal] = fieldValue.Int()
  114.         case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint, reflect.Uint64:
  115.             res[tagVal] = fieldValue.Uint()
  116.         case reflect.Float32, reflect.Float64:
  117.             res[tagVal] = fieldValue.Float()
  118.         case reflect.String:
  119.             res[tagVal] = fieldValue.String()
  120.         case reflect.Bool:
  121.             res[tagVal] = fieldValue.Bool()
  122.         case reflect.Complex64, reflect.Complex128:
  123.             res[tagVal] = fieldValue.Complex()
  124.         case reflect.Interface:
  125.             res[tagVal] = fieldValue.Interface()
  126.         default:
  127.         }
  128.     }
  129.     return
  130. }
  132. // readTag read tag with format `json:"name,omitempty"` or `json:"-"`
  133. // For now, only supports above format
  134. func readTag(f reflect.StructField, tag string) (string, int) {
  135.     val, ok := f.Tag.Lookup(tag)
  136.     fieldTag := ""
  137.     flag := 0
  139.     // no tag, use field name
  140.     if !ok {
  141.         return f.Name, flag
  142.     }
  143.     opts := strings.Split(val, ",")
  145.     fieldTag = opts[0]
  146.     for i := 1; i < len(opts); i++ {
  147.         switch opts[i] {
  148.         case OptIgnore:
  149.             flag |= flagIgnore
  150.         case OptOmitempty:
  151.             flag |= flagOmiEmpty
  152.         case OptDive:
  153.             flag |= flagDive
  154.         }
  155.     }
  157.     return fieldTag, flag
  158. }
  160. // call function
  161. func callFunc(fv reflect.Value, methodName string) (string, interface{}, error) {
  162.     methodRes := fv.MethodByName(methodName).Call([]reflect.Value{})
  163.     if len(methodRes) != methodResNum {
  164.         return "", nil, fmt.Errorf("wrong method %s, should have 2 output: (string,interface{})", methodName)
  165.     }
  166.     if methodRes[0].Kind() != reflect.String {
  167.         return "", nil, fmt.Errorf("wrong method %s, first output should be string", methodName)
  168.     }
  169.     key := methodRes[0].String()
  170.     return key, methodRes[1], nil
  171. }

创建 to_map_test.go 文件,写入代码

  1. package struct_to_map_test
  3. import (
  4.     "encoding/json"
  5.     "reflect"
  6.     "strconv"
  7.     "strings"
  8.     "testing"
  9.     "time"
  11.     "github.com/liangyaopei/structmap"
  12. )
  14. const timeLayout = "2006-01-02 15:04:05"
  16. type Profile struct {
  17.     Experience string    `map:"experience"`
  18.     Date       time.Time `map:"time"`
  19. }
  21. // its own toMap method
  22. func (p Profile) StructToMap() (key string, value interface{}) {
  23.     return "time", p.Date.Format(timeLayout)
  24. }
  26. type MySlice []int
  28. // its own toMap method
  29. func (a MySlice) StructToMap() (string, interface{}) {
  30.     key := "array"
  31.     b := strings.Builder{}
  32.     if len(a) == 0 {
  33.         return key, b.String()
  34.     }
  35.     for i := 0; i < len(a); i++ {
  36.         b.WriteString(strconv.Itoa(a[i]) + ",")
  37.     }
  38.     return key, b.String()
  39. }
  41. func TestCallMethod(t *testing.T) {
  42.     arr := MySlice{1, 2, 3}
  43.     v := reflect.ValueOf(&arr)
  44.     typ := v.Type()
  45.     t.Logf("type:%v,value:%v", v.Type(), v)
  46.     methodName := "StructToMap"
  47.     method, ok := typ.MethodByName(methodName)
  48.     t.Logf("method:%v,ok:%v", method, ok)
  49.     methodRes := v.MethodByName(methodName).Call([]reflect.Value{})
  50.     key := methodRes[0].String()
  51.     resValue := methodRes[1].String()
  52.     t.Logf("key:%s,value:%v", key, resValue)
  53. }
  55. // alias type
  56. type Gender int
  58. const (
  59.     male   Gender = 1
  60.     female Gender = 2
  61. )
  63. // Dive struct
  64. type GithubPage struct {
  65.     URL  string `map:"url"`
  66.     Star int    `map:"star"`
  67. }
  69. type StructNoDive struct {
  70.     NoDive int
  71. }
  73. // User is used for demonstration
  74. type User struct {
  75.     Name      string       `map:"name,omitempty"`        // string
  76.     Email     *string      `map:"email_ptr,omitempty"`   // pointer
  77.     MyGender  Gender       `map:"gender,omitempty"`      // type alias
  78.     Github    GithubPage   `map:"github,dive,omitempty"` // struct dive
  79.     NoDive    StructNoDive `map:"no_dive,omitempty"`     // no dive struct
  80.     MyProfile Profile      `map:"my_profile,omitempty"`  // struct implements its own method
  81.     Arr       []int        `map:"arr,omitempty"`         // normal slice
  82.     MyArr     MySlice      `map:"my_arr,omitempty"`      // slice implements its own method
  83. }
  85. func newUser() User {
  86.     name := "user"
  87.     email := "yaopei.liang@foxmail.com"
  88.     myGender := male
  89.     MyGithub := GithubPage{
  90.         URL:  "https://github.com/liangyaopei",
  91.         Star: 1,
  92.     }
  93.     NoDive := StructNoDive{NoDive: 1}
  94.     dateStr := "2020-07-21 12:00:00"
  95.     date, _ := time.Parse(timeLayout, dateStr)
  96.     profile := Profile{
  97.         Experience: "my experience",
  98.         Date:       date,
  99.     }
  100.     arr := []int{1, 2, 3}
  101.     myArr := MySlice{11, 12, 13}
  102.     return User{
  103.         Name:      name,
  104.         Email:     &email,
  105.         MyGender:  myGender,
  106.         Github:    MyGithub,
  107.         NoDive:    NoDive,
  108.         MyProfile: profile,
  109.         Arr:       arr,
  110.         MyArr:     myArr,
  111.     }
  112. }
  114. func TestStructToMap(t *testing.T) {
  115.     user := newUser()
  116.     tag := "map"
  117.     methodName := "StructToMap"
  118.     res, err := structmap.StructToMap(&user, tag, methodName)
  119.     if err != nil {
  120.         t.Errorf("struct to map:%s", err.Error())
  121.         return
  122.     }
  123.     for k, v := range res {
  124.         t.Logf("k:%v,v:%v", k, v)
  125.     }
  126. }
  128. type benchmarkUser struct {
  129.     Name    string `json:"name"`
  130.     Age     int    `json:"age"`
  131.     Address string `json:"address"`
  132.     Contact string `json:"contact"`
  133. }
  135. func newBenchmarkUser() benchmarkUser {
  136.     return benchmarkUser{
  137.         Name:    "name",
  138.         Age:     18,
  139.         Address: "github address",
  140.         Contact: "github contact",
  141.     }
  142. }
  144. func BenchmarkStructToMapByJson(b *testing.B) {
  145.     user := newBenchmarkUser()
  146.     b.ResetTimer()
  147.     for i := 0; i < b.N; i++ {
  148.         data, _ := json.Marshal(&user)
  149.         m := make(map[string]interface{})
  150.         json.Unmarshal(data, &m)
  151.     }
  152. }
  154. func BenchmarkStructToMapByToMap(b *testing.B) {
  155.     user := newBenchmarkUser()
  156.     tag := "json"
  157.     methodName := ""
  158.     b.ResetTimer()
  159.     for i := 0; i < b.N; i++ {
  160.         structmap.StructToMap(&user, tag, methodName)
  161.     }
  162. }