goalng——time包学习

1、星期：type Weekday int

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

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

返回星期几的英文名。

2、月份：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

返回月份英文名。　　

3、时间点：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"格式字符串的格式化时间。

4、纳秒：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
}

5、定时器：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() {
	//1、定时器一秒后
	t1 := time.Now()
	timer := time.NewTimer(time.Second)
	t2 := <-timer.C
	dur := t2.Sub(t1)
	fmt.Println(dur)
	//2、定时器一秒后输出
	time.AfterFunc(time.Second, func() {
		fmt.Println("one second")
	})
	time.Sleep(time.Second * 2)
	// 3、测试（运行结果根据随机数而定）
	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())
}

6、定时器：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 每隔一段时间执行一次
	//...
}

7、其他

（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，本函数就很方便。