在 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

看起来 delta 变量溢出，即使按小时设置也是如此。有没有办法计算这个？

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

Duration 将两个瞬间之间经过的时间表示为 int64 纳秒计数。该表示将最大可表示持续时间限制为大约 290 年。

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

EDIT2：最后我需要 time.Time 给定的时间戳

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用100100纳秒单位转换为纳秒。这总是会成功，因为只要它大于 ，之前的循环就会递减它maxdUnits。我们也只time.Add()在还有待添加的内容时才将其称为 final ，以确保最少的迭代。在实践中，这可能总是正确的，因此if可以省略：即使input是 0，添加零也不会改变t，我将它添加到“最少迭代”标题中。