Go package(1) time 用法

Go package(1) time 用法

golang使用的版本：

go version go1.10.3

一：功能介紹

time的一些功能，好比時區，像linux中的定時器，時間計算等

• 格式化時間
• 時區(Location)
• 時間計算
• Ticker
• Timer(定時器)

Time通常分爲時間Time 和 時段Duration

二：Time 結構體

time結構體定義：

type Time struct {
    wall unit64     //表示距離公元1年1月1日00:00:00UTC的秒數
    ext  int64      //表示納秒
    loc  *Location  //表明時區，主要處理偏移量。由於不一樣的時區，對應的時間不同
}

上面的loc表示時區， 那什麼是時區呢？
由於地球是圓的，因此同一個時刻，在地球的一邊是白天，一邊是黑夜。而由於人類使用一天 24 小時的制度，因此，在地球對角的兩邊就應該差了 12 的小時纔對。因爲同一個時間點上面， 整個地球的時間應該都不同，爲了解決這個問題，因此能夠想見的，地球就被分紅 24 個時區了，
由於繞地球一圈是 360 度角，這 360 度角共分爲 24 個時區，固然一個時區就是 15 度角啦！ 又因爲是以格林威治時間爲標準時間( Greenwich Mean Time, GMT 時間)，加上地球自轉的關係，所以，在格林威治以東的區域時間是比較快的(+小時)， 而以西的地方固然就是較慢囉！

UTC又是什麼 ？
在計算時間的時候，最準確的計算應該是使用‘原子震盪週期’所計算的物理時鐘了 (Atomic Clock, 也被稱爲原子鐘)，這也被定義爲標準時間 (International Atomic Time)。而咱們經常看見的 UTC 也就是 Coordinated Universal Time (協和標準時間)就是利用這種 Atomic Clock 爲基準所定義出來的正確時間。例如 1999 年在美國啓用的原子鐘 NIST F-1， 他所產生的時間偏差每兩千年才差一秒鐘！真的是很準吶！ 這個 UTC 標準時間是以 GMT 這個時區爲主的喔！因此本地時間與 UTC 時間的時差就是本地時間與 GMT 時間的時差就是了！

UTC + 時區差 ＝ 本地時間,
國內通常使用的是北京時間，與UTC的時間關係以下：
UTC + 8個小時 = 北京時間

更多關於時間的內容請查看 鳥哥的私房菜

初始化Time (struct)

下面的這些函數都是返回結構體Time，至關於把不一樣類型的日期格式初始化爲結構體Time

• 當前時間

func Now() Time

例子1：

fmt.Println(time.Now())
//output: 2019-04-25 23:15:12.2473056 +0800 CST m=+0.042979701

fmt.Println(time.Now().Year(), time.Now().Month())
//output: 2019 April

從上面能夠看出，Now()返回的是一個+0800 CST 的時間

• Parse 將字符串轉換爲Time類型

func Parse(layout, value string, defaultLocation, local *Location) (Time, error)

layout 定義輸入的時間格式，value 的時間格式需與 layout 保持一致

例子1：

fmt.Println(time.Parse("2006-01-02 15:04:05", "2018-04-23 00:00:23"))
//output: 2018-04-23 00:00:23 +0000 UTC <nil>

從上面示例能夠看出，Parse()默認返回的是+0000 UTC 時間

• ParseInLocation 功能與 Parse 相似，但有兩個重要的不一樣之處：

  • 第一，當缺乏時區信息時，Parse 將時間解釋爲 UTC 時間，而 ParseInLocation 將返回值的 Location 設置爲 loc；
  • 第二，當時間字符串提供了時區偏移量信息時，Parse 會嘗試去匹配本地時區，而 ParseInLocation 會去匹配 loc。

func ParseInLocation(layout, value string, loc *Location) (Time, error)

例子1：

fmt.Println(time.ParseInLocation("2006-01-02 15:04:05", "2017-05-11 14:06:06", time.Local))
//output: 2017-05-11 14:06:06 +0800 CST <nil>

• Unix
  

根據秒和納秒返回一個時間

func Unix(sec int64, nsec int64) Time

例子1：

fmt.Println(time.Unix(1e9, 0))
//output:2001-09-09 09:46:40 +0800 CST

• Date

func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time

例子1：

fmt.Println(time.Date(2018, 1, 2, 15, 30, 10, 0, time.Local))
//output: 2018-01-02 15:30:10 +0800 CST

• Local
  

返回本地時間

func (t Time) Local() Time

例子1：

fmt.Println(time.Now())
fmt.Println(time.Now().Local())
//output:  2019-03-26 00:51:19.5597562 +0800 CST m=+0.006832001
//output:  2019-03-26 00:51:19.5987973 +0800 CST

其餘的返回Time的方法，請到 godoc 查看time方法列表

三：時間的格式化

• Format
  

把時間(string)轉化爲string格式

func (t Time) Format(layout string) string

例子1：

