Golang JSON serializing and deserializing strings deserializing to map[string]interface{}

json.Unmarshl Deserialization ： take json String to struct

func Unmarshal(data []byte, v interface{}) error

demand ： take json String to struct
1) Predefine json Corresponding structure type ;
2) call json.Unmarshl

func main() {
    //  The inverted quotation marks here indicate that you do not change your meaning , That is to say string type 
    resp := `{"code":0,"message":"success","grades":[{"gradeClass":" In grade one ","Score":{"chinese":99,"english":88}},{"gradeClass":" second grade ","Score":{"chinese":100,"english":98}}]}`
    var stu Student
    err := json.Unmarshal([]byte(resp), &stu)
    if err != nil {
        log.Println(err)
    }
    log.Println(stu)
    // 2021/08/12 23:37:19 {0 success [{ In grade one  {99 88}} { second grade  {100 98}}]}
}

type Student struct {
    Code    int         `json:"code"`    //  Use tag, Indicates correspondence json Field name 
    Message string      `json:"message"`
    Grades  []GradeType `json:"grades"`  //  Structure class array 
}
type GradeType struct {
    GradeClass string `json:"gradeClass"`
    Score      ScoreType
}
type ScoreType struct {
    Chinese int `json:"chinese"`
    English int `json:"english"`
}

json String is anti sequenced into map

//  Strong go interface Type to string type ( Be careful :  No  convert.ToJSONString)
    wordCloudJson := convert.ToString(data[0]["word_cloud_json"])

    words := make(map[string]interface{})
    err = json.Unmarshal([]byte(wordCloudJson), &words)
    if err != nil {
        logu.CtxError(ctx, error_code.ProcessError, "GetBrandWordCloud Unmarshal", "wordCloudJson:%v,error: %v", wordCloudJson, err)
        return result, err
    }

    for k, v := range words {
        result = append(result, &competition_detail.BrandWord{
            ProductPropertyValue: k,
            ProductFrequency:     convert.ToInt64(v),
        })
    }

    //  Descending order  TOP 100
    top(&result, 100)

among ,func ToString(i interface{}) string Code ：

// ToString  Strong go interface Type to string type 
func ToString(i interface{}) string {
    v, _ := ToStringE(i)
    return v
}



// ToStringE  Strong go interface Type to string,  Support error return value 
func ToStringE(i interface{}) (string, error) {
    i = indirectToStringerOrError(i)

    switch s := i.(type) {
    case string:
        return s, nil
    case bool:
        return strconv.FormatBool(s), nil
    case float64:
        return strconv.FormatFloat(s, 'f', -1, 64), nil
    case float32:
        return strconv.FormatFloat(float64(s), 'f', -1, 32), nil
    case int:
        return strconv.Itoa(s), nil
    case int64:
        return strconv.FormatInt(s, 10), nil
    case int32:
        return strconv.Itoa(int(s)), nil
    case int16:
        return strconv.FormatInt(int64(s), 10), nil
    case int8:
        return strconv.FormatInt(int64(s), 10), nil
    case uint:
        return strconv.FormatInt(int64(s), 10), nil
    case uint64:
        return strconv.FormatInt(int64(s), 10), nil
    case uint32:
        return strconv.FormatInt(int64(s), 10), nil
    case uint16:
        return strconv.FormatInt(int64(s), 10), nil
    case uint8:
        return strconv.FormatInt(int64(s), 10), nil
    case []byte:
        return string(s), nil
    case template.HTML:
        return string(s), nil
    case template.URL:
        return string(s), nil
    case template.JS:
        return string(s), nil
    case template.CSS:
        return string(s), nil
    case template.HTMLAttr:
        return string(s), nil
    case nil:
        return "", nil
    case fmt.Stringer:
        return s.String(), nil
    case error:
        return s.Error(), nil
    default:
        v := reflect.ValueOf(i)
        if method, ok := reflect.TypeOf(i).MethodByName("String"); ok && method.Type.NumIn() == 0 &&
            method.Type.NumOut() == 1 && method.Type.Out(0).Kind() == reflect.String {
            return method.Func.Call([]reflect.Value{v})[0].String(), nil
        }
        switch v.Kind() {
        case reflect.Func:
            fullName := runtime.FuncForPC(v.Pointer()).Name()
            ss := strings.Split(fullName, ".")
            if len(ss) > 0 {
                return ss[len(ss)-1], nil
            } else {
                return fullName, nil
            }
        case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
            return ToStringE(v.Uint())
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
            return ToStringE(v.Int())
        case reflect.Float64, reflect.Float32:
            return ToStringE(v.Float())
        case reflect.Bool:
            return ToStringE(v.Bool())
        case reflect.String:
            return v.String(), nil
        }
        return "", fmt.Errorf("unable to cast %#v of type %T to string", i, i)
    }
}

Reference material

https://blog.csdn.net/Sunny_Future/article/details/119656822