Go 標準庫 —— time 經常使用類型和方法

時間 2019-11-16

標籤標準 time 經常使用類型方法简体版

原文原文鏈接

time 包提供了時間的顯示和測量用的函數，日曆的計算採用的是公曆
本文僅整理演示經常使用的類型和方法，完整的可參考標準庫文檔golang

type Location

Location 表明一個（關聯到某個時間點的）地點，以及該地點所在的時區

func LoadLocation

func LoadLocation(name string) (*Location, error)

LoadLocation 返回使用給定的名字建立的 Location函數

type Time

Time 表明一個納秒精度的時間點

func Now

func Now() Time

Now 返回當前本地時間post

func Parse

func Parse(layout, value string) (Time, error)

Parse 解析一個格式化的時間字符串並返回它表明的時間。
layout 定義輸入的時間格式，value 的時間格式需與 layout 保持一致.net

Example：線程

t, _ := time.Parse("2006-01-02", "2018-05-31")
fmt.Println(t)

// 輸出:
// 2018-05-31 00:00:00 +0000 UTC

func ParseInLocation

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

ParseInLocation 功能與 Parse 相似，但有兩個重要的不一樣之處：
第一，當缺乏時區信息時，Parse 將時間解釋爲 UTC 時間，而 ParseInLocation 將返回值的 Location 設置爲 loc；
第二，當時間字符串提供了時區偏移量信息時，Parse 會嘗試去匹配本地時區，而 ParseInLocation 會去匹配 loc。code

Example：orm

loc, _ := time.LoadLocation("PRC")
t, _ := time.ParseInLocation("2006-01-02", "2018-05-31", loc)
fmt.Println(t)

// 輸出:
// 2018-05-31 00:00:00 +0800 CST

func (Time) Location

func (t Time) Location() *Location

Location 返回 t 的地點和時區信息協程

Example：htm

loc, _ := time.LoadLocation("PRC")
t, _ := time.ParseInLocation("2006-01-02", "2018-05-31", loc)
fmt.Println(t.Location())

// 輸出:
// PRC

func (Time) Unix

func (t Time) Unix() int64

Unix 將 t 表示爲 Unix 時間，即從時間點January 1, 1970 UTC到時間點 t 所通過的時間（單位：秒）事件

func (Time) Format

func (t Time) Format(layout string) string

Format 根據 layout 指定的格式返回 t 表明的時間點的格式化文本表示。layout 定義了參考時間：

Mon Jan 2 15:04:05 -0700 MST 2006

格式化後的字符串表示，它做爲指望輸出的例子。一樣的格式規則會被用於格式化時間。

Example：

loc, _ := time.LoadLocation("PRC")
t, _ := time.ParseInLocation("2006-01-02 15:04:05", "2018-05-31 09:22:19", loc)
fmt.Println(t)
fmt.Println(t.Format("2006-01-02 15:04:05"))

// 輸出:
// 2018-05-31 09:22:19 +0800 CST
// 2018-05-31 09:22:19

func (Time) String

func (t Time) String() string

String 返回採用以下格式字符串的格式化時間：

"2006-01-02 15:04:05.999999999 -0700 MST"

type Duration

Duration 類型表明兩個時間點之間通過的時間，以納秒爲單位。可表示的最長時間段大約290年。

經常使用的時間段：

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

Example：
要將整數個某時間單元表示爲 Duration 類型值，用乘法：

seconds := 100000
fmt.Println(time.Duration(seconds) * time.Second)

// 輸出:
// 27h46m40s

type Timer

type Timer struct {
    C <-chan Time
    // 內含隱藏或非導出字段
}

Timer 類型表明單次時間事件。當 Timer 到期時，當時的時間會被髮送給 C，除非 Timer 是被 AfterFunc 函數建立的。

func NewTimer

func NewTimer(d Duration) *Timer

NewTimer 建立一個 Timer，它會在最少過去時間段 d 後到期，向其自身的 C 字段發送當時的時間。

Example：

fmt.Println(time.Now())

timer := time.NewTimer(time.Second * 2)

<-timer.C

fmt.Println(time.Now())

// 輸出:
// 2018-06-04 12:55:32.426676958 +0800 CST m=+0.000332587
// 2018-06-04 12:55:34.42745008 +0800 CST m=+2.001045690

func AfterFunc

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

AfterFunc 另起一個 go 協程等待時間段 d 過去，而後調用 f。它返回一個 Timer，能夠經過調用其 Stop 方法來取消等待和對 f 的調用。

wait := sync.WaitGroup{}
fmt.Println("start", time.Now())

wait.Add(1)

timer := time.AfterFunc(time.Second * 3, func() {
    fmt.Println("get timer", time.Now())
    wait.Done()
})

time.Sleep(time.Second)
fmt.Println("sleep", time.Now())

timer.Reset(time.Second * 2)

wait.Wait()

// 輸出:
// start 2018-06-04 13:11:25.478294853 +0800 CST m=+0.000332881
// sleep 2018-06-04 13:11:26.480826469 +0800 CST m=+1.002156500
// get timer 2018-06-04 13:11:28.483455973 +0800 CST m=+3.003496118

