mapstructure公开了将一种任意Go类型转换为另一种Go类型的功能
地址：https://github.com/mitchellh/mapstructure
文档：https://godoc.org/github.com/mitchellh/mapstructure
ps:viper 使用了该包

包函数

func Decode(input interface{}, output interface{}) error deep copy

type Decoder

decoder 是一个自定义得解码器，可以提供更多得功能，但不常用

  1. type Decoder struct {
  2.     // contains filtered or unexported fields
  3. }

func NewDecoder(config DecoderConfig) (Decoder, error)
func (d *Decoder) Decode(input interface{}) error deep copy

type DecoderConfig

DecoderConfig是用于创建新解码器并允许定制解码的各个方面的配置

  1. type DecoderConfig struct {
  2.     // 钩子函数
  3.     DecodeHook DecodeHookFunc
  5.     // 如果errorusage为true，如果一个键没使用，会报错
  6.     ErrorUnused bool
  8.     // 如果设置为真，将在写入字段之前将它们归零
  9.     // 例如，在输入解码值之前，映射将被清空。如果这是假的，一个映射将被合并
  10.     ZeroFields bool
  12.     // 类型转换
  13.     // "weak" conversions:
  14.     //
  15.     //   - bools to string (true = "1", false = "0")
  16.     //   - numbers to string (base 10)
  17.     //   - bools to int/uint (true = 1, false = 0)
  18.     //   - strings to int/uint (base implied by prefix)
  19.     //   - int to bool (true if value != 0)
  20.     //   - string to bool (accepts: 1, t, T, TRUE, true, True, 0, f, F,
  21.     //     FALSE, false, False. Anything else is an error)
  22.     //   - empty array = empty map and vice versa
  23.     //   - negative numbers to overflowed uint values (base 10)
  24.     //   - slice of maps to a merged map
  25.     //   - single values are converted to slices if required. Each
  26.     //     element is weakly decoded. For example: "4" can become []int{4}
  27.     //     if the target type is an int slice.
  28.     //
  29.     WeaklyTypedInput bool
  31.     // Squash will squash embedded structs.  A squash tag may also be
  32.     // added to an individual struct field using a tag.  For example:
  33.     //
  34.     //  type Parent struct {
  35.     //      Child `mapstructure:",squash"`
  36.     //  }
  37.     Squash bool
  39.     // 元数据是将包含关于的额外元数据的结构解码。如果该值为nil，则不跟踪元数据。
  40.     Metadata *Metadata
  42.     // 结果
  43.     Result interface{}
  45.     // mapstructure读取字段名的标记名。默认为“mapstructure”
  46.     TagName string
  47. }

type DecodeHookFunc

  1. type DecodeHookFunc interface{}

func ComposeDecodeHookFunc(fs …DecodeHookFunc) DecodeHookFunc 将多个钩子合并
func StringToIPHookFunc() DecodeHookFunc 将字符串转换为net.IP的钩子
func StringToIPNetHookFunc() DecodeHookFunc 将字符串转换为net.IPNet的钩子
func StringToSliceHookFunc(sep string) DecodeHookFunc 通过seq将字符串转为切片
func StringToTimeDurationHookFunc() DecodeHookFunc 将字符串转为time.Time类型
func StringToTimeHookFunc(layout string) DecodeHookFunc 将字符串按layout格式转为time.Time类型

type Metadata

  1. type Metadata struct {
  2.     // 成功解码的key集合
  3.     Keys []string
  5.     // 在原始内容中有，但目标源中未定义，导致没解码的key集合
  6.     Unused []string
  7. }

例子

map转struct

  1. type Person struct {
  2.     Name   string
  3.     Age    int
  4.     Emails []string
  5.     Extra  map[string]string
  6. }
  8. input := map[string]interface{}{
  9.     "name":   "Mitchell",
  10.     "age":    91,
  11.     "emails": []string{"one", "two", "three"},
  12.     "extra": map[string]string{
  13.         "twitter": "mitchellh",
  14.     },
  15. }
  17. var result Person
  18. err := Decode(input, &result)
  19. if err != nil {
  20.     panic(err)
  21. }
  23. fmt.Printf("%#v", result)
  24. mapstructure.Person{Name:"Mitchell", Age:91, Emails:[]string{"one", "two", "three"}, Extra:map[string]string{"twitter":"mitchellh"}}

