• 企业400电话
  • 微网小程序
  • AI电话机器人
  • 电商代运营
  • 全 部 栏 目

    企业400电话 网络优化推广 AI电话机器人 呼叫中心 网站建设 商标✡知产 微网小程序 电商运营 彩铃•短信 增值拓展业务
    Golang自定义结构体转map的操作

    在Golang中,如何将一个结构体转成map? 本文介绍两种方法。第一种是是使用json包解析解码编码。第二种是使用反射,使用反射的效率比较高,代码在这里。如果觉得代码有用,可以给我的代码仓库一个star。

    假设有下面的一个结构体

    func newUser() User {
     name := "user"
     MyGithub := GithubPage{
     URL: "https://github.com/liangyaopei",
     Star: 1,
     }
     NoDive := StructNoDive{NoDive: 1}
     dateStr := "2020-07-21 12:00:00"
     date, _ := time.Parse(timeLayout, dateStr)
     profile := Profile{
     Experience: "my experience",
     Date:    date,
     }
     return User{
     Name:   name,
     Github:  MyGithub,
     NoDive:  NoDive,
     MyProfile: profile,
     }
    }
     
    type User struct {
     Name   string    `map:"name,omitempty"`    // string
     Github  GithubPage  `map:"github,dive,omitempty"` // struct dive
     NoDive  StructNoDive `map:"no_dive,omitempty"`   // no dive struct
     MyProfile Profile   `map:"my_profile,omitempty"` // struct implements its own method
    }
     
    type GithubPage struct {
     URL string `map:"url"`
     Star int  `map:"star"`
    }
     
    type StructNoDive struct {
     NoDive int
    }
     
    type Profile struct {
     Experience string  `map:"experience"`
     Date    time.Time `map:"time"`
    }
     
    // its own toMap method
    func (p Profile) StructToMap() (key string, value interface{}) {
     return "time", p.Date.Format(timeLayout)
    }

    json包的marshal,unmarshal

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

    data, _ := json.Marshal(user)
    m := make(map[string]interface{})
    json.Unmarshal(data, m)

    优势

    使用简单 劣势

    效率比较慢

    不能支持一些定制的键,也不能支持一些定制的方法,例如将struct的域展开等。

    使用反射

    本文实现了使用反射将结构体转成map的方法。通过标签(tag)和反射,将上文示例的newUser()返回的结果转化成下面的一个map。

    其中包含struct的域的展开,定制化struct的方法。

    map[string]interface{}{
     "name":  "user",
     "no_dive": StructNoDive{NoDive: 1},
      // dive struct field
     "url":   "https://github.com/liangyaopei",
     "star":  1,
      // customized method
     "time":  "2020-07-21 12:00:00",
    }

    实现思路 源码解析

    1.标签识别。

    使用readTag方法读取域(field)的标签,如果没有标签,使用域的名字。然后读取tag中的选项。目前支持3个选项

    '-':忽略当前这个域

    'omitempty' : 当这个域的值为空,忽略这个域

    'dive' : 递归地遍历这个结构体,将所有字段作为键

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

    const (
     OptIgnore  = "-"
     OptOmitempty = "omitempty"
     OptDive   = "dive"
    )
     
    const (
     flagIgnore = 1  iota
     flagOmiEmpty
     flagDive
    )
     
    func readTag(f reflect.StructField, tag string) (string, int) {
     val, ok := f.Tag.Lookup(tag)
     fieldTag := ""
     flag := 0
     
     // no tag, use field name
     if !ok {
     return f.Name, flag
     }
     opts := strings.Split(val, ",")
     
     fieldTag = opts[0]
     for i := 1; i  len(opts); i++ {
     switch opts[i] {
     case OptIgnore:
      flag |= flagIgnore
     case OptOmitempty:
      flag |= flagOmiEmpty
     case OptDive:
      flag |= flagDive
     }
     }
     return fieldTag, flag
    }

    2.结构体的域(field)的遍历。

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

    for i := 0; i  t.NumField(); i++ {
        ...
        switch fieldValue.Kind() {
     case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int, reflect.Int64:
      res[tagVal] = fieldValue.Int()
     case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint, reflect.Uint64:
      res[tagVal] = fieldValue.Uint()
     case reflect.Float32, reflect.Float64:
      res[tagVal] = fieldValue.Float()
     case reflect.String:
      res[tagVal] = fieldValue.String()
     case reflect.Bool:
      res[tagVal] = fieldValue.Bool()
     default:
     }
      }
    }

    3.内嵌结构体的转换

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

    for i := 0; i  t.NumField(); i++ {
     fieldType := t.Field(i)
     
     // ignore unexported field
     if fieldType.PkgPath != "" {
      continue
     }
     // read tag
     tagVal, flag := readTag(fieldType, tag)
     
     if flagflagIgnore != 0 {
      continue
     }
     
     fieldValue := v.Field(i)
     if flagflagOmiEmpty != 0  fieldValue.IsZero() {
      continue
     }
     
     // ignore nil pointer in field
     if fieldValue.Kind() == reflect.Ptr  fieldValue.IsNil() {
      continue
     }
     if fieldValue.Kind() == reflect.Ptr {
      fieldValue = fieldValue.Elem()
     }
     
     // get kind
     switch fieldValue.Kind() {
     case reflect.Struct:
      _, ok := fieldValue.Type().MethodByName(methodName)
      if ok {
      key, value, err := callFunc(fieldValue, methodName)
      if err != nil {
       return nil, err
      }
      res[key] = value
      continue
      }
      // recursive
      deepRes, deepErr := StructToMap(fieldValue.Interface(), tag, methodName)
      if deepErr != nil {
      return nil, deepErr
      }
      if flagflagDive != 0 {
      for k, v := range deepRes {
       res[k] = v
      }
      } else {
      res[tagVal] = deepRes
      }
     default:
     }
      }
      ...
    }
     
    // call function
    func callFunc(fv reflect.Value, methodName string) (string, interface{}, error) {
     methodRes := fv.MethodByName(methodName).Call([]reflect.Value{})
     if len(methodRes) != methodResNum {
     return "", nil, fmt.Errorf("wrong method %s, should have 2 output: (string,interface{})", methodName)
     }
     if methodRes[0].Kind() != reflect.String {
     return "", nil, fmt.Errorf("wrong method %s, first output should be string", methodName)
     }
     key := methodRes[0].String()
     return key, methodRes[1], nil
    }

    4.array,slice类型的转换

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

    switch fieldValue.Kind() {
     case reflect.Slice, reflect.Array:
      _, ok := fieldValue.Type().MethodByName(methodName)
      if ok {
      key, value, err := callFunc(fieldValue, methodName)
      if err != nil {
       return nil, err
      }
      res[key] = value
      continue
      }
          res[tagVal] = fieldValue
          ....
    }

    5.其他类型

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

    switch fieldValue.Kind() {
     ...
     case reflect.Map:
      res[tagVal] = fieldValue
     case reflect.Chan:
      res[tagVal] = fieldValue
     case reflect.Interface:
      res[tagVal] = fieldValue.Interface()
     default:
     }

    以上为个人经验,希望能给大家一个参考,也希望大家多多支持脚本之家。如有错误或未考虑完全的地方,望不吝赐教。

    您可能感兴趣的文章:
    • golang 如何用反射reflect操作结构体
    • golang 实现两个结构体复制字段
    • golang通过反射设置结构体变量的值
    • Golang空结构体struct{}用途,你知道吗
    • golang修改结构体中的切片值方法
    • golang 结构体初始化时赋值格式介绍
    • 解决golang结构体tag编译错误的问题
    上一篇:golang 结构体初始化时赋值格式介绍
    下一篇:golang 实现struct、json、map互相转化
  • 相关文章
  • 

    © 2016-2020 巨人网络通讯 版权所有

    《增值电信业务经营许可证》 苏ICP备15040257号-8

    Golang自定义结构体转map的操作 Golang,自定义,结构,体转,