fmt.Println(time.Now().Format("2006-01-02 15:04:05"))
fmt.Println(time.Now().Format("2006/01/02"))
//2019-03-26 01:20:55
//2019/03/26

const TimeFormat = "15:04:05"
fmt.Println(time.Now().Format(TimeFormat))
//02:05:52

const MicroFormat = "2006/01/02 15:04:05.000000"
fmt.Println(time.Now().Format(MicroFormat))
//2019/03/26 02:07:45.051045

• 返回Unix時間戳

func (t Time) Unix() int64

例子1：返回如今時間的時間戳

fmt.Println(time.Now().Unix())
// 1553580240

例子2：返回指定格式日期的時間戳

t, _ := time.Parse("2006-01-02 15:04:05", "2018-03-23 00:00:23")
fmt.Println(t.Unix())
//1524441623

• 時間戳轉日期

Unix(sec int64, nsec int64) Time

把時間time轉化爲日期date

例子1：

fmt.Println(time.Unix(time.Now().Unix(), 0))
//2019-03-26 02:03:45 +0800 CST

• 返回年月日星期

返回Time結構體後，就能夠調用Time的一些方法獲得年月日

例子1：

t := time.Now()
fmt.Println(t.Year())
fmt.Println(t.Month())
fmt.Println(t.Day())
fmt.Pritnln(t.Weekday())

• 年月日返回日期

用Date() 函數實現

例子1：

t := time.Date(2012, 2, 20, 23, 59, 59, 0, time.UTC)
fmt.Println(t)
//2012-02-20 23:59:59 +0000 UTC

t = time.Date(2012, 2, 20, 23, 59, 59, 0, time.Local)
fmt.Println(t)
//2012-02-20 23:59:59 +0800 CST

Date()函數後面還能夠加一個時區參數，獲得相關時區的日期

四：時區

• 設置時區的函數

LoadLocation(name string) (*Location, error)

例子1：

loc, _ := time.LoadLocation("Asia/Shanghai") //設置時區
t, _ := time.ParseInLocation("2006-01-02 15:04:05", "2012-02-20 15:07:51", loc)
fmt.Println(t)
fmt.Println(t.Unix()) //獲取時間戳
//2012-02-20 15:07:51 +0800 CST
//1329721671

例子2：

loc, _ := time.LoadLocation("Asia/Shanghai") //設置時區
t := time.Unix(1329721671, 0)
fmt.Println(t.In(loc).Format("2006-01-02 15:04:05"))
//2012-02-20 15:07:51

• LoadLocation函數的一些經常使用參數：

loc, err := time.LoadLocation("")     //默認UTC時間
loc, err := time.LoadLocation("local") //服務器設定本地時區，通常爲CST
loc, err := time.LoadLocation("Asia/Shanghai") //設置指定時區，指定爲亞洲上海時區

五：時間段

• 一、Duration 定義

type Duration int64

定義瞭如下持續時間類型.多用於時間的加減須要傳入Duration作爲參數的時候

const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)

例子1：
這個咱們寫一個完整的例子

package main

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

func main() {
    fmt.Println(reflect.TypeOf(1))
    fmt.Println(reflect.TypeOf(1 * time.Second))
}
//int
//time.Duration

• 二、將duration字符串轉化爲Duration類型

func ParseDuration(s string) (Duration, error)

例子2：

td, _ := time.ParseDuration("2h20m")
fmt.Println(td)
fmt.Println("min:", td.Minutes(), "second:", td.Seconds())
//min: 140 second: 8400

六：時間計算

相加

• 一、根據時間段Duration相加

func (t Time) Add(d Duration) Time

例子1：

t := time.Date(2012, 2, 20, 23, 59, 59, 0, time.Local)
fmt.Println(t)

t = t.Add(60 * time.Second) //加60秒
fmt.Println(t)

t = t.Add(1 * time.Hour)  //加1小時
fmt.Println(t)

//output:
//2012-02-20 23:59:59 +0800 CST
//2012-02-21 00:00:59 +0800 CST
//2012-02-21 00:59:59 +0800 CST

• 二、根據年，月，日來相加

func (t Time) AddDate(years int, months int, days int) Time

例子2：

t = time.Date(2019, 3, 25, 23, 59, 59, 0, time.Local)
t2 := t.AddDate(0, 0, 1) //增長 1日
fmt.Println(t2)

t2 = t.AddDate(2, 0, 0) //增長 2年
fmt.Println(t2)

//output:
//2019-03-26 23:59:59 +0800 CST
//2021-03-25 23:59:59 +0800 CST

相減

• 一、計算2個時間的時差 (參數 t-u)

func (t Time) Sub(u Time) Duration

• 二、返回與當前時間的時間差 (Now - t)

func Since(t Time) Duration:

例子1：

t := time.Date(2019, 4, 25, 23, 59, 59, 0, time.Local)
fmt.Println(t)
sub := t.Sub(time.Now())  // t - time.Now()
fmt.Println(sub)

