實現(xiàn) MarshalJSON 和 UnmarshalJSON 可自定義 Go 結(jié)構(gòu)體的 JSON 序列化與反序列化，適用于處理非標準格式或兼容舊數(shù)據(jù)。2. 通過 MarshalJSON 控制輸出結(jié)構(gòu)，如轉(zhuǎn)換字段格式；3. 通過 UnmarshalJSON 解析特殊格式數(shù)據(jù)，如自定義日期；4. 注意避免遞歸調(diào)用導(dǎo)致的無限循環(huán)，可用類型別名繞過自定義方法。

In Go, you can customize how your structs are marshalled and unmarshalled to and from JSON by implementing the json.Marshaler and json.Unmarshaler interfaces. This gives you full control over the JSON serialization process — useful when dealing with non-standard formats, legacy APIs, or complex data types.

Implement json.Marshaler for Custom Marshalling

If you want to control how your type is converted to JSON, implement the MarshalJSON() method. This method should return the JSON-encoded bytes of your data.

Here's an example where we format a time field differently:

type Event struct {
    ID   int    `json:"id"`
    Date string `json:"date"` // custom format: "2024-Jan-01"
}

// MarshalJSON customizes how Event is serialized
func (e Event) MarshalJSON() ([]byte, error) {
    return json.Marshal(map[string]interface{}{
        "id":   e.ID,
        "date": strings.ReplaceAll(e.Date, "-", "_"), // just an example transform
    })
}

This lets you output JSON in any structure or format, even if it doesn't match the original fields directly.

Implement json.Unmarshaler for Custom Unmarshalling

To control how JSON is parsed into your type, implement UnmarshalJSON(data []byte). This method receives raw JSON and should populate the struct accordingly.

Example: parsing a date in a non-standard format:

func (e *Event) UnmarshalJSON(data []byte) error {
    var raw map[string]string
    if err := json.Unmarshal(data, &raw); err != nil {
        return err
    }

    e.ID, _ = strconv.Atoi(raw["id"])
    // Reverse our fake transformation
    e.Date = strings.ReplaceAll(raw["date"], "_", "-")
    return nil
}

Now when you use json.Unmarshal, your logic runs instead of the default behavior.

Use Cases and Tips

• Handling nullable or optional fields: You can interpret null values in custom ways, or treat missing fields as defaults.
• Version compatibility: Adapt old JSON formats to new structs without breaking changes.
• Embedded types: Be careful with recursion; avoid calling json.Marshal(e) inside MarshalJSON on the same type, or it will cause infinite loops. Use a type alias to bypass the custom method:

type Alias Event
return json.Marshal(&struct{ *Alias }{Alias: (*Alias)(e)})

This trick lets you use the default marshaler temporarily.

Basically, just define MarshalJSON and/or UnmarshalJSON on your type, and Go automatically uses them when processing JSON. It’s powerful and clean, especially for API integrations where you can’t control the input/output format.

以上是如何在Golang中為JSON創(chuàng)建自定義的騎士/Unmarshaller的詳細內(nèi)容。更多信息請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！