60、Go语言基础 - time 包

作者: 温新

分类: 【Go基础】

阅读: 953

时间: 2023-12-05 00:54:31

hi,我是温析

涉及到时间的操作,就想想 time 这个包吧。

Go语言中的time包是一个用于处理时间的包,它提供了一些函数和类型来表示时间、日期和时间间隔。

时间类型

Go 语言 time 包中定义了两种时间类型:time.Timetime.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.Parsetime.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)
}
请登录后再评论