sub = time.Since(t) //time.Now() - t, 至關於time.Now().Sub(t)
fmt.Println(sub)

• 三、與當前時間相減 (t - Now)

func Until(t Time) Duration

函數原型

// Until returns the duration until t.
// It is shorthand for t.Sub(time.Now()).
func Until(t Time) Duration {
    return t.Sub(Now())
}

例子1：

t := time.Date(2019, 3, 25, 23, 59, 59, 0, time.Local)
fmt.Println(t)
t3 := time.Until(t)
fmt.Println(t3) //至關於 t - Now() 至關於 t.Sub(time.Now())

比較

• 時間t是否在u以前

func (t Time) Before(u Time) bool

• 時間t是否在u以後

func (t Time) After(u Time) bool

• 2時間是否相等

func (t Time) Equal(u Time) bool

例子1：

t := time.Date(2012, 2, 20, 23, 59, 59, 0, time.Local)
now := time.Now()
ok := t.Before(now)
fmt.Println(ok)

ok = t.After(now)
fmt.Println(ok)

ok = t.Equal(now)
fmt.Println(ok)

//true
//false
//false

七：Ticker

Ticker:  按照指定的週期來調用函數或計算表達式

• Ticker結構

type Ticker struct {
    C <-chan Time // The channel on which the ticks are delivered.
    r runtimeTimer
}

• 建立一個Ticker

func NewTicker(d Duration) *Ticker

例子1：
能夠取消定時

package main

import (
    "fmt"
    "time"
)

func main() {
    //NewTicker 函數能夠取消定時
    ticker := time.NewTicker(time.Millisecond * 500)
    go func() {
        for t := range ticker.C {
            fmt.Println("Tick at", t)
        }
    }()

    time.Sleep(time.Millisecond * 1500) //阻塞
    ticker.Stop() //中止ticker
    fmt.Println("Ticker stopped")
}

//Tick at 2019-03-26 18:53:34.3215978 +0800 CST m=+0.506824001
//Tick at 2019-03-26 18:53:34.8226754 +0800 CST m=+1.007901601
//Ticker stopped

例子2：不能取消定時的Tick，因此咱們通常用上面的NewTicker

package main

import (
    "fmt"
    "time"
)

func main() {
    tick := time.Tick(2 * time.Second)
    for v := range tick {
        fmt.Println("Tick val:", v)
    }
}

//Tick val: 2019-03-26 18:04:10.3579389 +0800 CST m=+2.007946901
//Tick val: 2019-03-26 18:04:12.3586132 +0800 CST m=+4.008621301
//Tick val: 2019-03-26 18:04:14.3570512 +0800 CST m=+6.007059201
//Tick val: 2019-03-26 18:04:16.3580495 +0800 CST m=+8.008057601

八：定時器Timer

Timer: Timer類型用來表明一個獨立的事件，當設置的時間過時後，發送當前時間到channel

使用Timer定時器，超時後須要重置，才能繼續觸發

• Timer結構：

type Timer struct {
    C <-chan Time
    r runtimeTimer
}

• 建立新的定時器

func NewTimer(d Duration) *Timer

• 中止定時器

func (t *Timer) Stop() bool

• 重置定時器，以 d 爲觸發時間

func (t *Timer) Reset(d Duration) bool

例子1：

package main

import (
    "fmt"
    "time"
)

func main() {
    timer1 := time.NewTimer(2 * time.Second)

    <-timer1.C
    fmt.Println("Timer 1 expired")

    timer2 := time.NewTimer(time.Second)
    go func() {
        <-timer2.C
        fmt.Println("Timer 2 expired")
    }()
    stop2 := timer2.Stop()
    if stop2 {
        fmt.Println("Timer 2 stopped")
    }
}

• 過多長時間運行func函數

func AfterFunc(d Duration, f func()) *Timer

例子1：

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Second * 5
    timer := time.AfterFunc(t, func() {
        fmt.Printf("you %d second timer finished", t)
    })
    defer timer.Stop()
    time.Sleep(time.Second * 6)
}

• After() 在通過時長 d 以後，向返回的只讀信道發送當前時間

func After(d Duration) <-chan Time

例子1：

package main

import (
    "fmt"
    "time"
)

func main() {
    done := make(chan struct{}) //採用協程等待結束

    go func(ch <-chan time.Time) {
        fmt.Printf("Now is %s\n", <-ch)
        done <- struct{}{} // 通知主線程協程退出
    }(time.After(time.Second * 3)) //調用After，將返回的只讀信道傳遞給協程函數

    <-done

    close(done)
}

參考：

• 1：https://qiita.com/wMETAw/items/2c3120d1338c646ecfba#時刻から文字列を生成
• 2：https://ashitani.jp/golangtips/tips_time.html
• 3：https://my.oschina.net/90design/blog/1154133
• 4：https://www.cnblogs.com/zhepama/archive/2013/04/12/3017230.html
• 5：https://tonybai.com/2016/12/21/how-to-use-timer-reset-in-golang-correctly/