time.Since() 有月份和年份

Question

我正在尝试像这样转换时间戳：

2015-06-27T09:34:22+00:00

格式化后的某个时间，所以它会说 9 个月前 1 天 2 小时 30 分 2 秒。

类似的东西。

我使用了 time.Parse 和 time.Since 来达到这个目的：

6915h7m47.6901559s

但是我该如何从那里转换呢？我的想法是这样的：

for hours > 24 {
        days++
        hours -= 24
}

但这样做的问题是，这对月份来说并不准确，因为月份可能有 28、30 和 31 天。

有没有更好的方法来实现我想要的？

Answer 1

像这样的东西会起作用，可能不是最有效的，但它和你得到的一样准确：

func main() {
    a := time.Date(2015, 10, 15, 0, 0, 0, 0, time.UTC)
    b := time.Date(2016, 11, 15, 0, 0, 0, 0, time.UTC)
    fmt.Println(monthYearDiff(a, b))
}

func monthYearDiff(a, b time.Time) (years, months int) {
    m := a.Month()
    for a.Before(b) {
        a = a.Add(time.Hour * 24)
        m2 := a.Month()
        if m2 != m {
            months++
        }
        m = m2
    }
    years = months / 12
    months = months % 12
    return
}

playground

Answer 2

前言： 我在 github.com/icza/gox, see timex.Diff().

发布了这个实用程序

一个月中的天数取决于日期，就像一年中的天数（闰年）一样。

如果您使用 time.Since() to get the elapsed time since a time.Time value, or when you calculate the difference between 2 time.Time values using the Time.Sub() method, the result is a time.Duration 会丢失时间上下文（因为 Duration 只是以纳秒为单位的时差）。这意味着您无法准确、明确地计算 Duration 值的年、月等差异。

正确的解决方案必须计算时间上下文中的差异。您可以计算每个字段（年、月、日、小时、分钟、秒）的差异，然后将结果归一化为没有任何负值。如果它们之间的关系不是预期的，也建议交换 Time 值。

归一化意味着如果一个值是负数，添加该字段的最大值并将下一个字段减 1。例如，如果 seconds 是负数，添加 60 并减少 minutes by 1. 需要注意的一件事是在标准化天数差异（月中天数）时，必须应用正确月份中的天数。这可以很容易地用这个小技巧计算出来：

// Max days in year y1, month M1
t := time.Date(y1, M1, 32, 0, 0, 0, 0, time.UTC)
daysInMonth := 32 - t.Day()

这背后的逻辑是 32 天数大于任何月份的最大天数。它将自动归一化（额外的天数滚动到下个月，天数适当减少）。当我们从 32 中减去归一化后的天数时，我们会得到该月的最后一天。

时区处理：

只有当我们传入的两个时间值都在同一时区时，差异计算才会给出正确的结果（time.Location). We incorporate a check into our function: if this is not the case, we "convert" one of the time value to be in the same location as the other using the Time.In()方法：

if a.Location() != b.Location() {
    b = b.In(a.Location())
}

这是计算年、月、日、小时、分钟、秒的差异的解决方案：

func diff(a, b time.Time) (year, month, day, hour, min, sec int) {
    if a.Location() != b.Location() {
        b = b.In(a.Location())
    }
    if a.After(b) {
        a, b = b, a
    }
    y1, M1, d1 := a.Date()
    y2, M2, d2 := b.Date()

    h1, m1, s1 := a.Clock()
    h2, m2, s2 := b.Clock()

    year = int(y2 - y1)
    month = int(M2 - M1)
    day = int(d2 - d1)
    hour = int(h2 - h1)
    min = int(m2 - m1)
    sec = int(s2 - s1)

    // Normalize negative values
    if sec < 0 {
        sec += 60
        min--
    }
    if min < 0 {
        min += 60
        hour--
    }
    if hour < 0 {
        hour += 24
        day--
    }
    if day < 0 {
        // days in month:
        t := time.Date(y1, M1, 32, 0, 0, 0, 0, time.UTC)
        day += 32 - t.Day()
        month--
    }
    if month < 0 {
        month += 12
        year--
    }

    return
}

一些测试：

var a, b time.Time
a = time.Date(2015, 5, 1, 0, 0, 0, 0, time.UTC)
b = time.Date(2016, 6, 2, 1, 1, 1, 1, time.UTC)
fmt.Println(diff(a, b)) // Expected: 1 1 1 1 1 1

