60、Go语言基础 - time 包
hi,我是温析
涉及到时间的操作,就想想 time 这个包吧。
Go语言中的time包是一个用于处理时间的包,它提供了一些函数和类型来表示时间、日期和时间间隔。
时间类型
Go 语言 time
包中定义了两种时间类型:time.Time
和time.Duration
。
Time
time.Time
类型表示一个具体的时刻,它包含年、月、日、时、分、秒、纳秒以及时区等信息。
例如,我们可以使用以下代码创建一个表示当前时刻的时间对象:
package main
import (
"fmt"
"time"
)
func main() {
// 获取当前时间
now := time.Now()
year := now.Year() // 年
month := now.Month() // 月
day := now.Day() // 日
hour := now.Hour() // 小时
minute := now.Minute() // 分钟
second := now.Second() // 秒
fmt.Println(now)
fmt.Println(year, month, day, hour, minute, second)
}
输出结果
2023-10-20 16:07:46.5660726 +0800 CST m=+0.003083501
2023 October 20 16 7 46
Duration
time.Duration 类型表示一个时间间隔,它包含秒、纳秒等信息。
例如,我们可以使用以下代码创建一个表示 3 小时的时间间隔:
package main
import (
"fmt"
"time"
)
func main() {
// duration变量是一个time.Duration类型的值,表示3小时的时间间隔。
duration := time.Hour * 3
fmt.Println(duration)
}
输出结果
3h0m0s
Unix Time
Unix Time(也称为POSIX时间或UNIX Epoch时间)是从1970年1月1日00:00:00 UTC开始计算的秒数。在计算机系统中,Unix Time被广泛用于表示时间戳和时间间隔。
转为时间戳
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
unixTimestamp := now.Unix() // 秒级时间戳
milli := now.UnixMilli() // 毫秒时间戳
micro := now.UnixMicro() // 微秒时间戳
nano := now.UnixNano() // 纳秒时间戳
fmt.Println("当前时间的时间戳:", unixTimestamp)
fmt.Println("毫秒时间戳:", milli)
fmt.Println("微妙时间戳:", micro)
fmt.Println("纳秒时间戳:", nano)
}
输出结果
当前时间的时间戳: 1697790079
毫秒时间戳: 1697790079478
微妙时间戳: 1697790079478350
纳秒时间戳: 1697790079478350800
时间戳转为时间
package main
import (
"fmt"
"time"
)
func main() {
unixTimestamp := 1697790079478
timeObj := time.Unix(int64(unixTimestamp), 0)
fmt.Println("转换后的时间:", timeObj)
}
时间间隔
时间间隔操作,使用的是 time 包中的 Duration
类型。它代表两个时间点之间经过的时间,以纳秒为单位。
time 包中时间间隔类型如下:
const (
Nanosecond Duration = 1
Microsecond = 1000 * Nanosecond
Millisecond = 1000 * Microsecond
Second = 1000 * Millisecond
Minute = 60 * Second
Hour = 60 * Minute
)
Add
Add 方法返回一个新的时间对象,表示 t 加上 d 后的结果。
func (t time.Time) Add(d Duration) time.Time
其中,t 是时间对象,d 是时间间隔对象。
例如,我们可以使用Add方法将当前时间加上1小时:
package main
import (
"fmt"
"time"
)
func main() {
// 获取当前时间
now := time.Now()
// 将当前时间加上1小时
hour := time.Hour
t := now.Add(hour)
// 输出新时间
fmt.Println(t)
}
Sub
Sub 方法,用于计算两个时间对象之间的差值。
func (t1 time.Time) Sub(t2 time.Time) Duration
t1 和 t2 都是时间对象,Sub 方法返回一个 Duration 对象,表示 t1 和 t2 之间的差值。
例如,我们可以使用Sub方法计算当前时间与1小时前的时间之间的差值:
package main
import (
"fmt"
"time"
)
func main() {
// 获取当前时间
now := time.Now()
// 计算当前时间与1小时前的时间之间的差值
hour := time.Hour
t := now.Add(-hour)
duration := now.Sub(t)
// 输出差值
fmt.Println(duration)
}
Equal
Equal方法,用于比较两个时间对象是否相等。
func (t1 time.Time) Equal(t2 time.Time) bool
t1 和 t2 都是时间对象,Equal 方法返回一个 boo l值,表示 t1 和 t2 是否相等。
package main
import (
"fmt"
"time"
)
func main() {
// 获取当前时间
now := time.Now()
// 计算当前时间与1小时前的时间之间的差值
hour := time.Hour
t := now.Add(-hour)
// 比较当前时间与1小时前的时间是否相等
if now.Equal(t) {
fmt.Println("相等")
} else {
fmt.Println("不相等")
}
}
Before
Before方法,用于比较两个时间对象的先后顺序。
func (t1 time.Time) Before(t2 time.Time) bool
t1 和 t2 都是时间对象,Before 方法返回一个 bool 值,表示 t1 是否在 t2 之前。
例如,我们可以使用 Before 方法比较当前时间与 1 小时前的时间的先后顺序:
package main
import (
"fmt"
"time"
)
func main() {
// 获取当前时间
now := time.Now()
// 计算当前时间与1小时前的时间之间的差值
hour := time.Hour
t := now.Add(-hour)
// 比较当前时间与1小时前的时间的先后顺序
if now.Before(t) {
fmt.Println("当前时间在1小时前的时间之前")
} else {
fmt.Println("当前时间在1小时前的时间之后")
}
}
After
After方法,用于比较两个时间对象的先后顺序。
func (t1 time.Time) After(t2 time.Time) bool
t1 和 t2 都是时间对象,After 方法返回一个 bool 值,表示 t1 是否在 t2 之后。
After 方法的比较方式是:如果 t1 的时间戳大于 t2 的时间戳,则返回 true;否则返回 false。
例如,我们可以使用 After 方法比较当前时间与 1 小时前的时间的先后顺序:
package main
import (
"fmt"
"time"
)
func main() {
// 获取当前时间
now := time.Now()
// 计算当前时间与1小时前的时间之间的差值
hour := time.Hour
t := now.Add(-hour)
// 比较当前时间与1小时前的时间的先后顺序
if now.After(t) {
fmt.Println("当前时间在1小时前的时间之后")
} else {
fmt.Println("当前时间在1小时前的时间之前")
}
}
定时器
定时器使用 Tick()
函数。
time.Tick 是一个用于定时执行任务的函数。它会每隔一定的时间间隔调用一次指定的函数。 time.Tick 的语法如下:
func Tick(d Duration, fn func()) *Timer
d 是时间间隔,fn 是需要定时执行的函数。
time.Tick 会返回一个 Timer 对象,可以通过调用 Timer 的 Stop 方法来停止定时任务
package main
import (
"fmt"
"time"
)
func main() {
// 每隔1秒打印一次当前时间
tick := time.Tick(1 * time.Second)
for i := range tick {
fmt.Println(i)
}
}
格式化时间
time.Format 是一个用于格式化时间的函数。它会将一个时间对象按照指定的格式转换为字符串。
time.Format的语法如下:
func (t time.Time) Format(format string) string
其中,t
是要格式化的时间,format
是格式化字符串,用于定义输出时间的格式。
在 Go 语言中,格式化时间不是使用
Y-m-d H:m:s
,而是使用2006-01-02 15:04:05.000
来格式化。
- 2006:年(Y)
- 01:月(m)
- 02:日(d)
- 15:时(H)
- 04:分(M)
- 05:秒(S)
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
// 格式化为 24 小时制时间
formattedTime24 := now.Format("2006-01-02 15:04:05")
// 格式化为 12 小时制时间(带上 AM/PM 标识)
formattedTime12 := now.Format("2006-01-02 03:04:05 PM")
fmt.Println("24小时制时间:", formattedTime24)
fmt.Println("12小时制时间:", formattedTime12)
// 只格式化时分秒部分
fmt.Println(now.Format("15:04:05"))
// 只格式化日期部分
fmt.Println(now.Format("2006.01.02"))
}
解析字符串格式的时间
time
包中提供了time.Parse
和time.ParseInLocation
两个函数用于解析时间字符串.
time.Parse
time.Parse
函数是 Go 语言标准库中用于解析时间字符串的函数。它允许你将时间字符串解析为时间对象,给定一个格式化字符串,以告诉函数如何解释输入的字符串。
func Parse(layout, value string) (Time, error)
-
layout
是一个格式化字符串,用于定义输入字符串的时间格式。 -
value
是要解析的时间字符串。 - 返回值是
Time
类型的时间对象,以及一个错误。
package main
import (
"fmt"
"time"
)
func main() {
// 定义时间字符串和格式化字符串
timeStr := "2023-10-20 15:30:00"
layout := "2006-01-02 15:04:05"
// 使用 time.Parse 解析时间字符串
parsedTime, err := time.Parse(layout, timeStr)
if err != nil {
// 如果解析失败,打印错误信息并退出
fmt.Println("解析时间出错:", err)
return
}
// 如果解析成功,打印解析后的时间对象
fmt.Println("解析后的时间:", parsedTime)
}
time.ParseInLocation
time.ParseInLocation
用于解析时间字符串并指定时区的函数。它允许你显式指定解析时的时区,以便更精确地处理不同时区的时间。
func ParseInLocation(layout, value string, loc *Location) (Time, error)
-
layout
是一个格式化字符串,用于定义输入字符串的时间格式。 -
value
是要解析的时间字符串。 -
loc
是一个*time.Location
对象,用于指定解析时的时区。 - 返回值是
Time
类型的时间对象,以及一个错误。
package main
import (
"fmt"
"time"
)
func main() {
// 定义时间字符串和格式化字符串
timeStr := "2023-10-20 15:30:00"
layout := "2006-01-02 15:04:05"
// 显式指定时区为东八区
loc, _ := time.LoadLocation("Asia/Shanghai")
// 使用 time.ParseInLocation 解析时间字符串
parsedTime, err := time.ParseInLocation(layout, timeStr, loc)
if err != nil {
// 如果解析失败,打印错误信息并退出
fmt.Println("解析时间出错:", err)
return
}
// 如果解析成功,打印解析后的时间对象
fmt.Println("解析后的时间:", parsedTime)
}