在处理 JSON 数据时，我们通常会使用 json.Unmarshal 函数将 JSON 字符串解析为 Go 语言中的结构体。然而，在 UnmarshalJSON 函数内部调用 json.Unmarshal 函数可能会导致堆栈溢出的错误。这是因为 UnmarshalJSON 函数在解析 JSON 数据时会再次调用自身，从而导致无限循环。为了避免这种情况，我们可以使用 json.Decoder 的 Decode 方法来解析 JSON 数据，而不是直接调用 json.Unmarshal 函数。这样做可以确保不会造成堆栈溢出的问题，保证代码的健壮性和性能。

问题内容

我想执行一些额外的步骤来初始化我的实现 UnmarshalJSON 中的数据结构。在该实现中调用 json.Unmarshal(b, type) 自然会导致堆栈溢出。

JSON 解码器不断尝试查找是否有自定义 UnmarshalJSON 实现，然后再次调用 json.Unmarshal。

还有其他方法可以做到这一点吗？只需调用底层默认实现就不会导致此问题？

解决方法

避免这种情况/防止这种情况的一种简单而常见的方法是使用 type 关键字，并使用类型 conversion 来传递该类型的值（该值可以如果是您的原始值，则可以进行类型转换，因为新类型将原始类型作为其基础类型）。

这是有效的，因为 type 关键字创建了一个新类型，并且新类型将具有零个方法（它不会“继承”基础类型的方法）。

这会产生一些运行时开销吗？否。引用自 规范：转换：

让我们看一个例子。我们有一个带有数字 Age 的 Person 类型，并且我们要确保 Age 不能为负数（小于 0）。

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

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

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

测试它：

var p *Person
fmt.Println(json.Unmarshal([]byte(`{"name":"Bob","age":10}`), &p))
fmt.Println(p)

fmt.Println(json.Unmarshal([]byte(`{"name":"Bob","age":-1}`), &p))
fmt.Println(p)

输出（在 Go Playground 上尝试）：

<nil>
&{Bob 10}
<nil>
&{Bob 0}

当然，相同的技术也适用于自定义封送处理（MarshalJSON()）：

func (p *Person) MarshalJSON() ([]byte, error) {
    // Pre-processing before marshaling:
    if p.Age < 0 {
        p.Age = 0
    }

    type person2 Person
    return json.Marshal((*person2)(p))
}

测试它：

p = &Person{"Bob", 10}
fmt.Println(json.NewEncoder(os.Stdout).Encode(p))
p = &Person{"Bob", -1}
fmt.Println(json.NewEncoder(os.Stdout).Encode(p))

输出（在同一个 Go Playground 示例中）：

{"name":"Bob","age":10}
<nil>
{"name":"Bob","age":0}
<nil>

一个非常相似的问题是，当您为 fmt 的自定义文本表示定义 String() string 方法时a> 包，并且您想要使用您修改的默认字符串表示形式。在这里阅读更多相关信息：t 和 *t 之间的区别