11 篇博文 含有标签「golang」

type User struct {
    Name  string `json:"name,order:2"`
    Age   int    `json:"age,order:1"`
}

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
    "sort"
    "strconv"
    "strings"

    //orderedmap "github.com/wk8/go-ordered-map/v2"
    "github.com/iancoleman/orderedmap"
)

type User struct {
    Name  string `json:"name,order:3"`
    Age   int    `json:"age,order:2"`
    Score int    `json:"score,order:1"`
}

type Address struct {
    City    string `json:"city,order:10"`
    Street  string `json:"street,order:9"`
    ZipCode string `json:"zip_code,order:8"`
}

func main() {
    user := User{
        Name:  "Wen",
        Age:   30,
        Score: 100,
    }
    address := Address{
        City:    "Hangzhou",
        Street:  "XiHuDaDao",
        ZipCode: "10001",
    }

    // User構造体を指定した順序でJSONに変換
    userJSON, err := MarshalJSONWithOrder(user)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("User JSON:", string(userJSON))

    // Address構造体を指定した順序でJSONに変換
    addressJSON, err := MarshalJSONWithOrder(address)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println("Address JSON:", string(addressJSON))
}

// MarshalJSONWithOrder は構造体を指定した順序でJSONに変換する
// 構造体での指定方法： `json:"{struct field name},order:{integer}"`
// 指定例： `json:"name,order:10"`
func MarshalJSONWithOrder(obj interface{}) ([]byte, error) {
    val := reflect.ValueOf(obj)
    typ := reflect.TypeOf(obj)

    // ソート用のスライス
    var fields []fieldWithOrder

    // フィールドの数だけループ
    for i := 0; i < val.NumField(); i++ {
        fieldName := typ.Field(i).Name

        order := getTagValue(typ.Field(i), "json", "order")
        fields = append(fields, fieldWithOrder{
            Name:  fieldName,
            Order: order,
        })
    }

    // フィールドのソート
    sort.Slice(fields, func(i, j int) bool {
        return fields[i].Order < fields[j].Order
    })

    // ソート後の順序に従ってJSONを生成
    //result := orderedmap.New[string, any]()
    result := orderedmap.New()
    for _, f := range fields {
        //result[f.Name] = val.FieldByName(f.Name).Interface()
        result.Set(f.Name, val.FieldByName(f.Name).Interface())
    }

    // マーシャリング
    return json.Marshal(result)
}

// getTagValue は指定されたフィールドの指定されたタグの値を取得する
func getTagValue(field reflect.StructField, tag string, tagField string) int {
    tagValue, _ := field.Tag.Lookup(tag)

    // Split the tag string by ","
    tagParts := strings.Split(tagValue, ",")

    // Iterate through the tag parts to find the "order" value
    res := -1
    for _, part := range tagParts {
        // Check if the part starts with "order:"
        prefix := fmt.Sprintf("%s:", tagField)
        if strings.HasPrefix(part, prefix) {
            // Extract the numeric value after "order:"
            orderStr := strings.TrimPrefix(part, prefix)
            order, err := strconv.Atoi(orderStr)
            if err == nil {
                res = order
            }
        }
    }

    return res
}

// fieldWithOrder はソート用の構造体
type fieldWithOrder struct {
    Name  string
    Order int
}