a = time.Date(2016, 1, 2, 0, 0, 0, 0, time.UTC)
b = time.Date(2016, 2, 1, 0, 0, 0, 0, time.UTC)
fmt.Println(diff(a, b)) // Expected: 0 0 30 0 0 0

a = time.Date(2016, 2, 2, 0, 0, 0, 0, time.UTC)
b = time.Date(2016, 3, 1, 0, 0, 0, 0, time.UTC)
fmt.Println(diff(a, b)) // Expected: 0 0 28 0 0 0

a = time.Date(2015, 2, 11, 0, 0, 0, 0, time.UTC)
b = time.Date(2016, 1, 12, 0, 0, 0, 0, time.UTC)
fmt.Println(diff(a, b)) // Expected: 0 11 1 0 0 0

输出符合预期：

1 1 1 1 1 1
0 0 30 0 0 0
0 0 28 0 0 0
0 11 1 0 0 0

在 Go Playground 上试试。

计算您的年龄：

// Your birthday: let's say it's January 2nd, 1980, 3:30 AM
birthday := time.Date(1980, 1, 2, 3, 30, 0, 0, time.UTC)
year, month, day, hour, min, sec := diff(birthday, time.Now())

fmt.Printf("You are %d years, %d months, %d days, %d hours, %d mins and %d seconds old.",
    year, month, day, hour, min, sec)

示例输出：

You are 36 years, 3 months, 8 days, 11 hours, 57 mins and 41 seconds old.

围棋游乐场时间开始的神奇 date/time 是：2009-11-10 23:00:00 UTC
这是 Go 首次宣布的时间。让我们计算一下 Go 的年龄：

goAnnounced := time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC)
year, month, day, hour, min, sec := diff(goAnnounced, time.Now())
fmt.Printf("Go was announced "+
    "%d years, %d months, %d days, %d hours, %d mins and %d seconds ago.",
    year, month, day, hour, min, sec)

输出：

Go was announced 6 years, 4 months, 29 days, 16 hours, 53 mins and 31 seconds ago.

Answer 3

您可以尝试使用我的 date package, which includes the period package for working with ISO-style periods of time (Wikipedia).

Period 类型带有理解复数的格式化程序，打印可读字符串，例如“9 年，2 个月”和“3 小时，4 分钟，1 秒”，以及 ISO 等价物（"P9Y2M" 和 "PT3H4M1S").

当然，由于天数（由于夏令时）和月份（由于公历）的长度可变，周期很棘手。 period 包试图通过提供允许精确和不精确计算的 API 来帮助您。对于短时间（最多 ±3276 小时），它能够精确转换持续时间。

duration := time.Since(...)
p, _ := period.NewOf(duration)
str := p.String()

如果您需要较长跨度内的精确持续时间，则需要使用 Between 函数（体现了 icza 的出色回答）。

p := period.Between(t1, t2)
str := p.String()

Answer 4

如果您使用 PostgreSQL，您可以使用 age 函数轻松获得结果。

假设您有两个日期 a 和 b。

如icza所说，注意，a和b必须在同一时区。

首先，您可以使用两个参数调用 age，在您的例子中是日期 a 和日期 b。此函数return包含年、月、周、日、小时、分钟、秒和毫秒的间隔类型。

SELECT age('2016-03-31', '2016-06-30'); -- result is: -2 mons -30 days

第二种可能性是使用带有一个参数的age函数。结果也是一个间隔，但在这种情况下，age 从 current_date 中减去（在午夜）。假设今天是 2016/06/16:

SELECT age(timestamp '2016-06-30'); -- result is: -14 days

注意，需要 timestamp 关键字来转换日期“2016-06-30”。

更多的细节，你可以使用date_part或者直接extract函数return一个特定的字段（年，月，日...）。

SELECT date_part('month', age('2016-03-31', '2016-06-30')); --result is: -2
SELECT date_part('day',   age('2016-03-31', '2016-06-30')); --result is: -30

完整请求：

SELECT  
    date_part('year', diff) as year
  , date_part('month', diff) as month
  , date_part('day', diff) as day
FROM (
  SELECT age(timestamp '2016-06-30') AS diff
) as qdiff;

-- result is: 
-- year month day
-- 0    0     -14

（使用 CTE - 通用 Table 表达式）：

WITH qdiff AS (
  SELECT age(timestamp '2016-06-30') AS diff
)
SELECT  
    date_part('year', diff) as year
  , date_part('month', diff) as month
  , date_part('day', diff) as day
FROM qdiff

-- result is: 
-- year month day
-- 0    0     -14

