Go语言的time包

Location结构类型

type Location struct {  // 内含隐藏或非导出字段  }
代表一个地点以及该地点所在的时区

两个与预定义变量
var Local *Location = &localLoc
//代表系统本地，对应本地时区
var UTC *Location = &utcLoc
//代表通用协调，对应零时区

LoadLocation(name string) (*Location, error)：
    返回使用给定的名字创建的Location
    name应该是IANA时区数据库里有记录的地点名，如"America/New_York"
    name是空("")或"UTC"，返回UTC
    name是"Local"，返回Local

Time结构类型

type Time struct {  // 内含隐藏或非导出字段  }
代表一个纳秒精度的时间点
Time零值代表时间点"January 1, year 1, 00:00:00.000000000 UTC"

获取Time：

Now() Time ：返回本地当前时间
Unix(sec int64, nsec int64) Time ：根据一个时间戳返回UTC时间

Parse(layout, value string) (Time, error)：
    以layout指定的格式解析字符串value表示的时间并返回
    如果layout中缺少时区信息时，将时间解释为UTC时间
ParseInLocation(layout, value string, loc *Location) (Time, error)：
    作用同Parse函数
    不同的是如果layout中缺少时区信息时，将时间解释为loc指定时间

Time的格式化：

(t Time) Format(layout string) string ：
    根据layout指定的格式返回t代表的时间点的格式化文本

自定义时间格式layout参数

在Go中当表示时间自定义格式的时候并不是使用其他语言类似Y表示年、m表示月等字符这种格式，而是指定了一个固定的参考时间，以指定格式书写这个固定的参考时间就会解析成指定的时间，这个指定的时间是"2006-01-02 15:04:05.999999999 -0700 MST"

这个时间用英语表示就是：01/02 03:04:05PM 06 -0700，刚好是从1到7

任何位置的数字没有重复，这样如果我们不想要月份的前导0，则可以使用"1"表示，如果想使用12小时制显示小时则可以使用"03"表示，简单明了

其中2006就表示年，01表示月，以此类推
秒数后面的".999999999"中9个数量表示精确度，最多9位
-0700表示时区
Time.Now().Format("2006-01-02 15:04:05")会格式化当前时间为：
    2021-09-10 22:50:11

Time的操作

(t Time) Location() *Location：返回t的地点和时区信息
(t Time) Zone() (name string, offset int) ：
    返回t所在时区的规范名（如"CET"）和该时区相对于UTC的时间偏移量（单位秒）
(t Time) IsZero() bool ：t是否代表Time零值的时间
(t Time) Local() Time ：将t表示的时区转换为本地时区的时间
(t Time) UTC() Time ：将t表示的时区转换为UTC时区(零时区)的时间
(t Time) In(loc *Location) Time ：将t表示的时区转换为指定地区的时间
(t Time) Unix() int64 ：返回时间戳（单位秒）
(t Time) UnixNano() int64 ：返回时间戳（单位纳秒）
    如果结果超出了int64能表示的范围，结果是未定义的(Time零值的时间戳)
(t Time) Equal(u Time) bool ：判断两个时间是否相同，会考虑时区的影响
(t Time) Before(u Time) bool ：t代表的时间点是否在u之前
(t Time) After(u Time) bool ：t代表的时间点是否在u之后
(t Time) Date() (year int, month Month, day int) ：返回对应的年、月、日
(t Time) Clock() (hour, min, sec int) ：返回对应的时、分、秒
(t Time) Year() int ：返回对应的年份
(t Time) Month() Month ：返回对应的月份
(t Time) ISOWeek() (year, week int) ：返回ISO 9601标准下的年份和一年中的第几周
(t Time) YearDay() int ：返回一年中的第几天
(t Time) Day() int ：返回一月中的第几天
(t Time) Weekday() Weekday ：返回一周中的第几天，0表示周日
(t Time) Hour() int ：返回小时数
(t Time) Minute() int ：返回分钟数
(t Time) Second() int ： 返回秒数
(t Time) Nanosecond() int ：返回纳秒数，最多9位
(t Time) AddDate(years int, months int, days int) Time ：
    返回增加了给出的年份、月份和天数的时间点Time
    可以为负值
(t Time) String() string ：返回格式化时间
    采用"2006-01-02 15:04:05.999999999 -0700 MST"格式

(t Time) Add(d Duration) Time ：返回t+d的时间
(t Time) Sub(u Time) Duration ：返回一个时间段t-u。如果结果超出了Duration可以表示的最大值/最小值，将返回最大值/最小值
(t Time) Round(d Duration) Time ：返回距离t最近的时间点
    该时间点应该满足从Time零值到该时间点的时间段能整除d；
    如果有两个满足要求的时间点，距离t相同，会向上舍入；
    如果d <= 0，会返回t的拷贝。
(t Time) Truncate(d Duration) Time ：类似Round，但是返回的是最接近但早于t的时间点；如果d <= 0，会返回t的拷贝

时间段类型Duration

type Duration int64

代表时间段(两个时间点之间经过的时间)，以纳秒为单位。可表示的最长时间段大约290年

const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)
已经预定了常用的时间段常量

Sleep(d Duration)：
    Sleep阻塞当前go程序至少d代表的时间段

ParseDuration(s string) (Duration, error) :
    解析一个时间段字符串
    如"300ms"、"-1.5h"、"2h45m"
    合法的单位有"ns"、"us" "µs"、"ms"、"s"、"m"、"h"
Since(t Time) Duration ：返回从t到现在经过的时间
    等价于time.Now().Sub(t)
(d Duration) Hours() float64 ：将时间段表示为float64类型的小时数
(d Duration) Minutes() float64 ：将时间段表示为float64类型的分钟数
(d Duration) Seconds() float64 ：将时间段表示为float64类型的秒数
(d Duration) Nanoseconds() int64 ：将时间段表示为int64类型的纳秒数，等价于int64(d)
(d Duration) String() string ：返回时间段采用"72h3m0.5s"格式的字符串表示

Timer类型

type Timer struct {
    C <-chan Time
    // 内含隐藏或非导出字段
}
Timer类型代表单次时间事件。当Timer到期时，当时的时间会被发送给C，除非Timer是被AfterFunc函数创建的

NewTimer(d Duration) *Timer ：创建一个Timer
    它会在最少过去时间段d后到期
    然后向其自身的C字段发送当时的时间
AfterFunc(d Duration, f func()) *Timer ：
    另起一个go协程等待时间段d过去，然后调用f函数
    返回一个Timer，可以通过调用其Stop方法来取消等待和对f的调用
After(d Duration) <-chan Time ：
    会在另一线程经过时间段d后向返回值发送当时的时间
    等价于NewTimer(d).C
(t *Timer) Reset(d Duration) bool ：
    使t重新开始计时
    本方法返回后再等待时间段d过去后到期
    如果调用时t还在等待中会返回真
    如果t已经到期或者被停止了会返回假
(t *Timer) Stop() bool ：停止Timer的执行
    如果停止了t会返回真
    如果t已经被停止或者过期了会返回假
    不会关闭通道t.C，以避免从该通道的读取不正确的成功

Ticker类型

type Ticker struct {
    C <-chan Time // 周期性传递时间信息的通道
    // 内含隐藏或非导出字段
}
Ticker保管一个通道，并每隔一段时间向其传递当前时间

NewTicker(d Duration) *Ticker ：返回一个新的Ticker
    每隔时间段d就向该Ticker包含的通道发送当时的时间
    它会调整时间间隔或者丢弃传递的信息以适应反应慢的接收者
(t *Ticker) Stop() ：关闭一个Ticker
    在关闭后，将不会在发送信息
    不会关闭通道t.C，以避免从该通道的读取不正确的成功
Tick(d Duration) <-chan Time ：
    Tick是NewTicker的封装
    只提供对Ticker的通道的访问
    如果不需要关闭Ticker，本函数就很方便

我们可以利用Ticker来创建一个每隔一定时间就运行一次的定时器

func main(){
    tick:=time.NewTicker(1 * time.Second)
    defer tick.Stop()
    num := 0
    for i:=range tick.C{
        num+=1
        fmt.Println(i)
        if num==5{
            break
        }
    }
}