如何在 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

我會學會忍受這個，但我永遠不會喜歡它。