PostgreSQL 文档（当前版本）：https://www.postgresql.org/docs/current/static/functions-datetime.html

Answer 5

提出的解决方案很好，但是遗漏了一件事。如果加上下面的例子，就可以看到效果：

a = time.Date(2015, 1, 11, 0, 0, 0, 0, time.UTC)
b = time.Date(2015, 3, 10, 0, 0, 0, 0, time.UTC)
fmt.Println(diff(a, b))
// Expected: 0 1 27 0 0 0
// Actual output: 0 1 30 0 0 0

playground

代码是根据第一个月（y1,M1）的总天数计算下一个不完整月份的剩余天数，但需要从后面日期月份的上个月开始计算（ y2,M2-1).

最终代码如下：

package main

import (
    "fmt"
    "time"
)

func DaysIn(year int, month time.Month) int {
    return time.Date(year, month, 0, 0, 0, 0, 0, time.UTC).Day()
}

func Elapsed(from, to time.Time) (inverted bool, years, months, days, hours, minutes, seconds, nanoseconds int) {
    if from.Location() != to.Location() {
        to = to.In(to.Location())
    }

    inverted = false
    if from.After(to) {
        inverted = true
        from, to = to, from
    }

    y1, M1, d1 := from.Date()
    y2, M2, d2 := to.Date()

    h1, m1, s1 := from.Clock()
    h2, m2, s2 := to.Clock()

    ns1, ns2 := from.Nanosecond(), to.Nanosecond()

    years = y2 - y1
    months = int(M2 - M1)
    days = d2 - d1

    hours = h2 - h1
    minutes = m2 - m1
    seconds = s2 - s1
    nanoseconds = ns2 - ns1

    if nanoseconds < 0 {
        nanoseconds += 1e9
        seconds--
    }
    if seconds < 0 {
        seconds += 60
        minutes--
    }
    if minutes < 0 {
        minutes += 60
        hours--
    }
    if hours < 0 {
        hours += 24
        days--
    }
    if days < 0 {
        days += DaysIn(y2, M2-1)
        months--
    }
    if days < 0 {
        days += DaysIn(y2, M2)
        months--
    }
    if months < 0 {
        months += 12
        years--
    }
    return
}

func main() {
    var a, b time.Time
    a = time.Date(2015, 5, 1, 0, 0, 0, 0, time.UTC)
    b = time.Date(2016, 6, 2, 1, 1, 1, 1, time.UTC)
    fmt.Println(Elapsed(a, b)) // Expected: 1 1 1 1 1 1

    a = time.Date(2016, 1, 2, 0, 0, 0, 0, time.UTC)
    b = time.Date(2016, 2, 1, 0, 0, 0, 0, time.UTC)
    fmt.Println(Elapsed(a, b)) // Expected: 0 0 30 0 0 0

    a = time.Date(2016, 2, 2, 0, 0, 0, 0, time.UTC)
    b = time.Date(2016, 3, 1, 0, 0, 0, 0, time.UTC)
    fmt.Println(Elapsed(a, b)) // Expected: 0 0 28 0 0 0

    a = time.Date(2015, 2, 11, 0, 0, 0, 0, time.UTC)
    b = time.Date(2016, 1, 12, 0, 0, 0, 0, time.UTC)
    fmt.Println(Elapsed(a, b)) // Expected: 0 11 1 0 0 0

    a = time.Date(2015, 1, 11, 0, 0, 0, 0, time.UTC)
    b = time.Date(2015, 3, 10, 0, 0, 0, 0, time.UTC)
    fmt.Println(Elapsed(a, b)) // Expected: 0 1 27 0 0 0

    a = time.Date(2015, 12, 31, 0, 0, 0, 0, time.UTC)
    b = time.Date(2015, 3, 1, 0, 0, 0, 0, time.UTC)
    fmt.Println(Elapsed(a, b)) // Expected: 0 9 30 0 0 0

    a = time.Date(2015, 12, 31, 0, 0, 0, 0, time.UTC)
    b = time.Date(2016, 3, 1, 0, 0, 0, 0, time.UTC)
    fmt.Println(Elapsed(a, b)) // Expected: 0 2 1 0 0 0

    a = time.Date(2015, 12, 31, 0, 0, 0, 0, time.UTC)
    b = time.Date(2016, 2, 28, 0, 0, 0, 0, time.UTC)
    fmt.Println(Elapsed(a, b)) // Expected: 0 2 1 0 0 0
}

playground

time.Since() 有月份和年份

time.Since() with months and years

time

duration

go