datetime - Go中从1601-01-01开始计算time.Time

Question

我正在尝试解析 .ndx 文件。其中包含一个 64 位值，表示自 1601 年 1 月 1 日(UTC)以来 100 纳秒间隔的数量。这是 python 中的实现:https://github.com/mekh/jtv2xmltv/blob/master/jtv2xml.py#L31

package main

import (
    "fmt"
    "time"
)

func main() {
    var timestamp int64
    timestamp = 132118740000000000

    delta := time.Duration(timestamp)*time.Microsecond
    fmt.Println(delta)

    seconds, _ := divmod(timestamp, 1000000)
    hours, seconds := divmod(seconds, 3600)
    delta = time.Duration(hours)*time.Hour
    fmt.Println(delta)

    layout := "2006-01-02"
    start, _ := time.Parse(layout, "1601-01-01")

    fmt.Println(start.Add(delta))
}

func divmod(numerator, denominator int64) (quotient, remainder int64) {
    quotient = numerator / denominator // integer division, decimals are truncated
    remainder = numerator % denominator
    return
}

https://play.golang.org/p/--zQUtJN5Lh

看起来增量变量溢出，即使按小时设置也是如此。有什么办法可以计算吗？

编辑:在文档 https://golang.org/pkg/time/#Duration 中找到

A Duration represents the elapsed time between two instants as an int64 nanosecond count. The representation limits the largest representable duration to approximately 290 years.

是否有持续时间超过 290 年的第 3 方套餐？

EDIT2:最后我需要时间。给定时间戳的时间

Answer 1

time.Duration 是 int64表示持续时间(以纳秒为单位)的值。如上所述，最大值为 int64大约是290年，所以不能用它来代表更长的持续时间。

最简单、幼稚的解决方案

一个简单的解决方案是将您的输入转换为 time.Duration ，这将代表实际持续时间的百分之一，因为输入以 100 纳秒为单位。您可以将此持续时间添加到以引用日期开始的时间:1601-01-01 UTC一百次，你就完成了:

func getTime(input int64) time.Time {
    t := time.Date(1601, 1, 1, 0, 0, 0, 0, time.UTC)
    d := time.Duration(input)
    for i := 0; i < 100; i++ {
        t = t.Add(d)
    }
    return t
}

测试它:

fmt.Println(getTime(132118740000000000))

输出(在 Go Playground 上尝试):

2019-09-02 05:00:00 +0000 UTC

优化的朴素解决方案

是的，上述解决方案有一个 100 次迭代的循环，这可能不是最佳的。

加快上述速度的一种方法是减少迭代次数。如果输入不是“非常”大，我们可以这样做。例如，如果输入乘以 2 也适合 int64 ，我们可以将它预先乘以 2 ，那么我们只需要 50 次迭代。同样，如果input*10也适合 int64 ，我们可以将它预先乘以 10然后我们只需要 10 次迭代。

输入为 100 纳秒单位。 100可被 100, 50, 25, 20, 10, 5, 4, 2整除，因此为了不丢失任何纳秒，我们可以检查这些因子，如果输入乘以这些因子仍然适合 int64 ，如果是这样，我们可以将迭代次数除以它。在最好的情况下(如果持续时间小于2.9年，我们可以将迭代次数减少到1)。

这样做的示例:

var divisors = []int64{100, 50, 25, 20, 10, 5, 4, 2}

func getTime(input int64) time.Time {
    iterations := 100
    for _, div := range divisors {
        if input <= math.MaxInt64/div {
            input *= div
            iterations /= int(div)
            break
        }
    }

    t := time.Date(1601, 1, 1, 0, 0, 0, 0, time.UTC)
    d := time.Duration(input)
    for i := 0; i < iterations; i++ {
        t = t.Add(d)
    }
    return t
}

这将输出相同的内容，请在Go Playground上尝试一下。在本例中迭代次数仅为 2。

最少迭代次数

与上面的解决方案类似，但在每次迭代中，我们都会以尽可能最大的持续时间增加时间。即:time.Duration(math.MaxInt64) ，但由于输入以 100 纳秒为单位，准确地说，我们将使用 time.Duration(math.MaxInt64).Truncate(100 * time.Nanosecond) 。我们继续这样做，直到剩余持续时间小于最大值，这将是获得我们正在寻找的时刻的最后添加。另外，我们也不需要第一个寻找最大除数的循环(可以减少迭代次数)。

func getTime(input int64) time.Time {
    maxd := time.Duration(math.MaxInt64).Truncate(100 * time.Nanosecond)
    maxdUnits := int64(maxd / 100) // number of 100-ns units

    t := time.Date(1601, 1, 1, 0, 0, 0, 0, time.UTC)
    for input > maxdUnits {
        t = t.Add(maxd)
        input -= maxdUnits
    }
    if input != 0 {
        t = t.Add(time.Duration(input * 100))
    }
    return t
}

输出再次相同。试试这个 Go Playground .

该解决方案保证最少的迭代。例如。如果持续时间小于 290 年，则会有一个 time.Add()称呼。如果持续时间在 290 到 580 年之间，则会有 2 time.Add()来电等

请注意，最后的time.Add()称我们相乘input通过100将 100 纳秒单位转换为纳秒。这总是会成功，因为只要它大于maxdUnits，之前的循环就会递减它。 。我们也只将此称为最终time.Add()如果还有东西需要添加，以确保最少的迭代。实际上，这可能总是正确的，所以这个 if可以省略:即使 input是0，加零不会改变t ，我将其添加到“最少迭代”标题中。