Time #

After 在指定的时间间隔后发送当前时间 #

After(d Duration) <-chan Time：返回一个通道，该通道将在指定的时间间隔后发送当前时间。可以用它来实现定时器

例如，程序需要等待一段时间后再执行某个操作，可以使用After()函数来实现。示例代码：

select {
case <-time.After(5 * time.Second):
    fmt.Println("5秒后执行")
}

AfterFunc 定时器 #

func AfterFunc(d Duration, f func()) *Timer创建一个新的定时器，并在定时器触发时调用指定的回调函数f。参数d是一个time.Duration类型的值，表示定时器的持续时间。返回值是一个指向Timer结构体的指针。

func main() {
	t := time.AfterFunc(3*time.Second, func() {
		fmt.Println("定时器已触发")
	})
	fmt.Println("定时器已启动")
	time.Sleep(4 * time.Second)
	t.Stop()
	fmt.Println("定时器已停止")
}

Sleep 延迟 #

Sleep(d Duration)：使当前程序暂停指定的时间间隔。可以用它来实现程序的延迟操作，例如，程序需要在某个操作之后暂停一段时间再继续执行，可以使用Sleep()函数来实现。

示例代码：

fmt.Println("开始执行")
time.Sleep(2 * time.Second)
fmt.Println("暂停2秒后继续执行")

Tick #

Tick(d Duration) <-chan Time：返回一个通道，该通道会定期发送时间，每个时间间隔为指定的时间间隔。可以用它来实现定时器，例如，程序需要每隔一段时间执行某个操作，可以使用Tick()函数来实现。

示例代码：

for t := range time.Tick(2 * time.Second) {
    fmt.Println("每隔2秒执行一次，当前时间为：", t)
}

NewTicker 自动收报机 #

NewTicker(d Duration) *Ticker是 Go 编程语言time包中的一个函数，它创建一个新的自动收报机，以指定的时间间隔在通道上发送信号。

使用time.NewTicker对于运行周期性任务或在 Go 程序中以特定时间间隔安排事件很有用。

func main() {
    ticker := time.NewTicker(1 * time.Second)
    defer ticker.Stop()
    for {
        select {
        case <-ticker.C:
            fmt.Println("tick")
        }
    }
}

Data 创建指定时间 #

Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time：返回一个时间值，表示指定的日期和时间。可以用它来创建一个指定时间的time.Time类型变量。

示例代码：

t := time.Date(2023, time.April, 18, 12, 0, 0, 0, time.UTC)
fmt.Println(t)

loc, err := time.LoadLocation("Asia/Shanghai")
if err != nil {
	common.Log.Errorf("Error loading location:", err)
	continue
}
dhfslog.RecordTime = time.Date(
	int(year)+2000,
	time.Month(month),
	int(day),
	int(hour),
	int(minute),
	int(second),
	0,
	loc)

Parse 字符串解析为时间 #

Parse(layout, value string) (Time, error)：将指定的字符串解析为时间值。layout参数指定字符串的格式，value参数是要解析的字符串。可以用它来将字符串转换为时间类型。

示例代码：

t, err := time.Parse("2006-01-02 15:04:05", "2023-04-18 12:00:00")
if err != nil {
    fmt.Println("解析错误：", err)
    return
}
fmt.Println(t)

ParseInLocation字符串解析为本地时间 #

func ParseInLocation(layout, value string, loc *Location) (Time, error)

• layout 参数是时间字符串的格式，例如 “2006-01-02 15:04:05”。
• value 参数是要解析的时间字符串。
• loc 参数是指定的时区，可以使用 time.LoadLocation 函数获取一个 *time.Location 对象，代表某个时区。

ParseInLocation 函数会尝试将时间字符串 value 解析为对应 layout 格式的时间，并将其转换到 loc 时区。如果解析成功，它会返回一个 Time 对象和 nil 错误；如果解析失败，它会返回一个零值的 Time 对象和一个非 nil 的错误。

示例代码：

videoTime := "2023-09-03 14:30:00"

