标准库之 time

目录

• time库
  • 1. 时间类型
  • 2. 时间戳
    • （1）时间格式转化为时间戳
    • （2）时间戳转换为时间格式
  • 3. 时间间隔类型
  • 4. 时间的操作
    • （1）时间转字符串（时间格式化）
    • （2）字符串转时间
    • （3）时间加时间间隔
    • （4）两个时间之差
    • （5）时间是否相同
    • （6）判断时间前后
    • （7）定时器

time库

• time库是Go语言内置的库，用来定义和操作时间、日期

• time.Sleep(time.Second * 3)  // 睡眠3秒，同python的time.sleep()方法
  

1. 时间类型

package main

import (
	"fmt"
	"time"
)
func main() {
	now := time.Now()  // 获取当前时间
	fmt.Printf("current time:%v\n", now)

	year := now.Year()     // 获取时间类型的年
	month := now.Month()   // 获取时间类型的月
	day := now.Day()       // 获取时间类型的日
	hour := now.Hour()     // 获取时间类型的小时
	minute := now.Minute() // 获取时间类型的分钟
	second := now.Second() // 获取时间类型的秒
	fmt.Println(year, month, day, hour, minute, second)
	fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}

/*
current time:2024-02-28 10:46:22.6884166 +0800 CST m=+0.005582101
2024 February 28 10 46 22
2024-02-28 10:46:22 
*/

2. 时间戳

• 时间戳是自1970年1月1日（08:00:00GMT）至当前时间的总毫秒数。它也被称为Unix时间戳

（1）时间格式转化为时间戳

• Unix() 和 UnixNano()

package main

import (
	"fmt"
	"time"
)

func timestampDemo() {
	now := time.Now()            // 获取当前时间
	timestamp1 := now.Unix()     // 将当前时间转化为时间戳*****************
	timestamp2 := now.UnixNano() // 将当前时间转化为纳秒时间戳
	fmt.Printf("current timestamp1:%v\n", timestamp1)
	fmt.Printf("current timestamp2:%v\n", timestamp2)
}

// current timestamp1:1709088606
// current timestamp2:1709088606669159200

（2）时间戳转换为时间格式

• time.Unix()

package main

import (
	"fmt"
	"time"
)

func timestampDemo2(timestamp int64) {
	timeObj := time.Unix(timestamp, 0) //将时间戳转为时间格式
	fmt.Println(timeObj)
	year := timeObj.Year()     //年
	month := timeObj.Month()   //月
	day := timeObj.Day()       //日
	hour := timeObj.Hour()     //小时
	minute := timeObj.Minute() //分钟
	second := timeObj.Second() //秒
	fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}

func main() {
	now := time.Now()            //获取当前时间
	timestamp1 := now.Unix()     //时间戳
	timestampDemo2(timestamp1)
}

// 2024-02-28 10:56:36 +0800 CST
// 2024-02-28 10:56:36

3. 时间间隔类型

• Duration是time包定义的一个类型，它代表两个时间点之间经过的时间，以纳秒为单位。
• Duration表示一段时间间隔，可表示的最长时间段大约290年

time包中定义的时间间隔类型的常量如下：

1. 该类型的值的单位有如下几种：

const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)

2. 定义一个Duration类型变量
var jiange time.Duration
jiange = time.Second  // 赋值 1秒时间间隔 给 jiange
jiange = time.Hour  // 赋值 1小时时间间隔 给 jiange

4. 时间的操作

（1）时间转字符串（时间格式化）

• 时间类型有一个自带的方法Format进行格式化，需要注意的是Go语言中格式化时间模板不是常见的Y-m-d H:M:S而是使用Go的诞生时间2006年1月2号15点04分（记忆口诀为2006 1 2 3 4）
• 补充：如果想格式化为12小时方式，需指定PM ，Mon Jan分别表示当时的星期和月份

package main

import (
	"fmt"
	"time"
)

func formatDemo() {
	now := time.Now()
	// 格式化的模板为Go的出生时间2006年1月2号15点04分 Mon Jan
	// 24小时制
	fmt.Println(now.Format("2006-01-02 15:04:05.000 Mon Jan"))  // 000为精确到小数点后3位
	// 12小时制
	fmt.Println(now.Format("2006-01-02 03:04:05.00 PM Mon Jan"))  // 000为精确到小数点后2位
	fmt.Println(now.Format("2006/01/02 15:04"))
	fmt.Println(now.Format("15:04 2006/01/02"))
	fmt.Println(now.Format("2006/01/02"))
}

func main() {
	formatDemo()
}

/*
2024-02-28 11:27:20.148 Wed Feb
2024-02-28 11:27:20.14 AM Wed Feb
2024/02/28 11:27                 
11:27 2024/02/28                 
2024/02/28
*/

（2）字符串转时间

package main

import (
	"fmt"
	"time"
)

func time_string() {
	now := time.Now()
	fmt.Println("000 now:", now)

	// 直接转换，默认转成世界时(utc时间)
	timeObj, err := time.Parse("2006-01-02 15:04:05.9999", "2022-03-19 00:10:42.96")
	if err != nil {
		fmt.Println("转换出错", err)
	}
	// 默认转成utc时间
	fmt.Println(timeObj)

	// ***********************按照指定时区转换*********************
	// 1. 加载时区
	loc, err := time.LoadLocation("Asia/Shanghai")
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println("111 loc:", loc)

	// 2. 按照指定时区 和 指定格式转换 字符串时间2024/02/28 11:46:20
	my_time, err := time.ParseInLocation("2006/01/02 15:04:05", "2024/02/28 11:46:20", loc)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println("222 my_time:", my_time)
	fmt.Println("333 my_time.Sub(now):", my_time.Sub(now)) // my_time.Sub(now) 相当于 my_time - now 的差值
}

func main() {
	time_string()
}

/*
000 now: 2024-02-28 11:46:57.6179639 +0800 CST m=+0.004948901
111 loc: Asia/Shanghai
222 my_time: 2024-02-28 11:46:20 +0800 CST
333 my_time.Sub(now): -37.6179639s
*/

（3）时间加时间间隔

Add方法定义（不是函数）： func (t Time) Add(d Duration) Time

示例：
package main

import (
	"fmt"
	"time"
)

func main() {
	now := time.Now()
	fmt.Println(now)
	later := now.Add(time.Hour)  // 当前时间加1小时后的时间
	fmt.Println(later)
	later = now.Add(time.Minute * 2)  // 当前时间加2分钟后的时间
	fmt.Println(later)
}

（4）两个时间之差

Sub方法定义（不是函数）：  func (t Time) Sub(u Time) Duration

返回一个时间段t-u。如果结果超出了Duration可以表示的最大值/最小值，将返回最大值/最小值。要获取时间点t-d（d为Duration），可以使用t.Add(-d)

示例：见上面时间格式化中示例的 Sub

（5）时间是否相同

Equal方法定义（不是函数）：  func (t Time) Equal(u Time) bool

判断两个时间是否相同，会考虑时区的影响，因此不同时区标准的时间也可以正确比较。本方法和用t==u不同，这种方法还会比较地点和时区信息

（6）判断时间前后

• Before 和 After

Before方法定义（不是函数）：  func (t Time) Before(u Time) bool

如果t代表的时间点在u之前，返回真；否则返回假

After方法定义（不是函数）：  func (t Time) After(u Time) bool

如果t代表的时间点在u之后，返回真；否则返回假

（7）定时器

• 定时器的本质上是一个通道（channel）。详情见并发编程进阶