Go 标准库时间处理

发表于 | 分类于
字数统计: 1.5k | 阅读时长 ≈ 7

平时开发过程中，时间相关的操作用的还是很多的。接下来就与大家一起总结下与时间有关的操作，主要涉及到 time 包，核心数据结构是 time.Time，如下：

1
2
3
4
5
type Time struct {
    wall uint64
    ext  int64
    loc *Location
}

1. 获取时间相关函数

1.1 获取当前时间

1
2
3
4
5
6
7
8
9
10
11
12
// 返回当前时间，注意此时返回的是 time.Time 类型
now := time.Now()
fmt.Println(now)

// 当前时间戳
fmt.Println(now.Unix())

// 纳秒级时间戳
fmt.Println(now.UnixNano())

// 时间戳小数部分 单位：纳秒
fmt.Println(now.Nanosecond())

输出：

1
2
3
4
2022-12-25 09:19:37.135465 +0800 CST m=+0.004033001
1671931177
1671931177135465000
135465000

返回当前年月日时分秒、星期几、一年中的第几天等操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package main

import (
	"fmt"
	"time"
)

func main() {
	now := time.Now()

	// 返回日期
	year, month, day := now.Date()
	fmt.Printf("year:%d, month:%d, day:%d\n", year, month, day)
	//输出:year:2021, month:1, day:22
	// 年
	fmt.Println(now.Year())
	// 月
	fmt.Println(now.Month())
	// 日
	fmt.Println(now.Day())

	// 时分秒
	//Clock：返回由t指定的一天内的 时 分 秒
	hour, minute, second := now.Clock()
	fmt.Printf("hour:%d, minute:%d, second:%d\n", hour, minute, second)
	//输出:hour:10, minute:3, second:9
	// 时
	fmt.Println(now.Hour())
	// 分
	fmt.Println(now.Minute())
	// 秒
	fmt.Println(now.Second())

	// 返回星期
	//Weekday：返回由t指定的星期几
	fmt.Println(now.Weekday())
	spr := fmt.Sprintf("%d", now.Weekday()) //根据格式化说明符进行格式化并返回结果字符串
	fmt.Println("spr", spr)
	fmt.Printf("%d\n", now.Weekday())
	//返回一年中对应的第几天
	fmt.Println(now.YearDay())
	//返回时区
	fmt.Println(now.Location())

	// 返回一年中第几天
	fmt.Println(now.YearDay())
}

1.2 格式化时间

Go 语言提供了时间类型格式化函数 Format()，需要注意的是 Go 语言格式化时间模板不是常见的 Y-m-d H:i:s，而是 2006-01-02 15:04:05，也很好记忆(2006 1 2 3 4 5)

1
2
3
4
5
6
7
8
9
now := time.Now()

fmt.Println(now.Format("0102 030405 06 pm -0700")) //12小时制，加入时区
fmt.Println(now.Format("2006-01-02 15:04:05"))
fmt.Println(now.Format("2006-01-02 15:04:05 -0700")) //24小时制，加入时区
fmt.Println(now.Format("2006-01-02"))
fmt.Println(now.Format("15:03:04"))
fmt.Println(now.Format("2006/01/02 15:04"))
fmt.Println(now.Format("15:04 2006/01/02"))

2. 时间戳与日期字符串相互转化

时间戳怎么转成日期格式呢？需要先转成将时间戳转成 time.Time 类型再格式化成日期格式。

2.1 根据秒数、纳秒数返回 time.Time 类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import (
	"fmt"
	"time"
)

func main() {
	now := time.Now()
	layout := "2006-01-02 15:04:05"
	t := time.Unix(now.Unix(),0) // 参数分别是：秒数,纳秒数
	fmt.Println(t)
	fmt.Println(t.Format(layout))
	//2022-12-25 09:41:37 +0800 CST
	//2022-12-25 09:41:37
}

2.2 根据指定时间返回 time.Time 类型

使用函数 time.Date()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import (
	"fmt"
	"time"
)

func main() {
	now := time.Now()
	layout := "2006-01-02 15:04:05"

	//根据指定时间返回 time.Time 类型
	//分别指定年，月，日，时，分，秒，纳秒，时区
	t := time.Date(2022, time.Month(12), 25, 09, 41, 37, 0, now.Location())
	fmt.Println(t.Format(layout))
	//2022-12-25 09:41:37
}

2.3 日期字符串解析成 time.Time 类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import (
	"fmt"
	"time"
)

