type Person struct {
  Name string `mapstructure:"userName"`
}

type Student struct {
  Person `mapstructure:",squash"`
  Age int 
}

type Student struct {
  Name  string
  Age   int
  Other map[string]interface{} `mapstructure:",remain"`
}

// mapstructure.go
type Metadata struct {
  Keys   []string  // 解碼成功的鍵
  Unused []string  // 源數(shù)據(jù)中存在，但目標結構中不存在的鍵
  Unset  []string  // 未設定的（源數(shù)據(jù)中缺失的）鍵
}

  p := &Student{
    Name: "Mike",
    Age:  12,
  }
  var m map[string]interface{}
  mapstructure.Decode(p, &m)

type DecoderConfig struct {
    // 若設定，則在任何解碼或類型轉換（設定了WeaklyTypedInput）前調用；對于設定了squash的內(nèi)嵌字段，整體調用一次；若返回錯誤，則整個解碼失敗
    DecodeHook DecodeHookFunc
    // 若設定，則源數(shù)據(jù)中存在未使用字段時，報錯
    ErrorUnused bool
    // 若設定，則有字段未設定時，報錯
    ErrorUnset bool
    // 若設定，則在設定字段前先清空（對于map等類型會先清理掉舊數(shù)據(jù)）
    ZeroFields bool
    // 若設定，支持若類型間的轉換
    WeaklyTypedInput bool
    // Squash will squash embedded structs. 
    Squash bool
    // Metadata is the struct that will contain extra metadata about
    // the decoding. If this is nil, then no metadata will be tracked.
    Metadata *Metadata
    // Result is a pointer to the struct that will contain the decoded
    // value.
    Result interface{}
    // The tag name that mapstructure reads for field names. This
    // defaults to "mapstructure"
    TagName string
    // IgnoreUntaggedFields ignores all struct fields without explicit
    // TagName, comparable to `mapstructure:"-"` as default behaviour.
    IgnoreUntaggedFields bool
    // MatchName is the function used to match the map key to the struct
    // field name or tag. Defaults to `strings.EqualFold`. This can be used
    // to implement case-sensitive tag values, support snake casing, etc.
    MatchName func(mapKey, fieldName string) bool
}

    Name string
    Age  int
}
func decoderConfig() {
    m := map[string]interface{}{
        "name": 123,
        "age":  "12",
        "job":  "programmer",
    }
    var p Person
    var metadata mapstructure.Metadata
    decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
        WeaklyTypedInput: true,
        Result:           &p,
        Metadata:         &metadata,
    })
    if err != nil {
        log.Fatal(err)
    }
    err = decoder.Decode(m)
    if err == nil {
        log.Printf("Result: %#v", p)
        log.Printf("keys:%#v, unused:%#v\n", metadata.Keys, metadata.Unused)
    } else {
        log.Println("decode fail:", err)
    }
}

import "github.com/mitchellh/mapstructure"
type DataBasic struct {
    DataId     string `json:"dataId"`
    UpdateTime int64  `json:"updateTime"`
}
type AddedData struct {
    DataBasic `mapstructure:",squash"`
    Tag string `json:"tag"`
    AddParams map[string]any `json:"addParams"`
}
type messageData struct {
    Action    int    `json:"action"`
    SeqId     uint64 `json:"seqId"`
    Data      any    `json:"data"`
}
func decodeData() {
    add := &AddedData{
        DataBasic: DataBasic{
            DataId:     "a2",
            UpdateTime: time.Now().UnixMilli(),
        },
        Tag: "tag",
        AddParams:  map[string]any{"dataId": "c2", "otherId": "t2"},
    }
    data := &messageData{
        Action: 1,
        Data:   add,
    }
    js, err := json.Marshal(data)
    if err != nil {
        log.Printf("marshal fail: %v", err)
        return
    }
    got := &messageData{}
    err = json.Unmarshal(js, got)
    if err != nil {
        log.Printf("unmarshal fail: %v", err)
        return
    }
    param := new(AddedData)
    err = mapstructure.Decode(got.Data, param)
    if err != nil {
        log.Printf("unmarshal fail: %v", err)
        return
    }
    log.Printf("param: %+v", param)
}