zoukankan      html  css  js  c++  java
  • 7. Go语言—时间模块

    一、时间模块

    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
    ",(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
    }
    
    
  • 相关阅读:
    Qt计算器开发(三):执行效果及项目总结
    [HNOI2019]校园旅行
    How to fix nuget Unrecognized license type MIT when pack
    How to fix nuget Unrecognized license type MIT when pack
    git 通过 SublimeMerge 处理冲突
    git 通过 SublimeMerge 处理冲突
    git 上传当前分支
    git 上传当前分支
    gif 格式
    gif 格式
  • 原文地址:https://www.cnblogs.com/hq82/p/11073386.html
Copyright © 2011-2022 走看看