func main() {
	t, _ := time.ParseInLocation("2006-01-02 15:04:05", time.Now().Format("2006-01-02 15:04:05"), time.Local)
	fmt.Println("t", t)
	// 输出 t 2022-12-25 09:41:37 +0800 CST(北京时间)
	//time.Local 指定本地时间
	//time.Now:返回当前本地时间
	tt, _ := time.Parse("2006-01-02 15:04:05", time.Now().Format("2006-01-02 15:04:05"))
	fmt.Println("tt", tt)
	// 输出 tt 2022-12-25 09:41:37 +0000 UTC(世界协调时间)
	//ParselnLocation功能与parse类似，但两个重要的不同之处：
	//1.当缺少时区信息时，Parse将时间解释为UTC时间，而ParselnLocation将返回值得Location设置为loc(正在使用的区域)
	//2.当时间字符串提供了时区偏移量信息时，Parse会尝试去匹配本地时区，而ParselnLocation会去匹配loc
}

2.4 时间戳转日期

1
2
3
4
5
6
7
8
9
10
var startTime, endTime int64
startTime = 1671897600
endTime = 1671984000
eTime := time.Unix(endTime, 0)
sTime := time.Unix(startTime, 0)
startTimeday := sTime.Format("2006-01-02")
endTimeday := eTime.Format("2006-01-02")
fmt.Printf("%s\n%s", startTimeday, endTimeday)
//输出:startTimeday: 2022-12-25
//输出:endTimeday: 2022-12-26

2.5 日期转时间戳

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main

import (
	"fmt"
	"time"
)

func TimeStr2Time(Format, valueStr, locStr string) int64 {
	loc := time.Local
	if locStr != "" {
		loc, _ = time.LoadLocation(locStr) // 设置时区
	}
	if Format == "" {
		Format = "2006-01-02"
	}
	t, _ := time.ParseInLocation(Format, valueStr, loc)
	return t.Unix()
}

func main() {
	fmt.Println(TimeStr2Time("", "2022-12-25", ""))
}

3. 计算、比较日期

3.1 24小时之内的时间计算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
now := time.Now()
fmt.Println(now)

// 1小时1分1s之后
t1, _ := time.ParseDuration("1h1m1s")
fmt.Println(t1)
m1 := now.Add(t1)
fmt.Println(m1)

// 1小时1分1s之前
t2, _ := time.ParseDuration("-1h1m1s")
m2 := now.Add(t2)
fmt.Println(m2)

// 3小时之前
t3, _ := time.ParseDuration("-1h")
m3 := now.Add(t3 * 3)
fmt.Println(m3)

// 10 分钟之后
t4, _ := time.ParseDuration("10m")
m4 := now.Add(t4)
fmt.Println(m4)

// Sub 计算两个时间差
sub1 := now.Sub(m3)
fmt.Println(sub1.Hours())   // 相差小时数
fmt.Println(sub1.Minutes()) // 相差分钟数

3.2 24小时之外的时间计算

及到一天以外的时间计算，就需要用到 time.AddDate()，函数原型：

1
func (t Time) AddDate(years int, months int, days int) Time

比如我们想知道 一年一个月零一天 之后的时间，就可以这样：

1
2
3
4
now := time.Now()
fmt.Println(now)
m1 := now.AddDate(1,1,1)
fmt.Println(m1)

再比如，我们想获得 2 天之前时间：

1
2
3
4
now := time.Now()
fmt.Println(now)
m1 := now.AddDate(0,0,-2)
fmt.Println(m1)

3.3 日期比较

日期的比较总共有三种：之前、之后和相等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 如果 t 代表的时间点在 u 之前，返回真；否则返回假。
func (t Time) Before(u Time) bool

// 如果 t 代表的时间点在 u 之后，返回真；否则返回假。
func (t Time) After(u Time) bool

// 比较时间是否相等，相等返回真；否则返回假。
func (t Time) Equal(u Time) bool
now := time.Now()
fmt.Println(now)

// 1小时之后
t1, _ := time.ParseDuration("1h")
m1 := now.Add(t1)
fmt.Println(m1)

fmt.Println(m1.After(now))
fmt.Println(now.Before(m1))
fmt.Println(now.Equal(m1))

3.4 计算函数运行的时间

1
2
3
4
5
6
7
8
9
10
11
12
func compute() {
    start := time.Now()
    defer func() {
		sum := 0
		for i := 0; i < 100000000; i++ {
			sum++
		}
        cost := time.Since(start)
        fmt.Println("cost=", cost)
    }()
    // some computation
}
-------------本文结束感谢您的阅读-------------
分享到： 收藏夹 复制网址 邮件 微信 QQ空间 腾讯微博 豆瓣 一键分享 更多