goalng——time包學習

一、星期：type Weekday int

const (
    Sunday Weekday = iota
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
)

（1）func (d Weekday) String() string　　

返回星期幾的英文名。

二、月份：type Month int

const (
    January Month = 1 + iota
    February
    March
    April
    May
    June
    July
    August
    September
    October
    November
    December
)

（1）func (m Month) String() string

返回月份英文名。　　

三、時間點：type Time struct{...}

（1）Time表明一個納秒精度的時間點。

（2）func Now() Time

返回當前本地時間。

（3）func (t Time) Equal(u Time) bool

判斷兩個時間是否相同，會考慮時區的影響，所以不一樣時區標準的時間也能夠正確比較。

本方法和用t==u不一樣，這種方法還會比較地點和時區信息。

（4）func (t Time) Before(u Time) bool

若是t表明的時間點在u以前，返回真；不然返回假。

（5）func (t Time) After(u Time) bool

若是t表明的時間點在u以後，返回真；不然返回假。

（6）func (t Time) Date() (year int, month Month, day int)

返回時間點t對應的年、月、日。

（7）func (t Time) Clock() (hour, min, sec int)

返回t對應的那一天的時、分、秒。

（8）func (t Time) Year() int

返回時間點t對應的年份。

（9）func (t Time) Month() Month

返回時間點t對應那一年的第幾月。

（10）func (t Time) Day() int

返回時間點t對應那一月的第幾日。

（11）func (t Time) Hour() int

返回t對應的那一天的第幾小時，範圍[0, 23]。

（12）func (t Time) Minute() int

返回t對應的那一小時的第幾分種，範圍[0, 59]。

（13）func (t Time) Second() int

返回t對應的那一分鐘的第幾秒，範圍[0, 59]。

（14）func (t Time) Nanosecond() int

返回t對應的那一秒內的納秒偏移量，範圍[0, 999999999]。

（15）func (t Time) YearDay() int

返回時間點t對應的那一年的第幾天，平年的返回值範圍[1,365]，閏年[1,366]。

（16）func (t Time) Weekday() Weekday

返回時間點t對應的那一週的周幾。

（17）func (t Time) Add(d Duration) Time

Add返回時間點t+d。

（18）func (t Time) AddDate(years int, months int, days int) Time

AddDate返回增長了給出的年份、月份和天數的時間點Time。

（19）func (t Time) Sub(u Time) Duration

返回一個時間段t-u。若是結果超出了Duration能夠表示的最大值/最小值，將返回最大值/最小值。

要獲取時間點t-d（d爲Duration），可使用t.Add(-d)。

（20）func (t Time) Format(layout string) string

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

 (21)func (t Time) String() string

返回採用"2006-01-02 15:04:05.999999999 -0700 MST"格式字符串的格式化時間。

四、納秒：type Duration int64

（1）兩個時間點之間通過的時間，以納秒爲單位。

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

（2）func ParseDuration(s string) (Duration, error)

ParseDuration解析一個時間段字符串。

一個時間段字符串是一個序列，每一個片斷包含可選的正負號、十進制數、可選的小數部分和單位後綴，如"300ms"、"-1.5h"、"2h45m"。

合法的單位有"ns"、"us" /"µs"、"ms"、"s"、"m"、"h"。　

（3）func Since(t Time) Duration

Since返回從t到如今通過的時間，等價於time.Now().Sub(t)。

（4）func (d Duration) Hours() float64

Hours將時間段表示爲float64類型的小時數。

（5）func (d Duration) Minutes() float64

Hours將時間段表示爲float64類型的分鐘數。

（6）func (d Duration) Seconds() float64

Hours將時間段表示爲float64類型的秒數。

（7）func (d Duration) Nanoseconds() int64

Hours將時間段表示爲int64類型的納秒數，等價於int64(d)。

（8）func (d Duration) String() string

返回時間段採用"72h3m0.5s"格式的字符串表示。　

package main

import (
	"fmt"
	"time"
)

func main() {
	//時間操做
	now := time.Now()
	fmt.Println(now)
	fmt.Println(now.Date())
	fmt.Println(now.Clock())
	fmt.Printf("%d/%d/%d %d:%d:%d\n", now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second())
	fmt.Println(now.Format("2006/01/02 03:04:05"))
	fmt.Println(now.Format("2006/01/02 15:04:05"))
	newTime := now.Add(time.Hour)
	fmt.Println(now.Format("2006/01/02 15:04:05"), newTime.Format("2006/01/02 15:04:05"))
	dur := newTime.Sub(now)
	fmt.Println(dur)
	//輸出
	// 2019-06-15 22:16:39.6012388 +0800 CST m=+0.002032901
	// 2019 June 15
	// 22 16 39
	// 2019/6/15 22:16:39
	// 2019/06/15 10:16:39
	// 2019/06/15 22:16:39
	// 2019/06/15 22:16:39 2019/06/15 23:16:39
	// 1h0m0s
}

五、定時器：type Timer struct{...}

（1）Timer類型表明單次時間事件。

當Timer到期時，當時的時間會被髮送給C <-chan Time，除非Timer是被AfterFunc函數建立的。

（2）func NewTimer(d Duration) *Timer

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

（3）func AfterFunc(d Duration, f func()) *Timer 

AfterFunc另起一個go程等待時間段d過去，而後調用f。

它返回一個Timer，能夠經過調用其Stop方法來取消等待和對f的調用。

（4）func (t *Timer) Reset(d Duration) bool

Reset使t從新開始計時，（本方法返回後再）等待時間段d過去後到期。

若是調用時t還在等待中會返回真；若是t已經到期或者被中止了會返回假。

（5）func (t *Timer) Stop() bool

Stop中止Timer的執行。

若是中止了t會返回真；若是t已經被中止或者過時了會返回假。

Stop不會關閉通道t.C，以免從該通道的讀取不正確的成功。

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	//一、定時器一秒後
	t1 := time.Now()
	timer := time.NewTimer(time.Second)
	t2 := <-timer.C
	dur := t2.Sub(t1)
	fmt.Println(dur)
	//二、定時器一秒後輸出
	time.AfterFunc(time.Second, func() {
		fmt.Println("one second")
	})
	time.Sleep(time.Second * 2)
	// 三、測試（運行結果根據隨機數而定）
	rand.Seed(time.Now().UnixNano())
	timer = time.AfterFunc(time.Second, func() {
		fmt.Println("do test")
	})
	for {
		n := rand.Intn(3)
		if n == 0 {
			break
		} else {
			fmt.Println("Reset", n)
			timer.Reset(time.Second * time.Duration(n))
		}
	}
	time.Sleep(time.Second * 1)
	fmt.Println(timer.Stop())
}

六、定時器：type Ticker struct{...}

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

（2）func NewTicker(d Duration) *Ticker

NewTicker返回一個新的Ticker，該Ticker包含一個通道字段，並會每隔時間段d就向該通道發送當時的時間。

它會調整時間間隔或者丟棄tick信息以適應反應慢的接收者。若是d<=0會panic。關閉該Ticker能夠釋放相關資源。

（3）func (t *Ticker) Stop()

Stop關閉一個Ticker。在關閉後，將不會發送更多的tick信息。

Stop不會關閉通道t.C，以免從該通道的讀取不正確的成功。

package main

import (
	"fmt"
	"time"
)

func main() {
	timer := time.NewTimer(time.Second * 5)
	ticker := time.NewTicker(time.Second * 1)
	for {
		select {
		case <-timer.C:
			fmt.Println("timer 執行一次結束")
		case <-ticker.C:
			fmt.Println("ticker 每隔一段時間執行一次")
		}
	}
	// ticker 每隔一段時間執行一次
	// ticker 每隔一段時間執行一次
	// ticker 每隔一段時間執行一次
	// ticker 每隔一段時間執行一次
	// ticker 每隔一段時間執行一次
	// timer 執行一次結束
	// ticker 每隔一段時間執行一次
	// ticker 每隔一段時間執行一次
	// ticker 每隔一段時間執行一次
	// ticker 每隔一段時間執行一次
	// ticker 每隔一段時間執行一次
	// ticker 每隔一段時間執行一次
	// ticker 每隔一段時間執行一次
	// ticker 每隔一段時間執行一次
	// ticker 每隔一段時間執行一次
	// ticker 每隔一段時間執行一次
	// ticker 每隔一段時間執行一次
	// ticker 每隔一段時間執行一次
	//...
}

七、其餘

（1）func Sleep(d Duration)

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

（2）func After(d Duration) <-chan Time

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

（3）func Tick(d Duration) <-chan Time

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