Datetime 如何比较时间的时钟部分

我有一个时间。时间开始2019-07-02 01:00:00，我想写一个函数，告诉我时间。现在在开始时间之前的x分钟范围内忽略日期，只忽略时钟部分01:00:00

例如：

案例一

x = 30 minutes
time.Now() = "2020-11-20 00:45:00" //return True because 00:45:00 is 15 minutes before 01:00:00
time.Now() = "2020-11-20 00:20:00" //return False because 00:20:00 is 40 minutes before 01:00:00

案例二

x = 120 minutes
time.Now() = "2020-11-20 23:00:00" //return True because 23:00:00 is 120 minutes/2 hours before 01:00:00 (like 11pm is 2 hours before 1am of next day)
time.Now() = "2020-11-20 00:00:00" //return True
time.Now() = "2020-11-20 00:20:00" //return True
time.Now() = "2020-11-20 22:30:00" //returns False

案例三

x=1440 // 24 hours
always return true

我现在解决的只是案例一，而不是案例二。我查看了围棋的时间包，但没有找到任何有效的解决方法。有什么想法吗

now := time.Now()
trigger : = start.Sub(time.Minute * x))
triggerClock :=  trigger.Sub(trigger.Truncate(24 * time.Hour)) //extract clock portion
nowClock := now.Sub(now.Truncate(24*time.Hour)) //extract clock portion
diff := nowClock.Seconds() - triggerClock.Seconds()
if diff >= 0 && diff < x {
    return true
}

---

截断差异可能比截断时间更容易，例如：

package main

import (
    "log"
    "time"
)

const (
    day = time.Hour * 24
)

func within(t1, t2 time.Time, epsilon time.Duration) bool {
    delta := t1.Sub(t2)
    delta = (delta - delta.Truncate(day))

    // Take absolute value of delta.
    if delta < 0 {
        delta = -delta
    }

    // Reduce if the times are closer across midnight.
    if adjusted := day - delta; adjusted < delta {
        delta = adjusted
    }

    return delta <= epsilon
}

func main() {
    start := time.Date(2019, 7, 2, 01, 0, 0, 0, time.UTC)

    for _, tc := range []struct {
        t    time.Time
        e    time.Duration
        want bool
    }{
        {
            t:    time.Date(2020, 11, 20, 0, 45, 0, 0, time.UTC),
            e:    time.Minute * 30,
            want: true,
        },
        {
            t:    time.Date(2020, 11, 20, 0, 20, 0, 0, time.UTC),
            e:    time.Minute * 30,
            want: false,
        },
        {
            t:    time.Date(2020, 11, 20, 23, 0, 0, 0, time.UTC),
            e:    time.Minute * 120,
            want: true,
        },
        {
            t:    time.Date(2020, 11, 20, 0, 0, 0, 0, time.UTC),
            e:    time.Minute * 120,
            want: true,
        },
        {
            t:    time.Date(2020, 11, 20, 0, 20, 0, 0, time.UTC),
            e:    time.Minute * 120,
            want: true,
        },
        {
            t:    time.Date(2020, 11, 20, 22, 30, 0, 0, time.UTC),
            e:    time.Minute * 120,
            want: false,
        },
        {
            t:    time.Date(2020, 11, 20, 13, 0, 0, 0, time.UTC),
            e:    time.Hour * 24,
            want: true,
        },
    } {
        if within(start, tc.t, tc.e) != tc.want {
            log.Fatalf("test failed for %v, %v, %v", start, tc.t, tc.e)
        }
    }
}

---

您说您希望在24小时或更长时间内的任意x处返回true，但请注意，由于您希望在案例2中的第一个示例中给出的行为，因此在12小时或更长时间内的任意x处都将返回true，因为这是两次之间的最大距离，如果你在24小时内或在24小时内接受最接近的距离。

可能更容易截断差异，而不是时间，例如：

package main

import (
    "log"
    "time"
)

const (
    day = time.Hour * 24
)

func within(t1, t2 time.Time, epsilon time.Duration) bool {
    delta := t1.Sub(t2)
    delta = (delta - delta.Truncate(day))

    // Take absolute value of delta.
    if delta < 0 {
        delta = -delta
    }

    // Reduce if the times are closer across midnight.
    if adjusted := day - delta; adjusted < delta {
        delta = adjusted
    }

    return delta <= epsilon
}