func (*Timer) Reset

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

Reset 使 t 從新開始計時，（本方法返回後再）等待時間段 d 過去後到期。若是調用時 t 還在等待中會返回真；若是 t 已經到期或者被中止了會返回假。

wait := sync.WaitGroup{}
fmt.Println("start", time.Now())

wait.Add(1)
timer := time.NewTimer(time.Second * 2)

go func() {
    <-timer.C

    fmt.Println("get timer", time.Now())
    wait.Done()
}()

time.Sleep(time.Second)
fmt.Println("sleep", time.Now())

timer.Reset(time.Second * 3)

wait.Wait()

// 輸出:
// start 2018-06-04 13:07:51.780367114 +0800 CST m=+0.000324036
// sleep 2018-06-04 13:07:52.783389811 +0800 CST m=+1.003316644
// get timer 2018-06-04 13:07:55.784534298 +0800 CST m=+4.004371103

func (*Timer) Stop

func (t *Timer) Stop() bool

Stop 中止 Timer 的執行。若是中止了 t 會返回真；若是 t 已經被中止或者過時了會返回假。Stop 不會關閉通道 t.C，以免從該通道的讀取不正確的成功。

Example：

fmt.Println("start")

timer := time.NewTimer(time.Second * 2)

go func() {
    <-timer.C

    fmt.Println("get timer")
}()

if timer.Stop() {
    fmt.Println("timer stoped")
}

// 輸出:
// start
// timer stoped

type Ticker

type Ticker struct {
    C <-chan Time // 週期性傳遞時間信息的通道
    // 內含隱藏或非導出字段
}

Ticker 保管一個通道，並每隔一段時間向其傳遞"tick"。

func NewTicker

func NewTicker(d Duration) *Ticker

NewTicker 返回一個新的 Ticker，該 Ticker 包含一個通道字段，並會每隔時間段 d 就向該通道發送當時的時間。它會調整時間間隔或者丟棄 tick 信息以適應反應慢的接收者。若是d <= 0會觸發panic。關閉該 Ticker 能夠釋放相關資源。

Example：

fmt.Println("start", time.Now())

ticker := time.NewTicker(time.Second)

go func() {
    for tick := range ticker.C {
        fmt.Println("tick at", tick)
    }
}()

time.Sleep(time.Second * 5)
ticker.Stop()

fmt.Println("stoped", time.Now())

// 輸出: 
// start 2018-06-04 13:21:20.443700752 +0800 CST m=+0.000376994
// tick at 2018-06-04 13:21:21.448276294 +0800 CST m=+1.004922401
// tick at 2018-06-04 13:21:22.44666211 +0800 CST m=+2.003278267
// tick at 2018-06-04 13:21:23.446749266 +0800 CST m=+3.003335423
// tick at 2018-06-04 13:21:24.445154097 +0800 CST m=+4.001710303
// stoped 2018-06-04 13:21:25.445239727 +0800 CST m=+5.001765933

func Sleep

func Sleep(d Duration)

Sleep 阻塞當前 go 協程至少 d 時間段。d <= 0時，Sleep 會馬上返回。

func After

func After(d Duration) <-chan Time

After 會在另外一線程通過時間段 d 後向返回值發送當時的時間。等價於NewTimer(d).C。

Example：

fmt.Println("start", time.Now())

timer := time.After(time.Second)

select {
case t := <-timer:
    fmt.Println("get timer", t)
}

fmt.Println("stoped", time.Now())

// 輸出:
// start 2018-06-04 13:35:23.367586344 +0800 CST m=+0.000370476
// get timer 2018-06-04 13:35:24.368447041 +0800 CST m=+1.001201148
// stoped 2018-06-04 13:35:24.368787684 +0800 CST m=+1.001541781

func Tick

func Tick(d Duration) <-chan Time

Tick 是 NewTicker 的封裝，只提供對 Ticker 的通道的訪問。若是不須要關閉 Ticker，本函數就很方便。

Example：

fmt.Println("start", time.Now())

count := 0
wait := sync.WaitGroup{}
wait.Add(1)
ticker := time.Tick(time.Second)

go func() {
    for tick := range ticker {
        count += 1
        fmt.Println("tick at", tick)

        if count >= 5 {
            wait.Done()
            break
        }
    }
}()

wait.Wait()

fmt.Println("stoped", time.Now())

// 輸出:
// start 2018-06-04 13:30:56.49323192 +0800 CST m=+0.000306375
// tick at 2018-06-04 13:30:57.493468434 +0800 CST m=+1.000512884
// tick at 2018-06-04 13:30:58.493509786 +0800 CST m=+2.000524236
// tick at 2018-06-04 13:30:59.494584076 +0800 CST m=+3.001568495
// tick at 2018-06-04 13:31:00.494248484 +0800 CST m=+4.001202915
// tick at 2018-06-04 13:31:01.498742563 +0800 CST m=+5.005666860
// stoped 2018-06-04 13:31:01.499025155 +0800 CST m=+5.005949444