// 使用本地时区解析时间
t, err := time.ParseInLocation("2006-01-02 15:04:05", videoTime, time.Local)
if err != nil {
	fmt.Printf("time parse err: %s\n", err.Error())
	return
}

fmt.Println("本地时间:", t)

In将一个时间值转换到指定的时区 #

func (t Time) In(loc *Location) Time

• t 是要转换时区的时间值。
• loc 是目标时区，表示一个 *time.Location 对象，可以使用 time.LoadLocation 函数获取。

time.In 函数会返回一个新的时间值，它是将原始时间值 t 转换到指定时区 loc 后的结果。

以下是一个简单的示例，演示如何使用 time.In 函数：

func main() {
	// 创建一个时间对象
	t := time.Date(2024, 9, 3, 12, 0, 0, 0, time.UTC)

	// 指定目标时区
	loc, _ := time.LoadLocation("America/New_York")

	// 将时间转换到目标时区
	newTime := t.In(loc)

	// 输出转换后的时间
	fmt.Println("原始时间:", t)
	fmt.Println("目标时区时间:", newTime)
}

Format 时间转换为字符串 #

Format(t Time, layout string) string：将时间值t格式化为指定的字符串格式layout。可以用它来将时间类型转换为字符串类型。

示例代码：

t := time.Now()
fmt.Println(t.Format("2006-01-02 15:04:05"))

ParseDuration 字符串解析为持续时间 #

ParseDuration(s string) (Duration, error)：将字符串解析为持续时间值。可以用它来将字符串类型的时间转换为持续时间类型。

示例代码：

d, err := time.ParseDuration("1h30m")
if err != nil {
    fmt.Println("解析错误：", err)
    return
}
fmt.Println(d)
//1h30m0s

Add 时间值添加 #

Add(d Duration) Time：将持续时间值d添加到时间值t上，并返回结果。可以用它来实现时间的加减运算。

示例代码：

t := time.Now()
d, _ := time.ParseDuration("2h")
t2 := t.Add(d)
fmt.Println(t2)

Sub 计算时间差 #

Sub(t Time) Duration：计算时间t与当前时间之间的持续时间值，并返回结果。可以用它来计算两个时间之间的时间差。

示例代码：

t1 := time.Now()
time.Sleep(2 * time.Second)
t2 := time.Now()
d := t2.Sub(t1)
fmt.Println(d)

Since 当前时间与时间t之间的持续时间值 #

Since(t Time) Duration：计算当前时间与时间t之间的持续时间值，并返回结果。可以用它来计算当前时间与指定时间之间的时间差。

示例代码：

t := time.Now()
time.Sleep(2 * time.Second)
d := time.Since(t)
fmt.Println(d)

注意看与上面的区别

Truncate 将时间值精确到指定的时间间隔 #

Truncate(d Duration) Time：将时间值t截断到指定的时间间隔d。可以用它来将时间值精确到指定的时间间隔。

示例代码：

t := time.Now()
t2 := t.Truncate(10 * time.Minute)
fmt.Println(t2)

2023-04-18 19:33:56.3565825 +0800 CST m=+0.001535201
2023-04-18 19:30:00 +0800 CST

Unix 将Unix时间转换为时间值 #

Unix(sec int64, nsec int64) Time：将Unix时间转换为时间值。可以用它来将Unix时间戳转换为时间类型。

示例代码：

t := time.Unix(1619158800, 0)
fmt.Println(t)

LoadLocation 返回指定时区 #

LoadLocation(name string) (*Location, error)：返回指定时区的Location值。可以用它来获取指定时区的Location值。

示例代码：

loc, err := time.LoadLocation("Asia/Shanghai")
if err != nil {
    fmt.Println("获取时区失败：", err)
    return
}
t := time.Now().In(loc)
fmt.Println(t)

Round 将时间值t四舍五入到指定的时间间隔 #

Time.Round(d Duration) Time：将时间值t四舍五入到指定的时间间隔d。可以用它来将时间值舍入到指定的时间间隔。

示例代码：

t := time.Now()
t2 := t.Round(10 * time.Minute)
fmt.Println(t2)

UTC 生成位置 #

