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

IT行业相对于一般传统行业，发展更新速度更快，一旦停止了学习，很快就会被行业所淘汰。所以我们需要踏踏实实的不断学习，精进自己的技术，尤其是初学者。今天golang学习网给大家整理了《Go中从1601-01-01开始计算time.Time》，聊聊，我们一起来看看吧！

我正在尝试解析 .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

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

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

edit2：最后我需要时间。给定时间戳的时间

解决方案

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，我将其添加到“最少迭代”标题中。

如果您不需要之前的日期，例如 1900 年，为什么不将日期移至 1900 年呢？

因此，您从 ndx 中取出 int64，将其移位从 1601 到 1900 的差异，除以 100，然后根据新纪元进行计算。没有循环，应该非常快速和准确

好了，本文到此结束，带大家了解了《Go中从1601-01-01开始计算time.Time》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！