Question

我在Local中解析时间，将其封送为JSON，取消封送，时间不再匹配。

timeA, _ := time.ParseInLocation("15:04", "8:00", time.Local)

jBytes, _ := json.Marshal(timeA)

var timeB time.Time

json.Unmarshal(jBytes, &timeB)

fmt.Printf("Time A: %+v, Time B: %+v\n", timeA, timeB)
fmt.Printf("Time A: %+v, Time B: %+v\n", timeA.Local(), timeB.Local())
fmt.Printf("Diff: %s\n", timeA.Sub(timeB))
fmt.Printf("Marshaled: %s", string(jBytes))

时间A：0000-01-01 08:00:00 -0733 LMT，时间B：0000-01-01 08:00:00 -0733 -0733

时间A：0000-01-01 08:00:00 -0733 LMT，时间B：0000-01-01 07:59:08 -0733 LMT

差异：52秒

封送：“ 0000-01-01T08：00：00-07：33”

这是在Linux上运行的，以Edmonton / Mountain作为本地时间，因此我想它无法识别位置，并且显示两次偏移量-733 -733。当我呼叫本地电话时，由于某种原因，经过解析的电话始终会丢失52秒。

我希望时间能够匹配。是我的时钟不在参考的远程时钟上52秒吗？

Answer 1

在1906年9月1日之前，您的时区差是UTC-7：33：52。 json.Unmarshal仅使用编组文本中的7:33作为偏移量，而不是7:33:52的正确值，因此它计算的time.Time值会减少52秒。但是您的time.Local实现似乎是正确的（在某种程度上，我们可以将回溯到第一年的时区差异描述为“正确”），并从time.Time值中减去完整的7:33:52 ，导致您所看到的差异。

如果输出：

fmt.Printf("Time A: %+v, Time B: %+v\n", timeA.UTC(), timeB.UTC())

使用您当前的代码，您应该会看到timeB的UTC时间已设置为非编组后的15:33:00，而timeA的UTC时间已设置为15:33： 52。我怀疑如果您在时间字符串中加上1906年之后的一年，您会发现这52秒的差异消失了。

例如：

package main

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

func main() {
    zone, err := time.LoadLocation("America/Edmonton")
    if err != nil {
        log.Fatalf("%v", err)
    }

    for _, timestring := range []string{
        "01 02 1905 8:00",
        "01 02 1907 8:00",
    } {
        timeA, err := time.ParseInLocation("01 02 2006 15:04", timestring, zone)
        if err != nil {
            log.Fatalf("%v", err)
        }

        jBytes, _ := json.Marshal(timeA)

        var timeB time.Time

        json.Unmarshal(jBytes, &timeB)

        fmt.Printf("Time string: %s\n", timestring)
        fmt.Printf("Time A: %+v, Time B: %+v\n", timeA, timeB)
        fmt.Printf("Time A: %+v, Time B: %+v\n", timeA.UTC(), timeB.UTC())
        fmt.Printf("Time A: %+v, Time B: %+v\n", timeA.In(zone), timeB.In(zone))
        fmt.Printf("Diff: %s\n", timeA.Sub(timeB))
        fmt.Printf("Marshaled: %s\n", string(jBytes))
    }
}

输出：

paul@mac:got$ ./got
Time string: 01 02 1905 8:00
Time A: 1905-01-02 08:00:00 -0733 LMT, Time B: 1905-01-02 08:00:00 -0733 -0733
Time A: 1905-01-02 15:33:52 +0000 UTC, Time B: 1905-01-02 15:33:00 +0000 UTC
Time A: 1905-01-02 08:00:00 -0733 LMT, Time B: 1905-01-02 07:59:08 -0733 LMT
Diff: 52s
Marshaled: "1905-01-02T08:00:00-07:33"
Time string: 01 02 1907 8:00
Time A: 1907-01-02 08:00:00 -0700 MST, Time B: 1907-01-02 08:00:00 -0700 -0700
Time A: 1907-01-02 15:00:00 +0000 UTC, Time B: 1907-01-02 15:00:00 +0000 UTC
Time A: 1907-01-02 08:00:00 -0700 MST, Time B: 1907-01-02 08:00:00 -0700 MST
Diff: 0s
Marshaled: "1907-01-02T08:00:00-07:00"
paul@mac:got$

表明在1905年有52秒的时差，但在时区差变为直线UTC-7：00：00之后的1907年没有。

简短答案：默认情况下，封送进json和从json解封似乎无法正确处理时区偏移量的秒数，因为封送字符串中的偏移量中没有秒数出现，这是json.Unmarshal唯一的时区信息可用。

在任何代码中，请确保没有引用时钟，无论是远程的还是其他的-它只是在操纵值。

Answer 2

如果当地时间可能基于太阳在正午的位置，则默认将伪日期设置为0000-01-01。

只需解析一天中的时间。例如，

package main

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

func main() {
    timeA, err := time.Parse("15:04", "8:00")
    fmt.Println(timeA, err)

    jBytes, _ := json.Marshal(timeA)

    var timeB time.Time

    json.Unmarshal(jBytes, &timeB)

    fmt.Printf("Time A: %+v, Time B: %+v\n", timeA, timeB)
    fmt.Printf("Diff: %s\n", timeA.Sub(timeB))
    fmt.Printf("Marshaled: %s\n", string(jBytes))
}

输出：

0000-01-01 08:00:00 +0000 UTC <nil>
Time A: 0000-01-01 08:00:00 +0000 UTC, Time B: 0000-01-01 08:00:00 +0000 UTC
Diff: 0s
Marshaled: "0000-01-01T08:00:00Z"

编组/解组后，当地时间损失了52秒

2 个答案: