1.time.Time转string之Format方法

package main

import (
    "fmt"
    "time"
    "reflect"
)

const LayOut = "20060102"


func main(){
    now := time.Now()
    fmt.Println(reflect.TypeOf(now)) //time.Time
    nowStr := now.Format(LayOut)
    fmt.Println(nowStr) //20190508
    fmt.Println(reflect.TypeOf(nowStr)) //string

}

注意：使用time Format方法时，最好使用包内的常量类型。否则可能出现时间的变动。比如

const (
    ANSIC       = "Mon Jan _2 15:04:05 2006"
    UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
    RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
    RFC822      = "02 Jan 06 15:04 MST"
    RFC822Z     = "02 Jan 06 15:04 -0700" // RFC822 with numeric zone
    RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
    RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
    RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" // RFC1123 with numeric zone
    RFC3339     = "2006-01-02T15:04:05Z07:00"
    RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
    Kitchen     = "3:04PM"
    // Handy time stamps.
    Stamp      = "Jan _2 15:04:05"
    StampMilli = "Jan _2 15:04:05.000"
    StampMicro = "Jan _2 15:04:05.000000"
    StampNano  = "Jan _2 15:04:05.000000000"
)

如果上述常量无法满足需求，则可以自己定义常量

2. 时区问题

var ShanghaiTimeZone *time.Location

func InitTimeZone() {
    if location, err := time.LoadLocation("Asia/Shanghai"); err != nil {
        logrus.Panicln("Failed to load timezone Asia/Shanghai, err: ", err)
    } else {
        ShanghaiTimeZone = location
    }
}
now := time.Now().In(common.ShanghaiTimeZone)
nowStr := now.Format(TimeLayOut)
fmt.Println(nowStr)

3.string 转time.Time

package main

import (
    "fmt"
    "time"
    "reflect"
)

const LayOut = "20060102"


func main(){
    now := time.Now()
    fmt.Println(reflect.TypeOf(now))
    nowStr := now.Format(LayOut)
    fmt.Println(nowStr)
    fmt.Println(reflect.TypeOf(nowStr))
    nowTime, err := time.Parse(LayOut, nowStr)
    if err != nil {
    }
    fmt.Println(nowTime) //2019-05-08 00:00:00 +0000 UTC
    fmt.Println(reflect.TypeOf(nowTime))//time.Time
}

4.time.Time 转 int64

    now := time.Now()
    nowInt := now.Unix()
    fmt.Println(nowInt) // 1557280736
    fmt.Println(reflect.TypeOf(nowInt)) //int64

5.int64转time.Time

    nowTimeFromInt := time.Unix(nowInt, 0)
    fmt.Println(nowTimeFromInt) //2019-05-08 10:01:13 +0800 CST
    fmt.Println(reflect.TypeOf(nowTimeFromInt)) //time.Time

6.time.Time的时间加减计算

package main

import (
    "time"
    "fmt"
)
func main() {
    t1 := time.Now()
    t2 := t1.Add(time.Minute) //加一个分钟
    t3 := t1.Add(-3*time.Hour) // 减3个小时
    //分别指定年，月，日，时，分，秒，纳秒，时区
    ft := time.Date(2018, time.Month(1), 11, 5, 13, 32, 0, t1.Location())
    fmt.Println(ft)
    fmt.Println(t1, t2)
    if t3.After(t1) {
        fmt.Println("t3 is after t1")
    } else {
        fmt.Println("t3 is before t1")
    }
    fmt.Println(time.Since(t3)) // 从t3已经过去多长时间
}

输出结果：

2018-01-11 05:13:32 +0800 CST
2019-05-08 14:20:51.928066 +0800 CST m=+0.000256314 2019-05-08 14:21:51.928066 +0800 CST m=+60.000256314
t3 is before t1
3h0m0.000190914s

7.time.After超时应用

package main

import (
    "fmt"
    "time"
)

func main() {
    c := make(chan bool)
    select {
    case v:= <-c:
        fmt.Println(v)
    case <-time.After(3 * time.Second):
        fmt.Println("Timeout")
    }
}

8.简单的定时器NewTicker

每隔一秒钟，执行一次业务，直到定时器任务时间到期为止。

    ticker := time.NewTicker(time.Second)
    defer ticker.Stop()
    done := make(chan bool)
    go func() {
        time.Sleep(10 * time.Second)
        done <- true
    }()
    for {
        select {
        case <-done:
            fmt.Println("Done!")
            return
        case t := <-ticker.C:
            fmt.Println("Current time: ", t)
        }
    }

