我正在尝试解析 .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:最后我需要时间。给定时间戳的时间
最佳答案
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
,我将其添加到“最少迭代”标题中。
关于datetime - Go中从1601-01-01开始计算time.Time,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/57901280/