Go time模块

Time模块

1. time 包提供了一些关于时间显示和测量用的函数。
2. time 包中日历的计算采用的是公历。

时间类型

Go 语言中使用time.Time类型表示时间，可以通过time.Now函数（初始化函数）获取当前的时间对象，然后从时间对象中可以获取到年、月、日、时、分、秒等信息。

func timeDemo() {
	now := time.Now() // 初始化时间对象

	year := now.Year()     // 年
	month := now.Month()   // 月
	day := now.Day()       // 日
	hour := now.Hour()     // 小时
	minute := now.Minute() // 分钟
	second := now.Second() // 秒
}

时区

1. Go 语言中使用 location 来映射具体的时区。
2. 时区（Time Zone）是根据世界各国家与地区不同的经度而划分的时间定义，全球共分为24个时区。
3. 中国差不多跨5个时区，但为了使用方便只用东八时区的标准时即北京时间为准。

func main(){
	shanghai, _ := time.LoadLocation("Asia/Shanghai")
	timeobj, _ := time.ParseInLocation("2006-01-02","2022-10-01",shanghai
	//2022-09-30 16:00:00 +0000 UTC
	fmt.Println(timeobj.UTC())
	//2022-10-01 00:00:00 +0800 CST
	fmt.Println(timeobj)
}

func timezoneDemo() {
	// 中国没有夏令时，使用一个固定的8小时的UTC时差。
	// 对于很多其他国家需要考虑夏令时。
	secondsEastOfUTC := int((8 * time.Hour).Seconds())
	// FixedZone 返回始终使用给定区域名称和偏移量(UTC 以东秒)的 Location。
	beijing := time.FixedZone("Beijing Time", secondsEastOfUTC)

	// 加载纽约所在的时区
	newYork, err := time.LoadLocation("America/New_York") // UTC-05:00
	// 加载上海所在的时区
	shanghai, err := time.LoadLocation("Asia/Shanghai") // UTC+08:00
	// 加载东京所在的时区
	tokyo, err := time.LoadLocation("Asia/Tokyo") // UTC+09:00

	// 创建时间对象需要指定位置。常用的位置是 time.Local（当地时间） 和 time.UTC（UTC时间）。
	timeInLocal := time.Date(2009, 1, 1, 20, 0, 0, 0, time.Local)
	timeInUTC := time.Date(2009, 1, 1, 12, 0, 0, 0, time.UTC)
	sameTimeInBeijing := time.Date(2009, 1, 1, 20, 0, 0, 0, beijing)
	sameTimeInNewYork := time.Date(2009, 1, 1, 7, 0, 0, 0, newYork)

	// 北京时间（东八区）比UTC早8小时，所以上面两个时间看似差了8小时，但表示的是同一个时间
	timesAreEqual := timeInUTC.Equal(sameTimeInBeijing)
	fmt.Println(timesAreEqual)

	// 纽约（西五区）比UTC晚5小时，所以上面两个时间看似差了5小时，但表示的是同一个时间
	timesAreEqual = timeInUTC.Equal(sameTimeInNewYork)
	fmt.Println(timesAreEqual)
}

时间戳

Unix Time是自1970年1月1日 00:00:00 UTC 至当前时间经过的总秒数。

func main(){
	now := time.Now()        // 获取当前时间
	timestamp := now.Unix()  // 秒级时间戳
	milli := now.UnixMilli() // 毫秒时间戳 
	micro := now.UnixMicro() // 微秒时间戳
	nano := now.UnixNano()   // 纳秒时间戳
	fmt.Println(timestamp, milli, micro, nano)
}

时间转换

func main(){
	secondsEastOfUTC := int((8 * time.Hour).Seconds())
	beijing := time.FixedZone("Beijing Time", secondsEastOfUTC)

	// 北京时间 2022-02-22 22:22:22.000000022 +0800 CST
	t := time.Date(2022, 02, 22, 22, 22, 22, 22, beijing)
	var (
		sec  = t.Unix()
		msec = t.UnixMilli()
		usec = t.UnixMicro()
	)
	// 将秒级时间戳转为时间对象（第二个参数为不足1秒的纳秒数）
	timeObj := time.Unix(sec, 22)
	fmt.Println(timeObj)           // 2022-02-22 22:22:22.000000022 +0800 CST
	timeObj = time.UnixMilli(msec) // 毫秒级时间戳转为时间对象
	fmt.Println(timeObj)           // 2022-02-22 22:22:22 +0800 CST
	timeObj = time.UnixMicro(usec) // 微秒级时间戳转为时间对象
	fmt.Println(timeObj)           // 2022-02-22 22:22:22 +0800 CST
}

时间间隔

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

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

时间操作

1. func (t Time) Add(d Duration) Time
2. func (t Time) Sub(u Time) Duration
3. func (t Time) Equal(u Time) bool
4. func (t Time) Before(u Time) bool
5. func (t Time) After(u Time) bool

定时器

使用time.Tick(时间间隔)来设置定时器，定时器的本质上是一个通道（channel）。

func tickDemo() {
	ticker := time.Tick(time.Second) //定义一个1秒间隔的定时器
	for i := range ticker {
		fmt.Println(i)//每秒都会执行的任务
	}
}

时间格式化

1. 如果想格式化为12小时格式，需在格式化布局中添加PM。
2. 小数部分想保留指定位数就写0，如果想省略末尾可能的0就写 9。

func formatDemo() {
	now := time.Now()
	// 格式化的模板为 2006-01-02 15:04:05

	// 24小时制
	fmt.Println(now.Format("2006-01-02 15:04:05.000 Mon Jan"))
	// 12小时制
	fmt.Println(now.Format("2006-01-02 03:04:05.000 PM Mon Jan"))

	// 小数点后写0，因为有3个0所以格式化输出的结果也保留3位小数
	fmt.Println(now.Format("2006/01/02 15:04:05.000")) // 2022/02/27 00:10:42.960
	// 小数点后写9，会省略末尾可能出现的0
	fmt.Println(now.Format("2006/01/02 15:04:05.999")) // 2022/02/27 00:10:42.96

	// 只格式化时分秒部分
	fmt.Println(now.Format("15:04:05"))
	// 只格式化日期部分
	fmt.Println(now.Format("2006.01.02"))
}

解析字符串格式的时间

1. time.Parse在解析时不需要额外指定时区信息。

// parseDemo 指定时区解析时间
func parseDemo() {
	// 在没有时区指示符的情况下，time.Parse 返回UTC时间
	timeObj, err := time.Parse("2006/01/02 15:04:05", "2022/10/05 11:25:20")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(timeObj) // 2022-10-05 11:25:20 +0000 UTC

	// 在有时区指示符的情况下，time.Parse 返回对应时区的时间表示
	// RFC3339     = "2006-01-02T15:04:05Z07:00"
	timeObj, err = time.Parse(time.RFC3339, "2022-10-05T11:25:20+08:00")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(timeObj) // 2022-10-05 11:25:20 +0800 CST
}

2. time.ParseInLocation函数需要在解析时额外指定时区信息。

// parseDemo 解析时间
func parseDemo() {
	now := time.Now()
	fmt.Println(now)
	// 加载时区
	loc, err := time.LoadLocation("Asia/Shanghai")
	if err != nil {
		fmt.Println(err)
		return
	}
	// 按照指定时区和指定格式解析字符串时间
	timeObj, err := time.ParseInLocation("2006/01/02 15:04:05", "2022/10/05 11:25:20", loc)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(timeObj)
	fmt.Println(timeObj.Sub(now))
}

计算程序运行时间

func Timer(f func()){
	startTime :=time.Now().UnixMicro()
	f()
	fmt.Printf("程序用时：%v 微秒",time.Now().UnixMicro()-startTime)
}
func test(a ...interface{})[]interface{} {
	time.Sleep(time.Second*3)
	return a
}
func main(){
	// 计时器需要一个无参无返回值的函数，所以需要用匿名函数
	Timer(func() {
		res:=test(1,2,3,4,5)
		fmt.Println(res)
	})
}