Go-15 Golang语言中time包以及日期函数

package main

import (
	"fmt"
	"time"
)

// Golang time包以及日期函数
func main() {
	/*
		1. time.Now() 获取当前时间
		2. Format方法会格式化输出日期字符串
		3. 获取当前的时间戳
		4. 时间戳转换为日期字符串（年-月-日 时:分:秒）
		5. now.Format 把时间戳格式化成日期
		6. 日期字符串转换成时间戳
		7. 时间间隔
		8.时间操作函数
			Add方法:  增加时间
			Sub方法:  求两个时间之间的差值
			Equal方法:  判断两个时间是否相同，返回bool值
			Before方法:	判断时间在什么之前，返回bool值
			After方法:	判断时间在什么之后，返回bool值
		9.定时器
			9.1 使用time.NewTicker(时间间隔)来设置定时器
			9.2 time.Sleep(time.Second)来实现定时器
		10.练习题
			10.1、获取当前时间，格式化输出为 2020/06/19 20:30:05 格式。
			10.2、获取当前时间，格式化输出为时间戳
			10.3、把时间戳 1587880013 转换成日期字符串，格式为 2020/xx/xx xx:xx:xx
			10.4、把日期字符串 2020/06/19 20:30:05 转换成时间戳
			10.5、编写程序统计一段代码的执行耗时时间，单位精确到微秒。
	*/
	// 1. time.Now() 获取当前时间
	now := time.Now()
	fmt.Printf("current now time:%v \n", now)
	println(time.Now().Year())    // 返回年份
	println(time.Now().YearDay()) // 返回年份中的第几天
	println(time.Now().Month())   // 返回月份
	println(time.Now().Day())     // 返回当前月份的第几天
	println(time.Now().Hour())    // 返回今天的第几时
	println(time.Now().Minute())  // 返回今天的第几分
	println(time.Now().Second())  // 返回今天的第几秒

	year := now.Year()                                                                  //年
	month := now.Month()                                                                //月
	day := now.Day()                                                                    //日
	hour := now.Hour()                                                                  //小时
	minute := now.Minute()                                                              //分钟
	second := now.Second()                                                              //秒
	fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second) // 2022-12-13 11:03:40
	// 2. Format方法会格式化输出日期字符串
	now_t := time.Now()
	// 格式化的模板为Go的出生时间2006年1月2日15点04分 Mon Jan
	// 24 小时制
	fmt.Println("Look this ", now_t.Format("2006-01-02 15:04:05")) // Look this  2022-12-13 11:32:33
	// 3. 获取当前的时间戳
	println(time.Now().Unix())     // 1670905706
	println(time.Now().UnixNano()) // 纳秒级时间戳	1670905706444446200
	// 4. 时间戳转换为日期字符串（年-月-日 时:分:秒）
	// 使用time.Unix()函数可以将时间戳转为时间格式。使用方法如下：
	timestamp1 := time.Now().Unix()
	timeobj := time.Unix(timestamp1, 0)                                                                   // 将时间戳转为时间格式
	year1 := timeobj.Year()                                                                               // 年
	month1 := timeobj.Month()                                                                             // 月
	day1 := timeobj.Day()                                                                                 // 日
	hour1 := timeobj.Hour()                                                                               // 时
	minute1 := timeobj.Minute()                                                                           // 分
	second1 := timeobj.Second()                                                                           // 秒
	fmt.Printf("时间戳转换为时间后是：%d-%d-%d %d-%d-%d \n", year1, month1, day1, hour1, minute1, second1) // 时间戳转换为时间后是：2022-12-13 14-55-39
	// 5. now.Format 把时间戳格式化成日期
	var timestamp2 int64 = 1670905706
	t := time.Unix(timestamp2, 0)                                         // 日期对象
	fmt.Println("日期格式化输出结果是：", t.Format("2006-01-02 15:04:05")) // 日期格式化输出结果是： 2022-12-13 12:28:26
	// 6. 日期字符串转换成时间戳
	t1 := "2019-01-08 13:50:30"
	timeTemplate := "2006-01-02 15:04:05"
	stamp, _ := time.ParseInLocation(timeTemplate, t1, time.Local)
	fmt.Println("输出时间戳：", stamp.Unix()) // 输出时间戳： 1546926630
	/*	// 7. 时间间隔
		time.Duration 是 time包定义的一个类型，它代表两个时间点之间经过的时间，以纳秒为单位。time.Duration表示一段时间间隔，
		可表示的最长时间段大约290年。time包中定义的时间间隔类型的常量如下：
		const (
			Nanosecond Duration = 1
			Microsecond		= 1000 * Nanosecond
			Millisecond		= 1000 * Micresecond
			Second			= 1000 * Millisecond
			Minute			= 60 * Second
			Hour			= 60 Minute
		)
		例如：  time.Duration 表示1纳秒，time.Second 表示1秒.
	*/

	/*	// 8.时间操作函数
		Add方法:  增加时间
		Sub方法:  求两个时间之间的差值
		Equal方法:  判断两个时间是否相同，返回bool值
		Before方法:	判断时间在什么之前，返回bool值
		After方法:	判断时间在什么之后，返回bool值

	*/
	// 8.1 需求：求一个小时之后的时间,使用Add 方法
	time.Sleep(2 * time.Second) // 这个咋就没有生效呢？少了* time.Second
	now_ti := time.Now()
	fmt.Printf("current now_ti time:%v \n", now_ti)
	later := now_ti.Add(time.Hour) // 当前时间加1小时后的时间
	fmt.Println(later)             // 2022-12-13 17:15:34.6064959 +0800 CST
	// 8.2 需求1：求两个时间之间的差值,使用Sub 方法
	sub_time := now_ti.Sub(now)
	fmt.Println("相差时间为：", sub_time) // 相差时间为： 3.0123156s
	// 8.2 需求2：求两个时间之间的差值,使用Sub 方法
	start := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
	end := time.Date(2000, 1, 1, 12, 0, 0, 0, time.UTC)
	difference := end.Sub(start)
	fmt.Printf("difference = %v\n", difference) // difference = 12h0m0s
	// 8.3 需求：判断两个时间是否相同
	e_t1 := time.Now().Local()
	e_t2 := time.Now().Local()
	e_res := e_t2.Equal(e_t1)
	fmt.Printf("%v --- %v", e_t1, e_t2)
	fmt.Println("时间是否相同：", e_res) // 时间是否相同： true
	/* 结果是：2022-12-13 17:37:53.6482912 +0800 CST --- 2022-12-13 17:37:53.6482912 +0800 CST时间是否相同： true	*/

	// 8.4 需求：判断t时间在u时间之前
	year2000 := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
	year3000 := time.Date(3000, 1, 1, 0, 0, 0, 0, time.UTC)
	Year2000_Before_Year3000 := year2000.Before(year3000)
	Year3000_Before_Year2000 := year3000.Before(year2000)
	fmt.Printf("year2000.Before(year3000) = %v\n", Year2000_Before_Year3000) // True
	fmt.Printf("year3000.Before(year2000) = %v\n", Year3000_Before_Year2000) // False
	// 8.5 需求：判断t时间在u时间之后
	Y3_After_Y2 := year3000.After(year2000)
	fmt.Printf("year3000.After(year2000) = %v\n", Y3_After_Y2) // True
	// 9.定时器
	// 9.1 time.Sleep(time.Second)来实现定时器
	println()
	var num int // 应该写在这里
	for {
		// var num int
		//写在这里，每次if条件判断不成立后再回到这个地方，本来num++已经成为1，到了这里又变成了0，又继续下面+1，然后再跳转到0，一直死循环。
		time.Sleep(time.Second)
		fmt.Println("我在执行定时任务", num)
		num++
		if num == 3 {
			break // 此处不用return的好处，break可以结束当前的for循环，继续向下执行，return会直接终止函数的运行，下面的代码就不再执行了。
		}
	}

	// 9.2 使用time.NewTicker(时间间隔)来设置定时器
	ticker := time.NewTicker(time.Second) // 定义一个1秒间隔的定时器
	n := 0
	for i := range ticker.C {
		fmt.Println(i) // 每秒都会执行的任务
		n++
		if n > 5 {
			ticker.Stop()
			break // 此处不用return的好处，break可以结束当前的for循环，继续向下执行，return会直接终止函数的运行，下面的代码就不再执行了。
		}
	}
	/*	10. 练习题
		10.1、获取当前时间，格式化输出为 2020/06/19 20:30:05 格式。
		10.2、获取当前时间，格式化输出为时间戳
		10.3、把时间戳 1587880013 转换成日期字符串，格式为 2020/xx/xx xx:xx:xx
		10.4、把日期字符串 2020/06/19 20:30:05 转换成时间戳
		10.5、编写程序统计一段代码的执行耗时时间，单位精确到微秒。
	*/
	// 10.1、获取当前时间，格式化输出为 2020/06/19 20:30:05 格式。
	current_time := time.Now()
	fmt.Println("练习题1：", current_time.Format("2006-01-02 03:04:05"))
	// 10.2、获取当前时间，格式化输出为时间戳
	fmt.Println("练习题2：", current_time.Unix())
	// 10.3、把时间戳 1587880013 转换成日期字符串，格式为 2020/xx/xx xx:xx:xx
	timeUnixObj := time.Unix(1587880013, 0)
	fmt.Printf("练习题3：%d/%d/%d %d:%d:%d \n", timeUnixObj.Year(), timeUnixObj.Month(), timeUnixObj.Day(), timeUnixObj.Hour(), timeUnixObj.Minute(), timeUnixObj.Second())
	// 10.4、把日期字符串 2020/06/19 20:30:05 转换成时间戳
	timeUnixStr := "2020-06-19 20:30:05"
	Template := "2006-01-02 15:04:05"
	sta_str, _ := time.ParseInLocation(Template, timeUnixStr, time.Local)
	fmt.Println("练习题4：", sta_str.Unix())
	// 10.5、编写程序统计一段代码的执行耗时时间，单位精确到微秒。
	st1 := time.Now()
	time.Sleep(2 * time.Second)
	st2 := time.Now()
	fmt.Println("练习题5，两个时间相差：", st2.Sub(st1))

	/*	以上代码的全部执行结果是：
		PS C:\Users\Zhaoshan.lu\go\DaDi> go run .\17.go
		current now time:2022-12-13 22:24:54.1491994 +0800 CST m=+0.002247001
		2022
		347
		12
		13
		22
		24
		54
		2022-12-13 22:24:54
		Look this  2022-12-13 22:24:54
		1670941494
		1670941494161488000
		时间戳转换为时间后是：2022-12-13 22-24-54
		日期格式化输出结果是： 2022-12-13 12:28:26
		输出时间戳： 1546926630
		current now_ti time:2022-12-13 22:24:56.1623942 +0800 CST m=+2.015401101
		2022-12-13 23:24:56.1623942 +0800 CST m=+3602.015401101
		相差时间为： 2.0131541s
		difference = 12h0m0s
		2022-12-13 22:24:56.1623942 +0800 CST --- 2022-12-13 22:24:56.1623942 +0800 CST时间是否相同： true
		2022-12-13 22:25:02.1657172 +0800 CST m=+8.018603101
		2022-12-13 22:25:03.1656104 +0800 CST m=+9.018476201
		2022-12-13 22:25:04.1657622 +0800 CST m=+10.018607901
		2022-12-13 22:25:05.1661535 +0800 CST m=+11.018979101
		练习题1： 2022-12-13 10:25:05
		练习题2： 1670941505
		练习题3：2020/4/26 13:46:53
		练习题4： 1592569805
		练习题5，两个时间相差： 2.0011237s

	*/

}