Golang自定義結構體轉map 第二個人的思路

以下內容轉載自 https://juejin.cn/post/6855129007193915400

在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 flag&flagIgnore != 0 {
			continue
		}

		fieldValue := v.Field(i)
		if flag&flagOmiEmpty != 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 flag&flagDive != 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:
		}
複製程式碼

關注下面的標籤，發現更多相似文章

作者：liangyaopei_
連結：https://juejin.cn/post/6855129007193915400
來源：掘金
著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。