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") //設定指定時區，指定為亞洲上海時區

五：時間段

• 1、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

• 2、將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

六：時間計算

相加

• 1、根據時間段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

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

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

相減

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

func (t Time) Sub(u Time) Duration

• 2、返回與當前時間的時間差 (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)

• 3、與當前時間相減 (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：ashitani.jp/golangtips/tips_time.h...
• 3：my.oschina.net/90design/blog/11541...
• 4：www.cnblogs.com/zhepama/archive/20...
• 5：tonybai.com/2016/12/21/how-to-use-...

本作品採用《CC 協議》，轉載必須註明作者和本文連結