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)
}