go语言time包

go语言time包

//time表示时间类型可以通过time.now()获取当前的时间对象.然后获取时间对象的年月日时分秒等信息
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.Printf("%d-%2d-%2d %2d:%2d:%2d\n", year, month, day, hour, minute, second)
}

输出结果
C:\Users\34826\AppData\Local\Temp\___go_build_main_go__1_.exe #gosetup
current time:2021-03-25 16:57:43.2877883 +0800 CST m=+0.003990801
2021- 3-25 16:57:43

时间戳

//time表示时间类型可以通过time.now()获取当前的时间对象.然后获取时间对象的年月日时分秒等信息
func main() {
	now := time.Now() //获取当前的时间
	fmt.Printf("current time:%v\n", now)
	//时间戳
	timestamp1 := now.Unix()     //时间戳
	timestamp2 := now.UnixNano() //纳秒时间戳
	fmt.Printf("current timestamp1:%v\n", timestamp1)
	fmt.Printf("current timestamp2:%v\n", timestamp2)
}
输出结果
C:\Users\34826\AppData\Local\Temp\___go_build_main_go__1_.exe #gosetup
current time:2021-03-25 17:01:59.6201826 +0800 CST m=+0.003989001
current timestamp1:1616662919
current timestamp2:1616662919620182600

使用unix时间戳转换年月日时分秒

func main() {
	timestamp := time.Now().Unix()
	timeObj := time.Unix(timestamp, 0)
	year := timeObj.Year()
	mouth := timeObj.Month()
	day := timeObj.Day()
	hour := timeObj.Hour()
	minute := timeObj.Minute()
	second := timeObj.Second()
	fmt.Printf("%d-%d-%d %d:%d:%d", year, mouth, day, hour, minute, second)
}
输出结果
C:\Users\34826\AppData\Local\Temp\___go_build_main_go__1_.exe #gosetup
2021-3-25 17:8:7

时间间隔

//时间间隔
const (
	Nanosecond  = 1
	Microsecond = 1000 * Nanosecond
	Millisecond = 1000 * Microsecond
	Second      = 1000 * Millisecond
	Minute      = 60 * Second
	Hour        = 60 * Minute
)
秒以下的时间是千进制的.秒,分钟,小时是60进制的.

Add

func main() {
	timeNow := time.Now()  //当前时间以及相关的方法.
	timeAfter := timeNow.Add(2 * time.Hour)  //表示两个小时后的时间
	fmt.Println(timeAfter)
}
输出结果
C:\Users\34826\AppData\Local\Temp\___go_build_main_go__1_.exe #gosetup
2021-03-25 19:24:51.48939 +0800 CST m=+7200.004987201

time.sub用法

//time.sub用法
func main() {
	startTime := time.Now()
	time.Sleep(2 * time.Second)
	endTime := time.Now()
	timeFrame := endTime.Sub(startTime)
	fmt.Println(timeFrame)
}
输出结果
C:\Users\34826\AppData\Local\Temp\___go_build_main_go__1_.exe #gosetup
2.0006539s

equal用法

//time.equal用法
func main() {
	startTime := time.Now()
	time.Sleep(time.Second)
	endTime := time.Now()

	timeFrame := endTime.Equal(startTime)  //比较两个时间的大小, 这里传入的是starttime.与endtime进行比较.
	fmt.Println(timeFrame)
}

输出结果
C:\Users\34826\AppData\Local\Temp\___go_build_main_go__1_.exe #gosetup
false

与sub用法类似.但是这里输出的是一个bool值

time.befor

//time.before用法
func main() {
	startTime := time.Now()
	time.Sleep(time.Second)
	endTime := time.Now()

	timeFrame := endTime.Before(startTime) //表示end在start之前的话显示true.否则显示false
	fmt.Println(timeFrame)
}
输出结果
C:\Users\34826\AppData\Local\Temp\___go_build_main_go__1_.exe #gosetup
false
两个时间进行顺序比较关系.谁在谁的前面.显示bool

After同理

//time.after用法
func main() {
	startTime := time.Now()
	time.Sleep(time.Second)
	endTime := time.Now()

	timeFrame := endTime.After(startTime) //表示end在start之前的话显示true.否则显示false
	fmt.Println(timeFrame)
}

输出结果
C:\Users\34826\AppData\Local\Temp\___go_build_main_go__1_.exe #gosetup
true

定时器

//定时器
func main() {
	ticker := time.Tick(time.Second) //设定一个1秒间隔的定时器.
	for i := range ticker {
		fmt.Println(i) //每秒执行一次打印
	}
}
输出结果
C:\Users\34826\AppData\Local\Temp\___go_build_main_go__1_.exe #gosetup
2021-03-25 17:53:53.318923 +0800 CST m=+1.004326801
2021-03-25 17:53:54.3202331 +0800 CST m=+2.005636901
2021-03-25 17:53:55.3205616 +0800 CST m=+3.005965401
2021-03-25 17:53:56.3188922 +0800 CST m=+4.004296001
这里输出的是一个疫苗的定时器.每隔1秒钟执行一次.

格式化显示当前时间

//时间戳格式化成编年体显示
func main() {
	now := time.Now()
	//24小时制
	fmt.Println(now.Format("2006-01-02 15:04:05.000 "))
	// 12小时制
	fmt.Println(now.Format("2006-01-02 03:04:05.000 PM Mon Jan"))
	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"))
}
输出结果:
C:\Users\34826\AppData\Local\Temp\___go_build_main_go__1_.exe #gosetup
2021-03-25 18:07:01.939
2021-03-25 06:07:01.939 PM Thu Mar
2021/03/25 18:07
18:07 2021/03/25
2021/03/25

按照指定格式指定时区解析时间

func main() {
	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", "2019/08/04 14:15:20", loc)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(timeObj)
	fmt.Println(timeObj.Sub(now))  //将以前的时间当做基准时间,然后减掉当前的时间.得到的结果进行打印
}
输出结果
2021-03-25 18:14:06.0814043 +0800 CST m=+0.003989801
2019-08-04 14:15:20 +0800 CST
-14379h58m46.0814043s

练习题：

1. 获取当前时间，格式化输出为2017/06/19 20:30:05`格式。
2. 编写程序统计一段代码的执行耗时时间，单位精确到微秒。