时间范围内数组元素的标准化方法

一分耕耘，一分收获！既然都打开这篇《时间范围内数组元素的标准化方法》，就坚持看下去，学下去吧！本文主要会给大家讲到等等知识点，如果大家对本文有好的建议或者看到有不足之处，非常欢迎大家积极提出！在后续文章我会继续更新Golang相关的内容，希望对大家都有所帮助！

我正在尝试标准化一个时间范围内的元素数组。假设您有 20 笔银行交易发生在 2022 年 1 月 1 日

transaction  1 - 2022/01/01
transaction  2 - 2022/01/01
...
transaction 20 - 2022/01/01

除了它们发生的日期之外，我们没有其他数据，但我们仍然希望为它们分配一天中的一个小时，因此它们结束为：

transaction  1 - 2022/01/01 00:00
transaction  2 - 2022/01/01 ??:??
...
transaction 20 - 2022/01/01 23:59

在 go 中，我有一个函数尝试计算元素数组中索引的一天中某个时间的标准化：

func normal(start, end time.time, arraysize, index float64) time.time {
    delta := end.sub(start)
    minutes := delta.minutes()

    duration := minutes * ((index+1) / arraysize)

    return start.add(time.duration(duration) * time.minute)
}

但是，我在 2022/1/1 00:00 到 2022/1/1 23:59 的时间范围内意外计算出 4 个元素数组中索引 0 的 2022/1/1 05:59 ，相反，我希望看到 2022/1/1 00:00。在这些条件下唯一能正常工作的是索引 3。

那么，我的标准化做错了什么？

编辑：

这是由 @icza 修复的函数

func timeindex(min, max time.time, entries, position float64) time.time {
    delta := max.sub(min)
    minutes := delta.minutes()

    if position < 0 {
        position = 0
    }

    duration := (minutes * (position / (entries - 1)))

    return min.add(time.duration(duration) * time.minute)
}

有一个例子：假设我们的开始和结束日期是 2022/01/01 00:00 - 2022/01/01 00:03，我们的银行交易数组中有 3 个条目，我们希望获取第 3 号交易的标准化时间（数组中的 2）：

result := timeindex(time.date(2022, time.january, 1, 0, 0, 0, 0, time.utc), time.date(2022, time.january, 1, 0, 3, 0, 0, time.utc), 3, 2)

由于开始时间和结束时间之间只有 4 分钟（从 00:00 到 00:03），并且想要查找数组（大小 3）中最后一个条目（索引 2）的标准化时间，结果应该是：

fmt.Printf("%t", result.Equal(time.Date(2022, time.January, 1, 0, 3, 0, 0, time.UTC))
// prints "true"

或范围内的最后一分钟，即 00:03。

这是一个可重现的示例：https://go.dev/play/p/ezwkqanv1at

正确答案

在 n 点之间有 n-1 段。这意味着，如果您想在插值中包含 start 和 end，则时间段数（即 delta）为 arraysize - 1。

此外，如果将 1 添加到 index，则结果不可能是 start （您将跳过 00:00）。

所以正确的算法是这样的：

func normal(start, end time.time, arraysize, index float64) time.time {
    minutes := end.sub(start).minutes()

    duration := minutes * (index / (arraysize - 1))

    return start.add(time.duration(duration) * time.minute)
}

在 go playground 上尝试一下。

另请注意，如果您有很多交易（按照一天中的分钟数排列，大约一千次），您可能很容易最终会出现多个具有相同时间戳（相同小时和分钟）的交易。如果您想避免这种情况，请使用比分钟更小的精度，例如秒或毫秒：

func normal(start, end time.time, arraysize, index float64) time.time {
    sec := end.sub(start).seconds()

    duration := sec * (index / (arraysize - 1))

    return start.add(time.duration(duration) * time.second)
}

是的，这将导致时间戳的秒数也不一定为零，但将确保更高的交易数量具有不同的、唯一的时间戳。

如果您的交易数量级接近一天的秒数（即 86400），那么您可以完全删除此“单位”并使用 time.duration 本身（即纳秒）。即使对于最大数量的事务，这也将保证时间戳的唯一性：

func normal(start, end time.time, arraysize, index float64) time.time {
    delta := float64(end.sub(start))

    duration := delta * (index / (arraysize - 1))

    return start.add(time.duration(duration))
}

用 100 万笔交易对此进行测试，以下是前 15 个时间部分（它们仅在亚秒部分延迟）：

0 - 00:00:00.00000
1 - 00:00:00.08634
2 - 00:00:00.17268
3 - 00:00:00.25902
4 - 00:00:00.34536
5 - 00:00:00.43170
6 - 00:00:00.51804
7 - 00:00:00.60438
8 - 00:00:00.69072
9 - 00:00:00.77706
10 - 00:00:00.86340
11 - 00:00:00.94974
12 - 00:00:01.03608
13 - 00:00:01.12242
14 - 00:00:01.20876
15 - 00:00:01.29510
16 - 00:00:01.38144
17 - 00:00:01.46778
18 - 00:00:01.55412
19 - 00:00:01.64046

在 go playground 上尝试一下这个。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。