一、时间模块
1. 统计程序执行时间
package main
import (
"time"
"fmt"
)
func test() {
time.Sleep(time.Millisecond*100)
}
func main() {
start := time.Now().UnixNano()
test()
end := time.Now().UnixNano()
fmt.Printf("cost:%d us\n",(end-start)/1000)
}2. 时间模块使用
(1) 生成时间Now/Date
// 当前时间使用 time.Now()获取.
// 获取使用time.Day(), time.Year() 获取部分日期
// 生成指定时间 time.Date()
package main
import (
"time"
"fmt"
)
func main() {
t := time.Now()
fmt.Println(t) // 2019-04-16 16:01:40.8493932 +0800 CST m=+0.002907801
fmt.Println(t.Date()) // 2019 April 16
fmt.Println(t.Year()) // 2019
fmt.Println(t.Month()) // April
fmt.Println(t.Day()) // 16
fmt.Println(t.Hour()) // 16
fmt.Println(t.Minute()) // 1
fmt.Println(t.Second()) // 40
fmt.Println(t.Weekday()) // Tuesday 星期二 返回当前日期是星期几
fmt.Println(t.YearDay()) // 106 返回当前日期在今年的第几天
fmt.Println(t.Zone()) // CST 28800 返回时间所表示的时区,以及时区与UTC时间的差值
// 需要注意的是t.Weekday() 返回的是 time.WeekDay类型, 而不是字符串
// 如果想要变成字符串 可以使用 t.Weekday().String()
}(2) 时间的加减Add和AddDate
// (t Time)Add(d Duration) Time
// Duration 脉冲时间. 加上对应的时间. time.Minute分钟 time.Hour小时 ...
// func (t Time) AddDate(years int, months int, days int) Time
// 加上日期, 如果想减去对应的时间, 数字写负数就行了
package main
import (
"time"
"fmt"
)
func main() {
t := time.Now()
fmt.Println(t)
//2019-04-16 16:57:58.9955704 +0800 CST m=+0.002002001
fmt.Println("10分钟后:", t.Add(time.Minute * 10))
//10分钟后: 2019-04-16 17:07:58.9955704 +0800 CST m=+600.002002001
fmt.Println("10分钟前:", t.Add(time.Minute * -10))
//10分钟前: 2019-04-16 16:47:58.9955704 +0800 CST m=-599.997997999
fmt.Println("1天后:", t.Add(time.Hour * 24))
//1天后: 2019-04-17 16:57:58.9955704 +0800 CST m=+86400.002002001
// AddDate(year, month, day)
fmt.Println("1天后:", t.AddDate(0,0,1))
//1天后: 2019-04-17 16:57:58.9955704 +0800 CST
}(3) 判断时间t1是否在时间t2后
// func (t Time) After(u Time) bool
// time t 是否在 time u 之后才发生
package main
import (
"time"
"fmt"
"reflect"
)
func main() {
t1 := time.Date(2019, 4, 16, 17, 9, 0, 0, time.Local)
fmt.Println(t1, reflect.TypeOf(t1))
//2019-04-16 17:09:00 +0800 CST time.Time
t2 := t1.AddDate(0,0,1)
fmt.Println(t2, reflect.TypeOf(t1))
//2019-04-17 17:09:00 +0800 CST time.Time
t3 := t1.AddDate(0,0,-1)
fmt.Println(t3, reflect.TypeOf(t1))
//2019-04-15 17:09:00 +0800 CST time.Time
fmt.Println(t1.After(t2)) // false
fmt.Println(t1.After(t3)) // true
}(4) 判断时间t1是否在时间t2前
func (t Time) Before(u Time) bool
// time t 是否在 time u 之前发生
代码参考 time.After(5) 格式化字符串与Time类型转换
package main
import (
"time"
"fmt"
"reflect"
)
func main() {
// parse解析一般分为两种, 一种是go语言定义了的format格式, 一种是自定义格式
// go语言定义的格式也可以称为标准格式字符串格式化
// time.Time类型转换为字符串类型, 可以使用 func (t Time) String() string
// 1. 标准格式字符串 解析为 time.Time类型
// 生成当前时间
t := time.Now()
fmt.Println(t, reflect.TypeOf(t))
// 2019-04-17 11:26:46.6982927 +0800 CST m=+0.002967801 time.Time
// 转换为标准时间字符串
utcTime := t.Format(time.RFC3339)
fmt.Println(utcTime, reflect.TypeOf(utcTime))
// 2019-04-17T11:26:46+08:00 string
// 标准时间字符串 转换为 time.Time 类型
new_t, err := time.Parse(time.RFC3339, utcTime) // 解析有可能会出错
if err != nil {
fmt.Println("解析错误, err:", err)
}
fmt.Println(new_t, reflect.TypeOf(new_t))
// 2019-04-17 11:26:46 +0800 CST time.Time
// 2. 自定义格式字符串 格式化
str := "2019-04-17 11:26:46"
fmt.Println(str, reflect.TypeOf(str))
new_t, err = time.Parse("2006-01-02 15:04:05", str)
if err != nil {
fmt.Println("解析失败, err:", err)
}
fmt.Println(new_t, reflect.TypeOf(new_t))
// 2019-04-17 11:26:46 +0000 UTC time.Time 可以看到是UTC时间了
// 解析的时间比实际大了8个小时
// 所以要减去增加的8个小时
new_t = new_t.Add(time.Hour * -8)
fmt.Println(new_t)
// 2019-04-17 03:26:46 +0000 UTC 转换成本地是 019-04-17 11:26:46 +0800 CST
// time.Time类型直接转为time.Time样式的字符串
// Format是转换为指定样式的字符串
t = time.Now()
fmt.Println(t, reflect.TypeOf(t))
// 2019-04-17 15:13:48.3207645 +0800 CST m=+0.002879301 time.Time
str = t.String()
fmt.Println(str, reflect.TypeOf(str))
// 2019-04-17 15:13:48.3207645 +0800 CST m=+0.002879301 string
}(6) Time类型和时间戳的转换
// 接口 func (t time.Time) Unix() int64 是由time类型转为时间戳
// 函数 func(i, int64, nsec int64) Time 是由时间戳类型转换为time.Time类型
// nsec 参数是指 转换为time.Time类型后 对应秒的精度(小数位的个数)
// 接口 func (t time.Time) Format(layout string) string 是将time.Time类型转为格式化字符串
package main
import (
"time"
"fmt"
)
func main() {
// 获取当前时间 或者使用 time.Date(year, month, ...)
t := time.Now()
fmt.Println(t) // 2019-04-17 10:48:08.6401348 +0800 CST m=+0.004012501
// 转换为时间戳 t.Unix()
timeStamp := t.Unix()
fmt.Println(timeStamp) // 1555469288
// 时间戳转换为格式化字符串
// 两步: 1 使用Unix func 转为time.Time类型 2.使用Format格式化为时间字符串
newT := time.Unix(timeStamp, 0) // nsec代表秒的精度
newT1 := time.Unix(timeStamp, 8)
fmt.Println(newT, newT1)
// 上面的两个time.Time类型打印结果
// 2019-04-17 10:48:08 +0800 CST 2019-04-17 10:48:08.000000008 +0800 CST
fmt.Println(newT1.Format("2006-01-02 15:04:05"))
// 2019-04-17 10:48:08
// 2006 和 01 02 03 04 05 都是代表特殊含义的
// 在go语言中, 每个格式化都有对应的特定值
// 年: 06 2006
// 月: 1 01 Jan January
// 日: 2 02 _2
// 时: 3 03 15 // 15 代表24小时表示法. 03代表12小时表示法
// 分: 4 04
// 秒: 5 05
// 时区: 美国(MST) 中国(CST) +00:00 +08:00
// 对于上面12 小时和24小时制格式化的值例子
newT = time.Date(2019,4,17,13,0,0,0, time.Local)
fmt.Println(newT) // 2019-04-17 13:00:00 +0800 CST
fmt.Println(newT.Format("2006-01-02 15:04:05")) // 2019-04-17 13:00:00
fmt.Println(newT.Format("2006-01-02 03:04:05")) // 2019-04-17 01:00:00
}(7) 生成一个时区对象
使用time.FixedZone(name string, offset int) 生成一个相较于utc时间的时区
比如在北京地区.
beiJing := time.FixedZone("BeiJing time", int((8*time.Hour).Seconds()))
t := time.Date(2019,4,17,14,21,0,0,time.Local)
t1 := time.Date(2019,4,17,14,21,0,0,beiJing)
t 和 t1的值是相等的两个时间(8) 判断不同时区的时间是否相等
package main
import (
"time"
"fmt"
)
func main() {
// 定义一个时区.time.FixedZone() 第一个参数是时区名字, 第二个参数是相比较于utc时间相差的秒数
// utc时区之后的采用正数, 之前的采用负数
beiJing := time.FixedZone("BeiJing time", int((time.Hour * 8).Seconds()))
t1 := time.Date(2019,4,17,6,21,0,0,time.UTC)
t2 := time.Date(2019,4,17,14,21,0,0,beiJing)
// 这里的beiJing就相当于是time.Local
fmt.Println(t1, t2)
// 2019-04-17 06:21:00 +0000 UTC 2019-04-17 14:21:00 +0800 BeiJing time
fmt.Println(t1.Equal(t2))
// true Equal接口可以搞定两个时区的时间是否相等
fmt.Println(t1 == t2)
// false 直接相等并不能比较两个不同时区的时间
}(9) 指定日期发生在当年第几周
package main
import (
"time"
"fmt"
)
func main() {
// 2019-01-01 是星期二
// func (t Time) ISOWeek() (year, week int)
t := time.Date(2019,1,1,1,1,1,0,time.Local)
fmt.Println(t.ISOWeek()) // 2019 1
t = time.Date(2019,1,7,1,1,1,0,time.Local)
fmt.Println(t.ISOWeek()) // 2019 2
t = time.Date(2019,1,13,1,1,1,0,time.Local)
fmt.Println(t.ISOWeek()) // 2019 2
t = time.Date(2019,1,14,1,1,1,0,time.Local)
fmt.Println(t.ISOWeek()) // 2019 3
}(10) 时区的转换
package main
import (
"time"
"fmt"
)
func main() {
// func (t Time) In(loc *Location) Time 是用来转换时区的
t,_ := time.Parse("2006-01-02 15:04:05", "2019-04-17 14:54:00")
fmt.Println(t) // 2019-04-17 14:54:00 +0000 UTC
local_t := converTimeZone(&t)
fmt.Println(local_t) //2019-04-17 14:54:00 +0800 BeiJingTime
// 可以看到时区被转换了
}
func converTimeZone(t *time.Time) time.Time {
return t.Add(time.Hour * -8).In(time.FixedZone("BeiJingTime", int((time.Hour * 8).Seconds())))
// 对于中国的北京时间 时区相较于UTC时间是相差8个小时
// 这里之所以先减8个小时, 是因为time.Parse将日期解析为了UTC时间
// 相当于2019-04-17 14:54:00的北京时间 变成了 2019-04-17 14:54:00的UTC时间
// 实际上应该是对应 2019-04-17 06:54:00 UTC
}
// 如果是本地时间time.Time类型, 可以直接使用 func (t Time) UTC() Time 转换为 utc 时间
package main
import (
"time"
"fmt"
)
func main() {
t := time.Now()
fmt.Println(t)
// 2019-04-17 15:44:09.6141006 +0800 CST m=+0.002998401
fmt.Println(t.UTC())
// 2019-04-17 07:44:09.6141006 +0000 UTC
}(11) 计算时间差
package main
import (
"time"
"fmt"
"reflect"
)
func main() {
// func (t Time) Sub(u Time) Duration 计算 t-u 差值
t1 := time.Date(2019,4,17,15,26,0,0,time.Local)
t2 := time.Date(2019,4,17,15,25,0,0,time.Local)
res := t1.Sub(t2)
fmt.Println(res, reflect.TypeOf(res), res.Seconds())
// 1m0s time.Duration 60
}
原文地址：https://www.cnblogs.com/hq82/p/11073386.html
时间： 2024-08-09 23:02:26