7. Go语言—时间模块

标签：before   func   timezone   解析错误   成本   字符串格式化   小数   after   自定义   

一、时间模块

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
}

7. Go语言—时间模块

标签：before   func   timezone   解析错误   成本   字符串格式化   小数   after   自定义   

原文地址：https://www.cnblogs.com/hq82/p/11073386.html