时间类型

在编码中，经常会涉及到时间的转换，对于time的使用，一直比较模糊，现在做一下整理。

首先，了解时间的两种类型。时间可分为时间点与时间段，golang 提供了以下两种基础类型

  • 时间点(Time)
  • 时间段(Duration)

除此之外 golang 也提供了以下类型，做一些特定的业务

  • 时区(Location)
  • Ticker
  • Timer(定时器)

时间点(Time)

时间相关的业务都是基于点而延伸的，两点组成一个时间段，大多数应用也都是围绕这些点与面去做逻辑处理。

时间初始化

Go 针对不同的参数类型提供了以下初始化的方式 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//2019-12-13 10:42:09.364687 +0800 CST m=+0.003140465
fmt.Println(time.Now())

//2010-04-23 12:24:51 +0000 UTC
s, _ := time.Parse("2006-01-02 15:04:05", "2010-04-23 12:24:51")
fmt.Println(s)

//2017-05-11 14:06:06 +0800 CST
s, _ = time.ParseInLocation("2006-01-02 15:04:05", "2017-05-11 14:06:06", time.Local)
fmt.Println(s)

//2001-09-09 09:46:40 +0800 CST
s = time.Unix(1e9, 0)
fmt.Println(s)

//2018-01-02 15:30:10 +0800 CST
s = time.Date(2018, 1, 2, 15, 30, 10, 0, time.Local)
fmt.Println(s)

//Time 当前时间对应指定时区的时间
//2019-12-12 18:42:09.366207 -0800 PST
loc, _ := time.LoadLocation("America/Los_Angeles")
fmt.Println(time.Now().In(loc))

时间格式化

代码不同环境，需要的时间显示可能是不一样的。

String

格式化为字符串我们需要使用 time.Format 方法来转换成我们想要的格式。

1
2
3
4
//2019-12-13 10:42:09
fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
//Fri Dec 13 10:42:09 CST 2019
fmt.Println(time.Now().Format(time.UnixDate))

Format 函数中可以指定你想使用的格式，同时 time 包中也给了一些我们常用的格式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
const (
    ANSIC       = "Mon Jan _2 15:04:05 2006"
    UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
    RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
    RFC822      = "02 Jan 06 15:04 MST"
    RFC822Z     = "02 Jan 06 15:04 -0700" // RFC822 with numeric zone
    RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
    RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
    RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" // RFC1123 with numeric zone
    RFC3339     = "2006-01-02T15:04:05Z07:00"
    RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
    Kitchen     = "3:04PM"
    // Handy time stamps.
    Stamp      = "Jan _2 15:04:05"
    StampMilli = "Jan _2 15:04:05.000"
    StampMicro = "Jan _2 15:04:05.000000"
    StampNano  = "Jan _2 15:04:05.000000000"
)

注意: galang 中指定的特定时间格式为 "2006-01-02 15:04:05 -0700 MST"， 为了记忆方便，按照美式时间格式 月日时分秒年 外加时区 排列起来依次是 01/02 03:04:05PM ‘06 -0700，刚开始使用时需要注意。

时间戳

1
2
func (t Time) Unix() int64
func (t Time) UnixNano() int64
1
2
3
4
5
6
7
8
9
//1576204929
fmt.Println(time.Now().Unix())

//1524486291
dt, _ := time.Parse("2006-01-02 15:04:05", "2018-04-23 12:24:51")
fmt.Println(dt.Unix())

//1514878210
fmt.Println(time.Date(2018, 1, 2, 15, 30, 10, 0, time.Local).Unix())

其它方法

time 包还提供了一些常用的方法，基本覆盖了大多数业务。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
func (t Time) Date() (year int, month Month, day int)
func (t Time) Clock() (hour, min, sec int)
func (t Time) Year() int
func (t Time) Month() Month
func (t Time) Day() int
func (t Time) Hour() int
func (t Time) Minute() int
func (t Time) Second() int
func (t Time) Nanosecond() int
func (t Time) YearDay() int
func (t Time) Weekday() Weekday
func (t Time) ISOWeek() (year, week int)
func (t Time) IsZero() bool
func (t Time) Local() Time
func (t Time) Location() *Location
func (t Time) Zone() (name string, offset int)
func (t Time) Unix() int64

时间段(Duartion)

时间段，即 Duartion 类型， 我们业务也是很常用的类型。

1
2
3
4
5
6
func (d Duration) Hours() float64
func (d Duration) Minutes() float64
func (d Duration) Seconds() float64
func (d Duration) Nanoseconds() int64
func (d Duration) Round(m Duration) Duration //四舍五入
func (d Duration) Truncate(m Duration) Duration //向下取整
1
2
3
4
5
6
//1.5s
tp, _ := time.ParseDuration("1.5s")
fmt.Println(tp)

//1.5s 1.5 1500000000
fmt.Println(tp.Truncate(100000), tp.Seconds(), tp.Nanoseconds())

时区(Location)

时区的相关的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 默认UTC
loc, _ = time.LoadLocation("")
fmt.Println(loc)
//UTC
loc, _ = time.LoadLocation("local")
fmt.Println(loc)

//America/Los_Angeles
loc, _ = time.LoadLocation("America/Los_Angeles")
fmt.Println(loc)

// 获取指定时区的时间点
local, _ := time.LoadLocation("America/Los_Angeles")
//2018-01-01 12:00:00 -0800 PST
fmt.Println(time.Date(2018, 1, 1, 12, 0, 0, 0, local))

