Местное время теряет 52 секунды после маршала / демаршала

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

До 1 сентября 1906 года разница часовых поясов составляла UTC-7: 33: 52.json.Unmarshal просто использует 7:33 в маршалированном тексте для смещения вместо правильного значения 7:33:52, поэтому вычисляемое им значение time.Time отключено на 52 секунды.Но ваша реализация time.Local, кажется, делает это правильно (в той степени, в которой мы можем описать разницу часовых поясов с задним числом до года 1 как «правильную») и вычтя все 7:33:52 из значения time.Time, что приводит кразницу вы видите.

Если вы выводите:

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

с вашим текущим кодом, вы должны увидеть, что время UTC для timeB устанавливается после 15:33:00 после демаршалинга, тогда как время UTCдля timeA устанавливается значение 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$ 

, показывающий, что 52-секундная разница существует для 1905 года, но не для 1907 года после того, как разница часовых поясов изменилась на прямую UTC-7: 00: 00.

Краткий ответ: маршалинг и демаршалинг от 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"