如果映射是引用类型，为什么 json.Unmarshal 需要指向映射的指针？

Question

我在使用 json.Unmarshal 时遇到了以下怪癖。运行以下代码时，出现错误json: Unmarshal(non-pointer map[string]string)

func main() {
    m := make(map[string]string)
    data := `{"foo": "bar"}`
    err := json.Unmarshal([]byte(data), m)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(m)
}

Playground

查看documentation 的json.Unmarshal，似乎没有迹象表明需要指针。我能找到的最接近的是以下行

Unmarshal 解析 JSON 编码的数据并将结果存储在 v 指向的值中。

关于 Unmarshal 遵循的 map 协议的行同样不清楚，因为它没有引用指针。

为了将 JSON 对象解组为映射，Unmarshal 首先建立要使用的映射。如果映射为 nil，Unmarshal 分配一个新映射。否则 Unmarshal 会重用现有映射，保留现有条目。然后 Unmarshal 将 JSON 对象中的键值对存储到映射中。映射的键类型必须是字符串、整数或实现 encoding.TextUnmarshaler。

为什么我必须传递一个指向 json.Unmarshal 的指针，尤其是在映射已经是引用类型的情况下？我知道如果我将映射传递给函数，并将数据添加到映射，映射的基础数据将被更改（请参阅the following playground example），这意味着如果我将指针传递给地图。有人可以解决这个问题吗？

Answer 1

如文档中所述：

Unmarshal 使用 Marshal 使用的逆编码，根据需要分配映射、切片和指针，...

Unmarshal 可以分配变量（map、slice 等）。如果我们将map 而不是指针 传递给map，那么新分配的map 将不会对调用者可见。以下示例 (Go Playground) 证明了这一点：

package main

import (
    "fmt"
)

func mapFunc(m map[string]interface{}) {
    m = make(map[string]interface{})
    m["abc"] = "123"
}

func mapPtrFunc(mp *map[string]interface{}) {
    m := make(map[string]interface{})
    m["abc"] = "123"

    *mp = m
}

func main() {
    var m1, m2 map[string]interface{}
    mapFunc(m1)
    mapPtrFunc(&m2)

    fmt.Printf("%+v, %+v\n", m1, m2)
}

其中的输出是：

map[], map[abc:123]

如果需求说函数/方法可以在必要时分配一个变量，并且新分配的变量需要对调用者可见，则解决方案将是：(a) 变量必须在函数的 return 声明或 (b) 可以将变量分配给函数/方法参数。因为在go 一切 都是按值传递的，在 (b) 的情况下，参数必须是 指针。下图说明了上述示例中发生的情况：

1. 首先，映射m1 和m2 都指向nil。
2. 调用mapFunc 会将m1 指向的值复制到m，结果m 也将指向nil 映射。
3. 如果在 (1) 中映射已经分配，​​那么在 (2) 中 底层映射数据结构 由m1 指向的地址（不是m1 的地址 em>) 将被复制到m。在这种情况下m1 和m 都指向同一个地图数据结构，因此通过m1 修改地图项也将可见 到m。
4. 在mapFunc 函数中，新地图被分配并分配给m。无法将其分配给m1。

如果是指针：

1. 调用mapPtrFunc时，m2的地址会被复制到mp。
2. 在mapPtrFunc 中，新映射被分配并分配给*mp（不是mp）。由于mp 是指向m2 的指针，因此将新映射分配给*mp 将更改m2 指向的值。注意mp的值不变，即m2的地址。

Answer 2

文档的另一个关键部分是：

为了将 JSON 解组为指针，Unmarshal 首先处理 JSON 是 JSON 文字 null。在这种情况下，Unmarshal 设置 指向零的指针。否则，Unmarshal 将 JSON 解组到 指针指向的值。如果指针为 nil，则 Unmarshal 为其分配一个新值以指向。

如果 Unmarshall 接受地图，则无论 JSON 是 null 还是 {}，它都必须使地图保持相同的状态。但是通过使用指针，现在指针被设置为nil 和它指向一个空映射之间是有区别的。

请注意，为了让 Unmarshall 能够“将指针设置为 nil”，您实际上需要传入一个指向映射指针的指针：

package main

import (
    "encoding/json"
    "fmt"
    "log"
)

func main() {
    var m *map[string]string
    data := `{}`
    err := json.Unmarshal([]byte(data), &m)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(m)

    data = `null`
    err = json.Unmarshal([]byte(data), &m)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(m)

    data = `{"foo": "bar"}`
    err = json.Unmarshal([]byte(data), &m)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(m)
}

这个输出：

&map[]
<nil>
&map[foo:bar]

Answer 3

您的观点与说“切片只不过是指针”没有什么不同。切片（和映射）使用指针使它们变得轻量，是的，但还有更多的东西可以使它们工作。例如，切片包含有关其长度和容量的信息。

至于为什么会这样，从代码的角度来看，json.Unmarshal的最后一行调用了d.unmarshal()，它执行了lines 176-179 of decode.go中的代码。它基本上说“如果值不是指针，或者是nil，则返回InvalidUnmarshalError。”

文档可能会更清楚一些事情，但请考虑以下几点：

1. 如果您不传递指向地图的指针，如何将 JSON null 值作为 nil 分配给地图？如果您需要修改地图本身（而不是地图中的项目）的能力，那么将指针传递给需要修改的项目是有意义的。在这种情况下，就是地图。
2. 或者，假设您将nil 映射传递给json.Unmarshal。在代码json.Unmarshal 使用最终调用make(map[string]string) 的等效项之后，值将根据需要解组。但是，您的函数中仍然有一个 nil 映射，因为您的映射没有指向任何内容。除了将指针传递给地图之外，没有其他方法可以解决此问题。

但是，假设不需要传递您的地图地址，因为“它已经是一个指针”，并且您已经初始化了地图，所以它不是nil。那会发生什么？好吧，如果我通过将第 176 行更改为 if rv.Kind() != reflect.Map && rv.Kind() != reflect.Ptr || rv.IsNil() { 来绕过我之前链接的行中的测试，那么这可能会发生：

`{"foo":"bar"}`: false map[foo:bar]
`{}`: false map[]
`null`: panic: reflect: reflect.Value.Set using unaddressable value [recovered]
    panic: interface conversion: string is not error: missing method Error

goroutine 1 [running]:
json.(*decodeState).unmarshal.func1(0xc420039e70)
    /home/kit/jstest/src/json/decode.go:172 +0x99
panic(0x4b0a00, 0xc42000e410)
    /usr/lib/go/src/runtime/panic.go:489 +0x2cf
reflect.flag.mustBeAssignable(0x15)
    /usr/lib/go/src/reflect/value.go:228 +0xf9
reflect.Value.Set(0x4b8b00, 0xc420012300, 0x15, 0x4b8b00, 0x0, 0x15)
    /usr/lib/go/src/reflect/value.go:1345 +0x2f
json.(*decodeState).literalStore(0xc420084360, 0xc42000e3f8, 0x4, 0x8, 0x4b8b00, 0xc420012300, 0x15, 0xc420000100)
    /home/kit/jstest/src/json/decode.go:883 +0x2797
json.(*decodeState).literal(0xc420084360, 0x4b8b00, 0xc420012300, 0x15)
    /home/kit/jstest/src/json/decode.go:799 +0xdf
json.(*decodeState).value(0xc420084360, 0x4b8b00, 0xc420012300, 0x15)
    /home/kit/jstest/src/json/decode.go:405 +0x32e
json.(*decodeState).unmarshal(0xc420084360, 0x4b8b00, 0xc420012300, 0x0, 0x0)
    /home/kit/jstest/src/json/decode.go:184 +0x224
json.Unmarshal(0xc42000e3f8, 0x4, 0x8, 0x4b8b00, 0xc420012300, 0x8, 0x0)
    /home/kit/jstest/src/json/decode.go:104 +0x148
main.main()
    /home/kit/jstest/src/jstest/main.go:16 +0x1af

导致该输出的代码：

package main

// Note "json" is the local copy of the "encoding/json" source that I modified.
import (
    "fmt"
    "json"
)

func main() {
    for _, data := range []string{
        `{"foo":"bar"}`,
        `{}`,
        `null`,
    } {
        m := make(map[string]string)
        fmt.Printf("%#q: ", data)
        if err := json.Unmarshal([]byte(data), m); err != nil {
            fmt.Println(err)
        } else {
            fmt.Println(m == nil, m)
        }
    }
}

关键在这里：

reflect.Value.Set using unaddressable value

因为您传递了地图的副本，所以它是不可寻址的（即它有一个临时地址，或者从低级机器的角度来看甚至没有地址）。我知道解决这个问题的一种方法（x := new(Type) 后跟*x = value，除了使用reflect 包），但它实际上并没有解决问题；您正在创建一个无法返回给调用者的本地指针并使用它而不是您的原始存储位置！

所以现在试试指针：

        if err := json.Unmarshal([]byte(data), m); err != nil {
            fmt.Println(err)
        } else {
            fmt.Println(m == nil, m)
        }

输出：

`{"foo":"bar"}`: false map[foo:bar]
`{}`: false map[]
`null`: true map[]

现在可以了。底线：如果对象本身可能被修改，则使用指针（并且文档说它可能会被修改，例如，如果在需要对象或数组（映射或切片）的地方使用 null。