Output:

Current time:  2018-02-05 10:41:37.204211269 +0800 CST m=+1.001535613
Current time:  2018-02-05 10:41:38.204068714 +0800 CST m=+2.001320058
Current time:  2018-02-05 10:41:39.204252518 +0800 CST m=+3.001503862
Current time:  2018-02-05 10:41:40.204103403 +0800 CST m=+4.001281747
Current time:  2018-02-05 10:41:41.204360898 +0800 CST m=+5.001539242
Current time:  2018-02-05 10:41:42.204120805 +0800 CST m=+6.001227149
Current time:  2018-02-05 10:41:43.204406187 +0800 CST m=+7.001439531
Current time:  2018-02-05 10:41:44.203708482 +0800 CST m=+8.000741826
Current time:  2018-02-05 10:41:45.204431933 +0800 CST m=+9.001392277
Current time:  2018-02-05 10:41:46.204367246 +0800 CST m=+10.001327590
Done!

package main

import (
    "fmt"
    "time"
)

func main(){
    timer := time.NewTimer(12*time.Second)
    ticker := time.NewTicker(time.Second)
    go func () {
        for t := range ticker.C {
            fmt.Println("Tick at ", t)
        }
    }()
    <- timer.C
    ticker.Stop()
    fmt.Println("timer expired.")
}

9. Duration类型

// A Duration represents the elapsed time between two instants
// as an int64 nanosecond count. The representation limits the
// largest representable duration to approximately 290 years.
type Duration int64

Duration代表两个实例节点之间，经过的时间，以int64纳秒计数，该表示将最大可表示的持续时间限制为大约290年。

package main

import (
        "fmt"
        "time"
        "reflect"
)

func expensiveCall() {}

func main() {
        t0 := time.Now()
        time.Sleep(1*time.Second)
        t1 := time.Now()
        fmt.Printf("The call took %v to run.\n", t1.Sub(t0)) //The call took 1.002671497s to run.
        fmt.Println(reflect.TypeOf(t1.Sub(t0))) //time.Duration
}

10. ParseDuration方法

ParseDuration解析持续时间字符串。持续时间字符串是可能签名的十进制数字序列，每个都带有可选的分数和单位后缀，例如“300ms”，“ - 1.5h”或“2h45m”。有效时间单位是“ns”，“us”（或“μs”），“ms”，“s”，“m”，“h”。

package main

import (
    "fmt"
    "time"
)

func main() {
    hours, _ := time.ParseDuration("10h")
    complex, _ := time.ParseDuration("1h10m10s")

    fmt.Println(hours)  //10h0m0s
    fmt.Println(complex) //1h10m10s
    fmt.Printf("there are %.0f seconds in %v\n", complex.Seconds(), complex) //there are 4210 seconds in 1h10m10s
}

11. Hours方法

func (d Duration) Hours() float64 {
    hour := d / Hour
    nsec := d % Hour
    return float64(hour) + float64(nsec)/(60*60*1e9)
}

t4,_ := time.ParseDuration("4h30m")
fmt.Printf("%v\n",t4.Hours())

Output:

4.5

12.Minutes方法

func (d Duration) Minutes() float64 {
    min := d / Minute
    nsec := d % Minute
    return float64(min) + float64(nsec)/(60*1e9)
}

t4,_ := time.ParseDuration("4h30m")
fmt.Printf("%v\n",t4.Minutes())

Output:

13.Nanoseconds方法（纳秒）

func (d Duration) Nanoseconds() int64 {
        return int64(d) 
}

ns, _ := time.ParseDuration("1000ns")
fmt.Printf("one microsecond has %d nanoseconds.", ns.Nanoseconds())

Output:

one microsecond has 1000 nanoseconds.

Golang time包主要方法使用总结

Golang time包主要方法使用总结

1.time.Time转string之Format方法

2. 时区问题

3.string 转time.Time

4.time.Time 转 int64

5.int64转time.Time

6.time.Time的时间加减计算

7.time.After超时应用

8.简单的定时器NewTicker

9. Duration类型

10. ParseDuration方法

11. Hours方法

12.Minutes方法

13.Nanoseconds方法（纳秒）