time包
time包提供了时间显示与测量所使用的函数。
时间类型
time.Time类型表示时间，使用time.now()函数获取当前时间对象。对当前时间使用以下函数可获取不同的时间字段。
| 方法 | 描述 |
|---|---|
| Year() | 获取年 |
| Month() | 获取月 |
| Day() | 获取日 |
| Hour() | 获取时 |
| Second() | 获取秒 |
操作如下所示：
package main
import (
"fmt"
"time"
)
func main(){
currentTime := time.Now()
fmt.Println(currentTime) // 2020-10-09 13:47:55.654372 +0800 CST m=+0.002998001
fmt.Println(currentTime.Year())
fmt.Println(currentTime.Month())
fmt.Println(currentTime.Day())
fmt.Println(currentTime.Hour())
fmt.Println(currentTime.Minute())
fmt.Println(currentTime.Second())
}
时间戳
获取时间戳共有两种方法
| 方法 | 描述 |
|---|---|
| Unix() | 获取时间戳 |
| UnixNano() | 获取纳秒级的时间戳 |
操作如下所示：
package main
import (
"fmt"
"time"
)
func main(){
currentTime := time.Now()
timestamp1 := currentTime.Unix()
timestamp2 := currentTime.UnixNano()
fmt.Println(timestamp1)
fmt.Println(timestamp2)
}
时间转换
时间戳转日期
使用Unix()方法可将时间戳转为日期。
如下所示：
package main
import (
"fmt"
"time"
)
func main() {
var timestamp1 int64 = 1602222762 // 时间类型是int64
date := time.Unix(timestamp1, 0) // 最后放入一个0即可
fmt.Println(date) // 2020-10-09 13:52:42 +0800 CST
}
日期转字符串
日期转字符串使用Format()函数进行格式化。
需要注意的是Go语言中格式化时间模板不是常见的Y-m-d H:M:S，而是使用Go的诞生时间2006年1月2号15点04分（记忆口诀为2006 1 2 3 4）。
| Go中的日期格式 | 其他语言日期格式 | 描述 |
|---|---|---|
| 2006 | Y | 代表年 |
| 1 | m | 代表月 |
| 2 | d | 代表日 |
| 3 | H | 代表时 |
| 4 | M | 代表分 |
| 5 | S | 代表秒 |
如果想格式化为12小时方式，需指定PM。
如下，我们为当前时间进行转换成字符串格式：
package main
import (
"fmt"
"time"
)
func main() {
currentTime := time.Now()
strTime := currentTime.Format("2006年1月2日 (3时-4分-5秒) PM") // 加上PM为12小时制
fmt.Println(strTime) // 2020年10月9日 (2时-23分-1秒) PM
}
字符串转日期
字符串转日期需要先设定时区，其次使用ParseInLocation()函数进行转换。
如下所示：
package main
import (
"fmt"
"time"
)
func main() {
strTime := "2010-12-03 12:0:0"
// 设置时区
loc, _ := time.LoadLocation("Asia/Shanghai")
// 设置转换，参数1：指定格式 ，参数2：转换的字符串时间
timeObj, _ := time.ParseInLocation("2006-1-2 3:4:5", strTime, loc)
fmt.Println(timeObj) // 2010-12-03 12:00:00 +0800 CST
}
时间操作
时间间隔
time.Duration是time包定义的一个类型，它代表两个时间点之间经过的时间，以纳秒为单位。
time.Duration表示一段时间间隔，可表示的最长时间段大约290年。
time包中定义的时间间隔类型的常量如下：
const (
Nanosecond Duration = 1
Microsecond = 1000 * Nanosecond
Millisecond = 1000 * Microsecond
Second = 1000 * Millisecond
Minute = 60 * Second // 秒
Hour = 60 * Minute // 小时
)
Add
下列将展示求当前时间一天后的时间：
package main
import (
"fmt"
"time"
)
func main() {
currentTime := time.Now()
tomorrow := currentTime.Add(time.Hour * 24)
fmt.Println(tomorrow)
}
Sub
下列将展示两个时间中的差值。
package main
import (
"fmt"
"time"
)
func main() {
var timestamp1 int64 = 1502222762
date := time.Unix(timestamp1, 0) // 旧时间
result := time.Now().Sub(date) // 当前时间减去旧时间
fmt.Println(result) // 27778h25m19.987857s
}
Equal
判断两个时间是否相等，不用考虑时区的差异，因为内部已经做好了处理。
package main
import (
"fmt"
"time"
)
func main() {
var timestamp1 int64 = 1502222762
date := time.Unix(timestamp1, 0) // 旧时间
result := time.Now().Equal(date) // 现在是否等于设置好的旧时间？
fmt.Println(result) // false
}
Before
判断该时间是否在某一时间之前，返回布尔值。
package main
import (
"time"
"fmt"
)
func main() {
oldTime := time.Unix(1502222762, 0)
newTime := time.Unix(1692223444, 0)
result := oldTime.Before(newTime) // 旧时间是不是在新时间之前？
fmt.Println(result) // true
}
After
判断该时间是否在某一时间之后，返回布尔值。
package main
import (
"time"
"fmt"
)
func main() {
oldTime := time.Unix(1502222762, 0)
newTime := time.Unix(1692223444, 0)
result := oldTime.After(newTime) // 旧时间是不是在新时间之后？
fmt.Println(result) // false
}
定时器
使用time.Tick()来设置一个定时器。
如下所示，每隔三秒运行一次show()函数。
package main
import (
"fmt"
"time"
)
func show(count *int) {
fmt.Printf("运行了,这是第%v次\n", *count)
*count++
}
func main() {
count := 1
for range time.Tick(3 * time.Second) {
show(&count)
}
}
线程睡眠
使用time.Sleep()来让当前线程进行阻塞。
package main
import (
"fmt"
"time"
)
func main() {
count := 1
for {
time.Sleep(3 * time.Second)
fmt.Println("运行次数:", count)
count++
}
}