如何在 for 循环中创建持续时间 -（不匹配类型 int 和 time.Duration）

Question

我有一个循环，我从 time.Time 开始，我要添加一分钟。

 for idx := range keys {
    var a = idx * time.Minute
    var t = tInit.Add(time.Minute * a)
    fmt.Println(t, idx)


 }

这是我的错误

invalid operation: idx * time.Minute (mismatched types int and time.Duration)

Answer 1

数值运算的操作数必须具有相同的类型。 转换的int值idx的time.Duration ： var a = time.Duration(idx) * time.Minute

Answer 2

作为其他编程语言的开发人员，我发现这是最违反直觉和不合逻辑的做法。 我最近10年在Scala工作，可以这么简单：

val a = idx minutes

相比之下，Go 方式：

var a = time.Duration(idx) * time.Minute

更冗长，但这不会是世界末日。

问题在于，如果您想要获得另一个 Duration 作为结果，则将 Duration 与另一个 Duration 相乘没有任何意义，因为从物理角度来看，这将以秒的平方来衡量。

根据文档 time.Minute 是一个常数：

const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)

所有这些都是根据 Duration 类型定义的，它是 int64 的别名：

type Duration int64

据我所知，将 integer 文字与这些常量中的每一个相乘是非常好的，毕竟这就是每个常量相对于其他常量的定义方式。

因此，回顾一下为什么60 * time.Second是有效的语法（并且非常有意义），但是：

var secondsInAMinute := 60

var oneMinute = secondsInAMinute * time.Second

是无效的。 这没有任何意义。

所有这些常量都是 Duration 类型。 这意味着它们是以时间为单位测量的（准确地说是一纳秒的倍数）。

因此，似乎“正确”的方法（在编译和工作的意义上是正确的）没有任何物理意义。 让我们再看看这个：

var a = time.Duration(idx) * time.Minute

所以，我们将 time.Duration(idx) 与 time.Minute 相乘。

time.Minute的类型是 Duration ，应该用时间单位来衡量。 在物理学中，公认的时间单位是秒。 似乎 Go 使用 integer 纳秒，所以 time.Minute 代表持续时间，在内部以纳秒表示。 没关系。

问题是 time.Duration time.Duration(idx)还将 integer idx“转换”为持续时间，因此在物理学中它也将表示为时间单位，如秒。 因此，相应地，我认为 time.Duration(idx) 表示 Go 中的idx nanoseconds 。

所以，基本上，当我们写time.Duration(idx) * time.Minute时，我们将idx nanoseconds （idx * 0.0000000001 秒）乘以one minute （60 秒）。

因此，从物理角度来看time.Duration(idx) * time.Minute将表示idx * 0.000000001 seconds * 60 seconds 。 或者，简化为idx * 0.00000006 seconds squared 。

现在，在哪个世界中idx * 0.00000006 seconds squared等于idx * 1 minute ？

所以，现在我知道，在 Go 中，如果你想对持续时间应用乘数，你必须将该持续时间乘以另一个持续时间，并在你的脑海中除以one millisecond ，这样所有这些混乱仍然可以产生任何类型的物理意义。

我知道所有这些单位不一致都是“数字运算的操作数必须具有相同类型”的结果。 约束。 但这并不能使它更合乎逻辑或不那么烦人。 我认为应该取消对 Go 语言的限制。

但是，对于任何在我的解释中迷失的人，让我们通过一个具体的代码示例看看这一切是多么不合逻辑：

package main

import (
    "fmt"
    "time"
)

func main() {
    var oneMinute = 1 * time.Minute
    var oneNanosecond = 1 * time.Nanosecond

    var oneMinuteTimesOneNanoSecond = oneMinute * oneNanosecond
    
    fmt.Println(oneMinuteTimesOneNanoSecond)
}

结果正是我对这种荒谬的时间计算方式的预期：

1m0s

我会学会忍受这个，但我永远不会喜欢它。