时间运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//  等价于 t.Sub(Now())，t与当前时间的间隔
func Until(t Time) Duration

// 加
func (t Time) Add(d Duration) Time 

// 减 
func (t Time) Sub(u Time) Duration 

// AddDate returns the time corresponding to adding the
// given number of years, months, and days to t.
func (t Time) AddDate(years int, months int, days int) Time

func (t Time) Before(u Time) bool
func (t Time) After(u Time) bool
//比较时间点时尽量使用Equal函数 
func (t Time) Equal(u Time) bool
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
time.Sleep(time.Duration(10) * time.Second)
fmt.Println("Waiting 10s")

time.After(time.Duration(10) * time.Second)
fmt.Println("Print soon")

//211ns
start := time.Now()
fmt.Println(time.Since(start))

dt = time.Now()
//2019-12-17 10:54:23.221246 +0800 CST m=+10.008947977
fmt.Println(dt)
//2019-12-17 10:54:33.221246 +0800 CST m=+20.008947977
fmt.Println(dt.Add(time.Duration(10) * time.Second))
//2021-01-18 10:54:23.221246 +0800 CST
fmt.Println(dt.AddDate(1, 1, 1))

示例

计算时间差

1
2
3
4
5
dt1 := time.Date(2018, 1, 10, 0, 0, 1, 100, time.Local)
dt2 := time.Date(2018, 1, 9, 23, 59, 22, 100, time.Local)
// 不用关注时区，go会转换成时间戳进行计算
//39s
fmt.Println(dt1.Sub(dt2))

当前时间的前后运算

1
2
3
4
5
6
7
8
9
10
now := time.Now()
// 一年零一个月一天之后
fmt.Println(now.AddDate(1, 1, 1))
// 一段时间之后
fmt.Println(now.Add(time.Duration(10) * time.Minute))

// 计算两个时间点的相差天数
dt1 = time.Date(dt1.Year(), dt1.Month(), dt1.Day(), 0, 0, 0, 0, time.Local)
dt2 = time.Date(dt2.Year(), dt2.Month(), dt2.Day(), 0, 0, 0, 0, time.Local)
fmt.Println(int(math.Ceil(dt1.Sub(dt2).Hours() / 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
29
30
31
// time.Local 用来表示当前服务器时区
// 自定义地区时间
secondsEastOfUTC := int((8 * time.Hour).Seconds())
beijing := time.FixedZone("Beijing Time", secondsEastOfUTC)
// 2018-01-02 00:00:00 +0800 Beijing Time
fmt.Println(time.Date(2018,1,2,0,0,0,0, beijing))

// 当前时间转为指定时区时间
//2019-12-17 11:07:00.57998 +0800 Beijing Time
fmt.Println(time.Now().In(beijing))

// 指定时间转换成指定时区对应的时间
dt, _ = time.ParseInLocation("2006-01-02 15:04:05", "2017-05-11 14:06:06", time.Local)
//2017-05-11 14:06:06 +0800 CST
fmt.Println(dt)

// 当前时间在零时区年月日   时分秒  时区
year, mon, day := time.Now().UTC().Date()
//2019 December 17
fmt.Println(year, mon, day)

hour, min, sec := time.Now().UTC().Clock()
//3 12 36 注意hour
fmt.Println(hour, min, sec)
hour, min, sec = time.Now().In(beijing).Clock()
//11 12 36
fmt.Println(hour, min, sec)

zone, _ := time.Now().UTC().Zone()
//UTC
fmt.Println(zone)

比较两个时间点

1
2
3
4
5
6
7
8
9
dt = time.Date(2019, 12, 17, 0, 0, 1, 100, time.Local)
// true
fmt.Println(time.Now().After(dt))
// false
fmt.Println(time.Now().Before(dt))

// 是否相等 判断两个时间点是否相等时推荐使用 Equal 函数
//false
fmt.Println(dt.Equal(time.Now()))

设置执行时间

通过time.After 函数与 select 结合使用可用于处理程序超时设定

1
2
3
4
5
6
select {
case m := <-c:
	// do something
case <-time.After(time.Duration(1) * time.Second):
	fmt.Println("time out")
}

Ticker类型

Ticker 类型包含一个 channel，有时我们会遇到每隔一段时间执行的业务(比如设置心跳时间等)，就可以用它来处理，这是一个重复的过程

1
2
3
4
5
6
// 无法取消
tick := time.Tick(5 * time.Second)
for _ = range tick {
	// do something
	fmt.Println("do something 1")
}
1
2
3
4
5
// 可通过调用ticker.Stop取消
ticker := time.NewTicker(3 * time.Second)
for _ = range ticker.C {
	fmt.Println("do something 2")
}

Timer类型

Timer 类型用来代表一个单独的事件，当设置的时间过期后，发送当前的时间到 channel, 我们可以通过以下两种方式来创建

1
2
3
// 指定一段时间后指定的函数
func AfterFunc(d Duration, f func()) *Timer
func NewTimer(d Duration) *Timer

以上两函数都可以使用 Reset, 这个有个需要注意的地方是使用 Reset 时需要确保 t.C 通道被释放时才能调用，以防止发生资源竞争的问题，可通过以下方式解决

1
2
3
4
if !t.Stop() {
      <-t.C
}
t.Reset(d)

链接

原文链接：https://blog.csdn.net/wschq/article/details/80114036