Go 之 time 模块相应函数及示例
时间获取
time.Hours()
time.Hours()函数就是用于获取时间点以来的小时数。
package main
import (
"fmt"
"time"
)
func main() {
t1 := time.Now()
t2, _ := time.Parse("2006-01-02 15:04:05 -0700 MST", "2023-12-24 14:41:40 +0800 CST")
hours := t2.Sub(t1)
fmt.Println(hours.Hours()) // 3021.5102945206113
}
time.Clock()
主要用于获取一个 time.Time 值的小时、分钟和秒数。
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
hour, min, sec := now.Clock()
fmt.Printf("now is %02d:%02d:%02d\n", hour, min, sec) // now is 11:40:22
}
time.Hour()/Minute()/Second()
package main
import (
"fmt"
"time"
)
func main() {
t := time.Now() // 获取当前时间
hour := t.Hour()
fmt.Println(hour) // 输出当前时间的小时数
minute := t.Minute()
fmt.Println(minute) // 输出当前时间的分钟数
second := t.Second()
fmt.Println(second) // 输出当前时间的秒数
}
time.Date()
主要用于获取 time.Time 类型变量表示的时间的年月日信息。
package main
import (
"fmt"
"time"
)
func main() {
t := time.Now()
year, month, day := t.Date()
fmt.Printf("now is %04d-%02d-%02d\n", year, month, day) // now is 2023-09-10
}
time.Day()
time.Time.Day()函数是一个用来获取当前时间的天数的函数。
package main
import (
"fmt"
"time"
)
func main() {
// 当前时间
t := time.Now()
// 获取当前时间的天数
day := t.Day()
// 输出结果
fmt.Printf("today is %d号\n", day) // today is 9号
}
time.Weekday()
time.Weekday()函数用来获取当前时间的星期。
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
fmt.Println("today is", now.Weekday()) // today is Monday
}
时间解析
time.Parse()
time.Parse()函数将字符串转换为了Time类型。其中第一个参数是时间格式，第二个参数是待转换的字符串。
package main
import (
"fmt"
"time"
)
func main() {
t, _ := time.Parse("2006-01-02 15:04:05 -0700 MST", "2021-12-24 14:41:40 +0800 CST")
fmt.Printf("Time: %v\n", t) // Time: 2021-12-24 14:41:40 +0800 CST
}
time.ParseDuration()
时间间隔解析
package main
import (
"fmt"
"time"
)
func main() {
d, _ := time.ParseDuration("3600s")
fmt.Printf("Duration in seconds: %f\n", d.Seconds())
d, _ = time.ParseDuration("1.5h")
fmt.Printf("Duration in minutes: %f\n", d.Minutes())
d, _ = time.ParseDuration("2h45m")
fmt.Printf("Duration in hours: %f\n", d.Hours())
d, _ = time.ParseDuration("1m30s")
fmt.Printf("Duration in nanoseconds: %d\n", d.Nanoseconds())
d, _ = time.ParseDuration("500ms")
fmt.Printf("Duration in microseconds: %d\n", d.Microseconds())
// Duration in seconds: 3600.000000
// Duration in minutes: 90.000000
// Duration in hours: 2.750000
// Duration in nanoseconds: 90000000000
// Duration in microseconds: 500000
}
时间格式化
time.Format()
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
a := now.AppendFormat([]byte{}, time.RFC3339)
a2 := now.Format(time.RFC3339)
fmt.Println(string(a)) // 2023-09-10T11:25:32+08:00
fmt.Println(a2) // 2023-09-10T11:25:32+08:00
layout := "Jan 2, 2006 at 3:04pm (MST)"
b := now.AppendFormat([]byte{}, layout)
b2 := now.Format(layout)
fmt.Println(string(b)) // Sep 10, 2023 at 11:25am (CST)
fmt.Println(b2) // Sep 10, 2023 at 11:25am (CST)
layout = "2006-01-02 15:04:05"
c := now.AppendFormat([]byte{}, layout)
c2 := now.Format(layout)
fmt.Println(string(c)) // 2023-09-10 11:25:32
fmt.Println(c2) // 2023-09-10 11:25:32
layout = "2006-01-02 15:04:05.000"
fmt.Println(now.Format(layout)) // 2023-09-10 11:25:32 612
layout = "2006-01-02 15:04:05.999"
fmt.Println(now.Format(layout)) // 2023-09-10 11:25:32 612
layout = "2006-01-02"
fmt.Println(now.Format(layout)) // 2023-09-10
layout = "15:04:05"
fmt.Println(now.Format(layout)) // 11:25:32
}
时间序列化
time.GobEncode()
package main
import (
"bytes"
"encoding/gob"
"fmt"
"time"
)
type TimeWrapper struct {
Time time.Time
}
func main() {
var buffer bytes.Buffer
encoder := gob.NewEncoder(&buffer)
now := TimeWrapper{Time: time.Now()}
err := encoder.Encode(&now)
if err != nil {
fmt.Println("encode error: ", err)
}
var otherTime TimeWrapper
decoder := gob.NewDecoder(&buffer)
err = decoder.Decode(&otherTime)
if err != nil {
fmt.Println("decode error: ", err)
}
fmt.Println(now.Time) // 2023-09-10 12:15:57.6990592 +0800 CST m=+0.001000001
fmt.Println(otherTime.Time) // 2023-09-10 12:15:57.6990592 +0800
}
时间定时器
time.After()
time.After() 函数用于创建一个 Timer 对象并在指定的持续时间后向其 C 字段发送一个时间值。当然，如果在循环中多路复用使用 time.After 的话，记得不要在 case 直接写 time.After 哟，因为每一次执行 select 的 time.After() 都会重新开始计时。
package main
import (
"time"
"fmt"
)
func main() {
ch := make(chan int)
go func() {
fmt.Println("Start goroutine...")
time.Sleep(3 * time.Second)
ch <- 1
}()
select {
case <- ch:
fmt.Println("chan get message")
case <- time.After(2 * time.Second):
fmt.Println("timeout!") // timeout!
}
}
time.AfterFunc()
time.AfterFunc()函数是在指定的时间之后执行一个函数的方法。
package main
import (
"fmt"
"time"
)
func main() {
fmt.Println("Start main...")
fmt.Println("print hello world after 5 seconds...")
time.AfterFunc(time.Second*5, func() {
fmt.Println("hello world")
})
time.Sleep(time.Second*10)
fmt.Println("the end")
// Start main...
// print hello world after 5 seconds...
// hello world
// the end
}
time.NewTicker()
package main
import (
"fmt"
"time"
)
func main() {
fmt.Println("Program started.", time.Now().Format("2006-01-02 15:04:05"))
timer := time.NewTimer(3 * time.Second)
<- timer.C
fmt.Println("Timer expired.", time.Now().Format("2006-01-02 15:04:05"))
ticker := time.NewTicker(2 * time.Second)
defer ticker.Stop()
for {
select {
case <-ticker.C:
fmt.Println("ticker:", time.Now().Format("2006-01-02 15:04:05"))
}
}
// Program started. 2023-09-02 14:02:06
// Timer expired. 2023-09-02 14:02:09
// ticker: 2023-09-02 14:02:11
// ticker: 2023-09-02 14:02:13
}
time.Tick()
package main
import (
"fmt"
"time"
)
func main() {
ticker := time.Tick(2 * time.Second)
count := 0
for now := range ticker {
count++
fmt.Printf("%d: %s\n", count, now)
if count == 5 {
break
}
}
// 1: 2023-09-02 15:47:57.8208432 +0800 CST m=+2.002114501
// 2: 2023-09-02 15:47:59.8209576 +0800 CST m=+4.002228901
// 3: 2023-09-02 15:48:01.821072 +0800 CST m=+6.002343301
// 4: 2023-09-02 15:48:03.8211864 +0800 CST m=+8.002457701
// 5: 2023-09-02 15:48:05.8213008 +0800 CST m=+10.002572101
}
time.Ticker.Stop()
package main
import (
"fmt"
"time"
)
func main() {
ticker := time.NewTicker(time.Second)
defer ticker.Stop()
for {
select {
case <-ticker.C:
fmt.Println("Ticker tick")
}
}
}
时间戳
time.Unix()
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now().Unix()
fmt.Println("Unix时间戳（ 秒）为：", now)
milli := time.Now().UnixMilli()
fmt.Println("Unix时间戳（毫秒）为：", milli)
micro := time.Now().UnixMicro()
fmt.Println("Unix时间戳（微秒）为：", micro)
nano := time.Now().UnixNano()
fmt.Println("Unix时间戳（纳秒）为：", nano)
// Unix时间戳（秒） 为： 1692523606
// Unix时间戳（毫秒）为： 1692523606723
// Unix时间戳（微秒）为： 1692523606723707
// Unix时间戳（纳秒）为： 1692523606723707200
}
time.Second
package main
import (
"fmt"
"time"
)
func main() {
nano := time.Now().UnixNano()
fmt.Println("Unix时间戳（纳秒）为：", nano)
fmt.Println("Unix时间戳（纳秒）为：", nano / int64(time.Nanosecond))
fmt.Println("Unix时间戳（微秒）为：", nano / int64(time.Microsecond))
fmt.Println("Unix时间戳（毫秒）为：", nano / int64(time.Millisecond))
fmt.Println("Unix时间戳（ 秒）为：", nano / int64(time.Second))
// Unix时间戳（纳秒）为： 1692531897930937100
// Unix时间戳（纳秒）为： 1692531897930937100
// Unix时间戳（微秒）为： 1692531897930937
// Unix时间戳（毫秒）为： 1692531897930
// Unix时间戳（ 秒）为： 1692531897
}
时间计算
time.Round()
四舍五入
package main
import (
"fmt"
"time"
)
func main() {
t := time.Date(2021, 1, 17, 4, 37, 0, 0, time.UTC)
fmt.Println(t.Round(time.Hour)) // 输出：2021-01-17 05:00:00 +0000 UTC
fmt.Println(t.Round(30 * time.Minute)) // 输出：2021-01-17 04:30:00 +0000 UTC
}
time.Since()
计算当前时间和开始时间的间隔
package main
import (
"fmt"
"time"
)
func main() {
start := time.Date(2023, 9, 1, 4, 37, 0, 0, time.UTC)
diff := time.Since(start)
fmt.Println(diff) // 26h19m50.8567339s
}
time.Add()
在时间点上加上一个固定时长，例如 2 个小时、5 分钟等；或根据时间信息，计算出距离当前时间点一定时长之后的时间。
package main
import (
"fmt"
"time"
)
func main() {
t1 := time.Now()
t2 := t1.Add(5 * time.Minute)
t3 := t1.Add(2 * time.Hour)
fmt.Println(t1)
fmt.Println(t2)
fmt.Println(t3)
// 2023-09-10 11:12:09.7998193 +0800 CST m=+0.000000001
// 2023-09-10 11:17:09.7998193 +0800 CST m=+300.000000001
// 2023-09-10 13:12:09.7998193 +0800 CST m=+7200.000000001
}
time.AddDate()
它接受三个参数：years、months和days，分别表示要增加（或减少）的年数、月数和天数。
package main
import (
"fmt"
"time"
)
func main() {
t := time.Date(2023, time.May, 18, 0, 0, 0, 0, time.UTC)
t2 := t.AddDate(1, 2, 3)
fmt.Println(t2) // 2024-07-21 00:00:00 +0000 UTC
}
time.Sub()
求两个时间之间的差值。返回一个时间段t-u。如果结果超出了Duration可以表示的最大值/最小值，将返回最大值/最小值。要获取时间点t-d（d为Duration），可以使用t.Add(-d)。
package main
import (
"fmt"
"time"
)
func main() {
t1 := time.Now()
t2 := t1.Add(5 * time.Minute)
t3 := t2.Sub(t1)
fmt.Println(t1)
fmt.Println(t2)
fmt.Println(t3)
// 2023-09-10 11:12:09.7998193 +0800 CST m=+0.000000001
// 2023-09-10 11:17:09.7998193 +0800 CST m=+300.000000001
// 5m0s
}
时间比较
time.Before()
time.Time.Before() 用来判断一个时间是否早于另一个时间。
package main
import (
"fmt"
"time"
)
func main() {
// 2022年1月1日
t1 := time.Date(2022, 1, 1, 0, 0, 0, 0, time.UTC)
// 2021年12月31日
t2 := time.Date(2021, 12, 31, 0, 0, 0, 0, time.UTC)
if t2.Before(t1) {
fmt.Println("t2 is earlier than t1") // t2 is earlier than t1
} else {
fmt.Println("t1 is earlier than t2")
}
}
time.Equal()
表示要比较的两个时间对象是否表示相同时间。通过调用此方法，我们可以避免手动解析和比较日期和时间。
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
n1 := now.Add(5 * time.Second)
n2 := now.Add(10 * time.Second)
fmt.Println(n1.Equal(now)) // false
fmt.Println(n2.Equal(now)) // false
fmt.Println(now.Equal(now)) // true
}