How to Avoid Stack Overflow When Calling `json.Unmarshal` Within `UnmarshalJSON`?

Call json.Unmarshal Within UnmarshalJSON Without Causing Stack Overflow

Problem:
Custom implementations of UnmarshalJSON that call json.Unmarshal can lead to stack overflows.

Solution:

To avoid the stack overflow issue when calling json.Unmarshal within UnmarshalJSON, utilize the following technique:

1. Create a new type using the type keyword, making it a wrapper over the original type.
2. Type-convert the original value to an instance of the wrapper type.
3. Call json.Unmarshal on the wrapper type object to perform the unmarshaling.
4. After unmarshaling, perform any custom post-processing on the original type.

Reasoning:

Using the type keyword to create a new type effectively removes all methods from the original type. When the wrapper type is used during the unmarshaling process, the JSON decoder will not find a custom UnmarshalJSON implementation and will use the default one. This prevents the stack overflow issue.

Example:

Consider a Person type with an Age field:

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func (p *Person) UnmarshalJSON(data []byte) error {
    type personWrapper Person
    if err := json.Unmarshal(data, (*personWrapper)(p)); err != nil {
        return err
    }

    // Post-processing after unmarshaling:
    if p.Age < 0 {
        p.Age = 0
    }
    return nil
}

This technique allows for custom post-processing after unmarshaling, while avoiding the stack overflow issue associated with calling json.Unmarshal within UnmarshalJSON.

The above is the detailed content of How to Avoid Stack Overflow When Calling `json.Unmarshal` Within `UnmarshalJSON`?. For more information, please follow other related articles on the PHP Chinese website!