struct转map

  1. type User struct {
  2.     Name string
  3.     Age  int
  4. }
  6. func main2() {
  7.     u1 := User{"zhangsan", 20}
  8.     var result map[string]interface{}
  9.     err := mapstructure.Decode(u1, &result)
  10.     if err != nil {
  11.         panic(err)
  12.     }
  14.     fmt.Printf("%+v", result) // map[Age:20 Name:zhangsan]
  15. }

slice map 转 slice struct

  1. type Person1 struct {
  2.     Name   string
  3.     Age    int
  4.     Emails []string
  5.     Extra  map[string]string
  6. }
  8. func main() {
  9.     input1 := map[string]interface{}{
  10.         "name":   "input1",
  11.         "age":    91,
  12.         "emails": []string{"one", "two", "three"},
  13.         "extra": map[string]string{
  14.             "twitter": "mitchellh",
  15.         },
  16.     }
  18.     input2 := map[string]interface{}{
  19.         "name":   "input2",
  20.         "age":    91,
  21.         "emails": []string{"one", "two", "three"},
  22.         "extra": map[string]string{
  23.             "twitter": "mitchellh",
  24.         },
  25.     }
  27.     input := []map[string]interface{}{input1, input2}
  29.     var result []Person1
  30.     err := mapstructure.Decode(input, &result)
  31.     if err != nil {
  32.         panic(err)
  33.     }
  35.     fmt.Printf("%v", result)
  36. }
  37. [{input1 91 [one two three] map[twitter:mitchellh]} 
  38.  {input2 91 [one two three] map[twitter:mitchellh]}]

slice struct 转 slice struct

  1. type User1 struct {
  2.     Name string
  3.     Age  int
  4. }
  6. type User2 struct {
  7.     UName string `mapstructure:"name"` // 首字母的大小写不受影响
  8.     uAddr string
  9.     UAge  int `mapstructure:"Age"` // 首字母的大小写不受影响
  10. }
  12. func main() {
  13.     u1 := []User1{
  14.         {"zhangsan1", 20},
  15.         {"zhangsan2", 30},
  16.     }
  17.     var result []User2
  18.     err := mapstructure.Decode(u1, &result)
  19.     if err != nil {
  20.         panic(err)
  21.     }
  23.     fmt.Printf("%+v", result) // [{UName:zhangsan1 uAddr: UAge:20} {UName:zhangsan2 uAddr: UAge:30}]
  24. }

struct转struct（类型一致）

  1. type User struct {
  2.     Name string
  3.     Age  int
  4. }
  6. type User2 struct {
  7.     UName string `mapstructure:"name"` // 首字母的大小写不受影响
  8.     uAddr string
  9.     UAge  int `mapstructure:"Age"`  // 首字母的大小写不受影响
  10. }  
  12. func main() {
  13.     u1 := User{"zhangsan", 20}
  14.     var result User2
  15.     err := mapstructure.Decode(u1, &result)
  16.     if err != nil {
  17.         panic(err)
  18.     }
  20.     fmt.Printf("%+v", result)  // {UName:zhangsan uAddr: UAge:20}
  21. }

struct转struct（类型不一致）

  1. type User struct {
  2.     Name string
  3.     Age  int
  4. }
  6. type User3 struct {
  7.     UName string `mapstructure:"name"`
  8.     uAddr string
  9.     UAge  string `mapstructure:"Age"`
  10. }
  12. func main() {
  13.     u1 := User{"zhangsan", 20}
  14.     var result User3
  15.     config := &mapstructure.DecoderConfig{
  16.         WeaklyTypedInput: true,
  17.         Result:           &result,
  18.     }
  20.     decoder, err := mapstructure.NewDecoder(config)
  21.     if err != nil {
  22.         panic(err)
  23.     }
  25.     err = decoder.Decode(u1)
  26.     if err != nil {
  27.         panic(err)
  28.     }
  30.     fmt.Printf("%+v", result)  // {UName:zhangsan uAddr: UAge:20}
  31. }

Metadata

  1. type Person struct {
  2.     Name string
  3.     Age  int
  4. }
  7. input := map[string]interface{}{
  8.     "name":  "Mitchell",
  9.     "age":   91,
  10.     "email": "foo@bar.com",
  11. }
  14. var md Metadata
  15. var result Person
  16. config := &DecoderConfig{
  17.     Metadata: &md,
  18.     Result:   &result,
  19. }
  21. decoder, err := NewDecoder(config)
  22. if err != nil {
  23.     panic(err)
  24. }
  26. if err := decoder.Decode(input); err != nil {
  27.     panic(err)
  28. }
  30. fmt.Printf("Unused keys: %#v", md.Unused) // Unused keys: []string{"email"}