func main() {
    start := time.Date(2019, 7, 2, 01, 0, 0, 0, time.UTC)

    for _, tc := range []struct {
        t    time.Time
        e    time.Duration
        want bool
    }{
        {
            t:    time.Date(2020, 11, 20, 0, 45, 0, 0, time.UTC),
            e:    time.Minute * 30,
            want: true,
        },
        {
            t:    time.Date(2020, 11, 20, 0, 20, 0, 0, time.UTC),
            e:    time.Minute * 30,
            want: false,
        },
        {
            t:    time.Date(2020, 11, 20, 23, 0, 0, 0, time.UTC),
            e:    time.Minute * 120,
            want: true,
        },
        {
            t:    time.Date(2020, 11, 20, 0, 0, 0, 0, time.UTC),
            e:    time.Minute * 120,
            want: true,
        },
        {
            t:    time.Date(2020, 11, 20, 0, 20, 0, 0, time.UTC),
            e:    time.Minute * 120,
            want: true,
        },
        {
            t:    time.Date(2020, 11, 20, 22, 30, 0, 0, time.UTC),
            e:    time.Minute * 120,
            want: false,
        },
        {
            t:    time.Date(2020, 11, 20, 13, 0, 0, 0, time.UTC),
            e:    time.Hour * 24,
            want: true,
        },
    } {
        if within(start, tc.t, tc.e) != tc.want {
            log.Fatalf("test failed for %v, %v, %v", start, tc.t, tc.e)
        }
    }
}

---

您说您希望在24小时或更长时间内的任意x处返回true，但请注意，由于您希望在案例2中的第一个示例中给出的行为，因此在12小时或更长时间内的任意x处都将返回true，因为这是两次之间的最大距离，如果您在24小时内或在24小时内接受最接近的距离。

有许多方法可以实现这一点，选择正确的方法取决于开始时间前x分钟的含义：

我假设你所说的时钟部分是指当天，或者，如果当前时间在时钟部分之后，则是明天。 夏令时的开始/结束可能会导致明显的答案可能不正确，但您需要指定在这些时间应该发生什么。 是否需要考虑时区？我现在假设没有，但值得考虑一下！。 我将通过计算目标和检查时间之间的分钟数来实现这一点，如下所示：

目标时间前的func分钟。时间，检查时间。时间整数{ t:=time.Datecheck.Year，check.Month，check.Day，target.Hour，target.Minute，target.Second，target.Nanosecond，target.Location 如果t.在检查之前{ t=time.Datecheck.Year，check.Month，check.Day+1，target.Hour，target.Minute，target.Second，target.Nanosecond，target.Location } 返回intt.Subcheck.Minutes }

---

在一些测试用例中尝试一下。

有很多方法可以实现这一点，选择正确的方法取决于开始时间前x分钟的含义：

我假设你所说的时钟部分是指当天，或者，如果当前时间在时钟部分之后，则是明天。 夏令时的开始/结束可能会导致明显的答案可能不正确，但您需要指定在这些时间应该发生什么。 是否需要考虑时区？我现在假设没有，但值得考虑一下！。 我将通过计算目标和检查时间之间的分钟数来实现这一点，如下所示：

目标时间前的func分钟。时间，检查时间。时间整数{ t:=time.Datecheck.Year，check.Month，check.Day，target.Hour，target.Minute，target.Second，target.Nanosecond，target.Location 如果t.在检查之前{ t=time.Datecheck.Year，check.Month，check.Day+1，target.Hour，target.Minute，target.Second，target.Nanosecond，target.Location } 返回intt.Subcheck.Minutes }

---

请在一些测试用例中试用。

您可以使用模板15:04:05解析日期的time fractionclock部分

我们想从现在开始减去，然后检查结果是否大于x

那给你

func rangeOf(x time.Duration, start time.Time, now time.Time) bool {
    if start.Before(now) {
        now = now.Add(-time.Hour * 24)
    }
    if start.Sub(now).Minutes() <= x.Minutes() {
        return true
    }

    return false
}

---

此处的所有测试用例

您可以使用模板15:04:05解析日期的时间分形时钟部分

我们想从现在开始减去，然后检查结果是否大于x

那给你

func rangeOf(x time.Duration, start time.Time, now time.Time) bool {
    if start.Before(now) {
        now = now.Add(-time.Hour * 24)
    }
    if start.Sub(now).Minutes() <= x.Minutes() {
        return true
    }

    return false
}

所有测试用例都在这里

func rangeOf(x time.Duration, start time.Time, now time.Time) bool {
    if start.Before(now) {
        now = now.Add(-time.Hour * 24)
    }
    if start.Sub(now).Minutes() <= x.Minutes() {
        return true
    }

    return false
}

func main() {
    x := 120 * time.Minute
    var now time.Time

    now, _ = time.Parse("15:04:05", "23:00:00")
    fmt.Printf("%t\n", rangeOf(x, start, now))

    now, _ = time.Parse("15:04:05", "00:00:00")
    fmt.Printf("%t\n", rangeOf(x, start, now))

    now, _ = time.Parse("15:04:05", "00:20:00")
    fmt.Printf("%t\n", rangeOf(x, start, now))

    now, _ = time.Parse("15:04:05", "22:30:00")
    fmt.Printf("%t\n", rangeOf(x, start, now))
}