Time.UTC()函数用于生成位置设置为UTC的t。此外，此函数在时间包下定义。在这里，您需要导入“time”包才能使用这些函数。

协调世界时，又称世界统一时间、世界标准时间、国际协调时间。由于英文（CUT）和法文（TUC）的缩写不同，作为妥协，简称UTC

用法:

func (t Time) UTC() Time

在此，“t”是UTC中规定的时间。

**返回值：**它返回t，并将其位置设置为UTC。

Local 返回当前系统本地时区 #

time.Local 返回的是代表当前系统本地时区的 *time.Location 对象。这个本地时区是通过系统的时区设置确定的，通常对应于系统的默认时区。在大多数情况下，这个本地时区与系统的本地时区设置相匹配。

在程序中使用 time.Local 时，它会返回一个 *time.Location 对象，表示程序所在系统的本地时区。这个时区对象可以用于在本地时间和 UTC 时间之间进行转换，以及执行其他与时区相关的操作。

func main() {
    // 获取本地时区
    local := time.Local
    // 输出本地时区的名称
    fmt.Println("本地时区:", local.String())
}

Timer结构体 #

NewTimer 在其通道上发送当前时间 #

NewTimer包中的函数创建time一个新的 Timer 对象，该对象将在指定的持续时间后在其通道上发送当前时间。

func NewTimer(d Duration) *Timer

timer := time.NewTimer(2 * time.Second)
<-timer.C
fmt.Println("Timer expired")

timer := time.NewTimer(2 * time.Second)
stop := timer.Stop() //停止
if stop {
	fmt.Println("Timer stopped")
} else {
	<-timer.C
	fmt.Println("Timer expired")
}

Reset 重置定时器t的时间间隔 #

Timer.Reset(d Duration) bool：重置定时器t的时间间隔为d，并返回是否成功。可以用它来重置定时器的时间间隔。如果定时器已经触发过了，则会取消之前的时间事件，并重新计时。

示例代码：

t := time.NewTimer(2 * time.Second)
time.Sleep(time.Second)
ok := t.Reset(1 * time.Second)
fmt.Println("重置定时器结果：", ok)
<-t.C

Stop 停止定时器 #

func (t *Timer) Stop() bool停止定时器，并返回定时器是否成功停止。如果定时器已经触发过了，则该方法不会有任何效果。

func main() {
	t := time.NewTimer(3 * time.Second)
	fmt.Println("定时器已启动")
	t.Stop()
	fmt.Println("定时器已停止")
	<-t.C
	fmt.Println("定时器已触发")
}

IsZero 判断为空 #

0001-01-01 00:00:00+00:00在 Go 中，time.Time 类型的零值表示公元 1 年 1 月 1 日的午夜，UTC 时间。这是 Go 的 time 包在未设置或未初始化时间变量时使用的默认值。

func isEmptyTime(t time.Time) bool {
	return t.IsZero()
}

//判断是否是Unix 时间戳的起点 1970-01-01 08:00:00+08:00 UTC 时间下，这个起点是 1970-01-01 00:00:00。但是，在东八区（+08:00）的时区，这个时间显示为 1970-01-01 08:00:00+08:00。这意味着时间值为 0 的 Unix 时间戳在东八区被转换为这个本地时间。

if t1.Equal(time.Date(1970, 1, 1, 8, 0, 0, 0, time.FixedZone("CST", 8*3600))){
    return 
}

时间对象（time.Time)的比较 #

Before, After, Equal，分别对应<,>,==

t1.Before(t2)// t1 < t2
t1.After(t2)// t1 > t2
t1.Equal(t2)// t1 == t2

获取00:00:00格式的时间 #

	// 假设这是你的 int64 类型的时间戳
	var seconds int64 = 366135345 // 例如 1 小时 1 分钟 1 秒

	// 将秒数转换为 time.Duration 类型
	duration := time.Duration(seconds) * time.Second

	// 提取小时、分钟和秒
	hours := int64(duration.Hours())
	minutes := int64(duration.Minutes()) % 60
	seconds = int64(duration.Seconds()) % 60

	// 格式化为 00:00:00 字符串
	timeStr := fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds)
	fmt.Println(timeStr)