Go 封送/解封后本地时间减少52秒

我在本地解析时间，将其封送到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

差值：52s

编组：“0000-01-01T08:00:00-07:33”

这是在linux上运行的，Edmonton/Mountain是我的本地时间，因此我猜它无法识别位置并显示偏移量两次

-733-733

。当我调用local时，由于某种原因，解析后的一个始终会丢失52秒

---

我希望时间会匹配。我的时钟是不是离它所参考的远程时钟还有52秒？你默认为伪日期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"

0000-01-01 08:00:00+0000 UTC
时间A:0000-01-01 08:00:00+0000 UTC，时间B:0000-01-01 08:00:00+0000 UTC
差值：0
编组：“0000-01-01T08:00:00Z”

在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年不存在52秒的差异

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

json。解封

可用

---

可以肯定的是，在任何代码中都没有时钟的引用，不管是远程的还是其他的，它只是在操纵值

这就是为什么如果你真的关心秒或时区之类的事情，那么用这种方式存储时间是个坏主意的原因之一。但是数据库中的日期时间字段非常吸引人。。。