当在文件中将“+”转义为“\u002b”时，从 JSON 解组“time.Time”失败，但在纯字符串中工作：无法将“\\u002b00:00\””解析为“Z07:00”

学习知识要善于思考，思考，再思考！今天golang学习网小编就给大家带来《当在文件中将“+”转义为“\u002b”时，从 JSON 解组“time.Time”失败，但在纯字符串中工作：无法将“\\u002b00:00\””解析为“Z07:00”》，以下内容主要包含等知识点，如果你正在学习或准备学习Golang，就都不要错过本文啦~让我们一起来看看吧，能帮助到你就更好了！

我正在解组到一个具有名为 foo 的 time.time 字段的结构：

type astructwithtime struct {
    foo time.time `json:"foo"`
}

我的期望是，解组后我会得到这样的结果：

var expectedstruct = astructwithtime{
    foo: time.date(2022, 9, 26, 21, 0, 0, 0, time.utc),
}

工作示例 1：将纯 json 对象转换为结构

这在使用纯 json 字符串时效果很好：

func test_unmarshalling_datetime_from_string(t *testing.t) {
    jsonstrings := []string{
        "{\"foo\": \"2022-09-26t21:00:00z\"}",           // trailing z = utc offset
        "{\"foo\": \"2022-09-26t21:00:00+00:00\"}",      // explicit zero offset
        "{\"foo\": \"2022-09-26t21:00:00\u002b00:00\"}", // \u002b is an escaped '+'
    }
    for _, jsonstring := range jsonstrings {
        var deserializedstruct astructwithtime
        err := json.unmarshal([]byte(jsonstring), &deserializedstruct)
        if err != nil {
            t.fatalf("could not unmarshal '%s': %v", jsonstring, err) // doesn't happen
        }
        if deserializedstruct.foo.unix() != expectedstruct.foo.unix() {
            t.fatal("unmarshalling is erroneous") // doesn't happen
        }
        // works; no errors
    }
}

工作示例 2：将 json 数组转换为切片

如果我将 json 数组中的相同对象解组到切片中，它也可以工作：

func test_unmarshalling_datetime_from_array(t *testing.t) {
    // these are just the same objects as above, just all in one array instead of as single objects/dicts
    jsonarraystring := "[{\"foo\": \"2022-09-26t21:00:00z\"},{\"foo\": \"2022-09-26t21:00:00+00:00\"},{\"foo\": \"2022-09-26t21:00:00\u002b00:00\"}]"
    var slice []astructwithtime // and now i need to unmarshal into a slice
    unmarshalerr := json.unmarshal([]byte(jsonarraystring), &slice)
    if unmarshalerr != nil {
        t.fatalf("could not unmarshal array: %v", unmarshalerr)
    }
    for index, instance := range slice {
        if instance.foo.unix() != expectedstruct.foo.unix() {
            t.fatalf("unmarshalling failed for index %v: expected %v but got %v", index, expectedstruct.foo, instance.foo)
        }
    }
    // works; no errors
}

不工作示例

现在，我使用从文件“test.json”读取的 json 进行相同的解组。它的内容是上面工作示例中的数组：

[
  {
    "foo": "2022-09-26t21:00:00z"
  },
  {
    "foo": "2022-09-26t21:00:00+00:00"
  },
  {
    "foo": "2022-09-26t21:00:00\u002b00:00"
  }
]

代码是：

func Test_Unmarshalling_DateTime_From_File(t *testing.T) {
    fileName := "test.json"
    fileContent, readErr := os.ReadFile(filepath.FromSlash(fileName))
    if readErr != nil {
        t.Fatalf("Could not read file %s: %v", fileName, readErr)
    }
    if fileContent == nil {
        t.Fatalf("File %s must not be empty", fileName)
    }
    var slice []AStructWithTime
    unmarshalErr := json.Unmarshal(fileContent, &slice)
    if unmarshalErr != nil {
        // ERROR HAPPENS HERE
        // Could not unmarshal file content test.json: parsing time "\"2022-09-26T21:00:00\\u002b00:00\"" as "\"2006-01-02T15:04:05Z07:00\"": cannot parse "\\u002b00:00\"" as "Z07:00"
        t.Fatalf("Could not unmarshal file content %s: %v", fileName, unmarshalErr)
    }
    for index, instance := range slice {
        if instance.Foo.Unix() != expectedStruct.Foo.Unix() {
            t.Fatalf("Unmarshalling failed for index %v in file %s. Expected %v but got %v", index, fileName, expectedStruct.Foo, instance.Foo)
        }
    }
}

由于转义的“+”而失败。

将时间“2022-09-26t21:00:00\u002b00:00”解析为“2006-01-02t15:04:05z07:00”：无法将“\u002b00:00”解析为“z07:00” ”

问题：为什么从文件中读取 time.time 字段时解组会失败，但从相同字符串读取相同 json 时却可以正常解组？

正确答案

我相信这是 encoding/json 中的错误。

https://www.json.org 处的 json 语法和 RFC 8259, Section 7: Strings 处的 ietf json 定义都规定 json 字符串可以包含 unicode 转义序列：

原始帖子中的 json 文档

{
  "foo": "2022-09-26t21:00:00\u002b00:00"
}   

使用 json.parse() 在 node.js 中完美解析和反序列化。

以下是演示该错误的示例：

package main

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

var document []byte = []byte(`
{
  "value": "2022-09-26t21:00:00\u002b00:00"
}
`)

func main() {

    deserializejsonastime()

    deserializejsonasstring()

}

func deserializejsonastime() {
    fmt.println("")
    fmt.println("deserializing json as time.time ...")

    type widget struct {
        value time.time `json: "value"`
    }

    expected := widget{
        value: time.date(2022, 9, 26, 21, 0, 0, 0, time.utc),
    }
    actual := widget{}
    err := json.unmarshal(document, &actual)

    switch {
    case err != nil:
        fmt.println("error deserializing json as time.time")
        fmt.println(err)
    case actual.value != expected.value:
        fmt.printf("unmarshalling failed: expected %v but got %v\n", expected.value, actual.value)
    default:
        fmt.println("sucess")
    }

}

func deserializejsonasstring() {
    fmt.println("")
    fmt.println("deserializing json as string ...")

    type widget struct {
        value string `json: "value"`
    }

    expected := widget{
        value: "2022-09-26t21:00:00+00:00",
    }
    actual := widget{}
    err := json.unmarshal(document, &actual)

    switch {
    case err != nil:
        fmt.println("error deserializing json as string")
        fmt.println(err)
    case actual.value != expected.value:
        fmt.printf("unmarshalling failed: expected %v but got %v\n", expected.value, actual.value)
    default:
        fmt.println("sucess")
    }

}

运行时 - 请参阅 https://goplay.tools/snippet/fHQQVJ8GfPp - 我们得到：

Deserializing JSON as time.Time ...
Error deserializing JSON as time.Time
parsing time "\"2022-09-26T21:00:00\\u002b00:00\"" as "\"2006-01-02T15:04:05Z07:00\"": cannot parse "\\u002b00:00\"" as "Z07:00"

Deserializing JSON as string ...
Sucess

由于将包含 unicode 转义序列的 json 字符串反序列化为 string 会产生正确/预期的结果 - 转义序列被转换为预期的符文/字节序列 - 问题似乎在于处理 time.time 反序列化的代码（它似乎没有反序列化为字符串，然后将字符串值解析为 time.time。

今天关于《当在文件中将“+”转义为“\u002b”时，从 JSON 解组“time.Time”失败，但在纯字符串中工作：无法将“\\u002b00:00\””解析为“Z07:00”》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！