Black Lives Matter. Support the Equal Justice Initiative.

Package time

import "time"
Overview
Index
Examples

Overview ▾

打包时间提供了用于测量和显示时间的功能.

日历计算始终采用公历,没有leap秒.

Monotonic Clocks

Operating systems provide both a “wall clock,” which is subject to changes for clock synchronization, and a “monotonic clock,” which is not. The general rule is that the wall clock is for telling time and the monotonic clock is for measuring time. Rather than split the API, in this package the Time returned by time.Now contains both a wall clock reading and a monotonic clock reading; later time-telling operations use the wall clock reading, but later time-measuring operations, specifically comparisons and subtractions, use the monotonic clock reading.

例如,即使在计时操作期间更改了挂钟,此代码也始终会计算约20毫秒的正经过时间:

start := time.Now()
... operation that takes 20 milliseconds ...
t := time.Now()
elapsed := t.Sub(start)

类似的其他习惯用法,例如time.Since(start),time.Until(deadline)和time.Now().Before(deadline),对挂钟重置也同样有效.

本节的其余部分提供了有关操作如何使用单调时钟的精确详细信息,但是使用此程序包不需要了解这些详细信息.

按时间返回的时间.现在包含单调时钟读数. 如果时间t具有单调时钟读数,则t.Add将相同的持续时间添加到挂钟和单调时钟读数中以计算结果. 因为t.AddDate(y,m,d),t.Round(d)和t.Truncate(d)是墙上时间计算,所以它们总是从结果中剥离任何单调时钟读数. 因为使用t.In,t.Local和t.UTC来影响墙壁时间,所以它们也会从结果中剥离任何单调时钟读数. 剥离单调时钟读数的典型方法是使用t = t.Round(0).

如果时间t和u都包含单调时钟读数,则仅使用单调时钟读数执行操作t.After(u),t.Before(u),t.Equal(u)和t.Sub(u). ,忽略挂钟读数. 如果t或u不包含单调时钟读数,则这些操作将退回到使用墙上时钟读数.

在某些系统上,如果计算机进入睡眠状态,单调时钟将停止. 在这样的系统上,t.Sub(u)可能无法准确反映t和u之间经过的实际时间.

由于单调时钟读数在当前过程之外没有任何意义,因此t.GobEncode,t.MarshalBinary,t.MarshalJSON和t.MarshalText生成的序列化形式将忽略单调时钟读数,而t.Format不为其提供任何格式. 同样,构造函数time.Date,time.Parse,time.ParseInLocation和time.Unix,以及解组器t.GobDecode和t.UnmarshalBinary. t.UnmarshalJSON和t.UnmarshalText始终创建没有单调时钟读数的时间.

请注意,Go ==运算符不仅会比较即时时间,还会比较"位置"和单调时钟读数. 有关时间值的相等性测试的讨论,请参见时间类型的文档.

对于调试,t.String的结果的确包含单调时钟读数(如果存在). 如果由于不同的单调时钟读数而导致t!= u,则在打印t.String()和u.String()时,可以看到该差异.

Index ▾

Constants
func After(d Duration) <-chan Time
func Sleep(d Duration)
func Tick(d Duration) <-chan Time
type Duration
    func ParseDuration(s string) (Duration, error)
    func Since(t Time) Duration
    func Until(t Time) Duration
    func (d Duration) Hours() float64
    func (d Duration) Microseconds() int64
    func (d Duration) Milliseconds() int64
    func (d Duration) Minutes() float64
    func (d Duration) Nanoseconds() int64
    func (d Duration) Round(m Duration) Duration
    func (d Duration) Seconds() float64
    func (d Duration) String() string
    func (d Duration) Truncate(m Duration) Duration
type Location
    func FixedZone(name string, offset int) *Location
    func LoadLocation(name string) (*Location, error)
    func LoadLocationFromTZData(name string, data []byte) (*Location, error)
    func (l *Location) String() string
type Month
    func (m Month) String() string
type ParseError
    func (e *ParseError) Error() string
type Ticker
    func NewTicker(d Duration) *Ticker
    func (t *Ticker) Stop()
type Time
    func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time
    func Now() Time
    func Parse(layout, value string) (Time, error)
    func ParseInLocation(layout, value string, loc *Location) (Time, error)
    func Unix(sec int64, nsec int64) Time
    func (t Time) Add(d Duration) Time
    func (t Time) AddDate(years int, months int, days int) Time
    func (t Time) After(u Time) bool
    func (t Time) AppendFormat(b []byte, layout string) []byte
    func (t Time) Before(u Time) bool
    func (t Time) Clock() (hour, min, sec int)
    func (t Time) Date() (year int, month Month, day int)
    func (t Time) Day() int
    func (t Time) Equal(u Time) bool
    func (t Time) Format(layout string) string
    func (t *Time) GobDecode(data []byte) error
    func (t Time) GobEncode() ([]byte, error)
    func (t Time) Hour() int
    func (t Time) ISOWeek() (year, week int)
    func (t Time) In(loc *Location) Time
    func (t Time) IsZero() bool
    func (t Time) Local() Time
    func (t Time) Location() *Location
    func (t Time) MarshalBinary() ([]byte, error)
    func (t Time) MarshalJSON() ([]byte, error)
    func (t Time) MarshalText() ([]byte, error)
    func (t Time) Minute() int
    func (t Time) Month() Month
    func (t Time) Nanosecond() int
    func (t Time) Round(d Duration) Time
    func (t Time) Second() int
    func (t Time) String() string
    func (t Time) Sub(u Time) Duration
    func (t Time) Truncate(d Duration) Time
    func (t Time) UTC() Time
    func (t Time) Unix() int64
    func (t Time) UnixNano() int64
    func (t *Time) UnmarshalBinary(data []byte) error
    func (t *Time) UnmarshalJSON(data []byte) error
    func (t *Time) UnmarshalText(data []byte) error
    func (t Time) Weekday() Weekday
    func (t Time) Year() int
    func (t Time) YearDay() int
    func (t Time) Zone() (name string, offset int)
type Timer
    func AfterFunc(d Duration, f func()) *Timer
    func NewTimer(d Duration) *Timer
    func (t *Timer) Reset(d Duration) bool
    func (t *Timer) Stop() bool
type Weekday
    func (d Weekday) String() string

Package files

format.go sleep.go sys_unix.go tick.go time.go zoneinfo.go zoneinfo_read.go zoneinfo_unix.go

Constants

这些是预定义的布局,用于Time.Format和time.Parse. 布局中使用的参考时间为特定时间:

Mon Jan 2 15:04:05 MST 2006

这是Unix时间1136239445.由于MST是GMT-0700,因此参考时间可以认为是

01/02 03:04:05PM '06 -0700

要定义自己的格式,请写下参考时间,以哪种方式格式化; 有关示例,请参见ANSIC,StampMicro或Kitchen等常数的值. 该模型将演示参考时间的外观,以便Format和Parse方法可以将相同的转换应用于一般时间值.

某些有效的布局对于time.Parse来说是无效的时间值,这是因为格式,例如_表示空格填充,Z表示区域信息.

在格式字符串中,下划线_表示如果后面的数字(一天)有两位数字,可以用一位数字代替空格. 与固定宽度的Unix时间格式兼容.

小数点后跟一个或多个零表示小数秒,打印到给定的小数位数. 小数点后跟一个或多个9代表一个小数秒,打印到给定的小数位数,并且删除了结尾的零. 解析时(仅),即使布局不表示其存在,输入也可能在秒字段之后立即包含分数秒字段. 在这种情况下,小数点后跟最大的数字序列被解析为小数秒.

数字时区偏移量格式如下:

-0700  ±hhmm
-07:00 ±hh:mm
-07    ±hh

用Z替换格式中的符号会触发ISO 8601打印Z的行为,而不是UTC区域的偏移量. 从而:

Z0700  Z or ±hhmm
Z07:00 Z or ±hh:mm
Z07    Z or ±hh

公认的星期几格式为"星期一"和"星期一". 公认的月份格式为"一月"和"一月".

格式2,_2和02是每月的无填充,有空格填充和零填充. 格式__2和002是一年中的三个字符的空格和零填充; 没有一年中未填充的日期格式.

格式字符串中未被识别为参考时间的文本将在"格式化"期间逐字回显,并希望在"解析"的输入中逐字出现.

Time.Format的可执行示例详细说明了布局字符串的工作原理,是一个很好的参考.

请注意,RFC822,RFC850和RFC1123格式应仅应用于本地时间. 将它们应用于UTC时间将使用" UTC"作为时区缩写,而严格地说,在这种情况下,那些RFC要求使用" GMT". 通常,对于坚持使用该格式的服务器,应使用RFC1123Z代替RFC1123,对于新协议,应首选RFC3339. RFC3339,RFC822,RFC822Z,RFC1123和RFC1123Z对于格式化非常有用. 当与time.Parse一起使用时,它们不接受RFC允许的所有时间格式. RFC3339Nano格式从秒字段中删除了结尾的零,因此一旦格式化就可能无法正确排序.

const (
    ANSIC       = "Mon Jan _2 15:04:05 2006"
    UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
    RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
    RFC822      = "02 Jan 06 15:04 MST"
    RFC822Z     = "02 Jan 06 15:04 -0700" // RFC822 with numeric zone
    RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
    RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
    RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" // RFC1123 with numeric zone
    RFC3339     = "2006-01-02T15:04:05Z07:00"
    RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
    Kitchen     = "3:04PM"
    // Handy time stamps.
    Stamp      = "Jan _2 15:04:05"
    StampMilli = "Jan _2 15:04:05.000"
    StampMicro = "Jan _2 15:04:05.000000"
    StampNano  = "Jan _2 15:04:05.000000000"
)

常见的持续时间. 对于天数或更大的单位,没有定义以避免在夏时制时区转换过程中产生混淆.

To count the number of units in a Duration, divide:

second := time.Second
fmt.Print(int64(second/time.Millisecond)) // prints 1000

要将整数单位转换为持续时间,请乘以:

seconds := 10
fmt.Print(time.Duration(seconds)*time.Second) // prints 10s
const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)

func After

func After(d Duration) <-chan Time

After等待持续时间过去,然后在返回的通道上发送当前时间. 它等效于NewTimer(d).C. 在计时器触发之前,底层的计时器不会由垃圾收集器恢复. 如果需要提高效率,请改用NewTimer,如果不再需要计时器,则调用Timer.Stop.

Example

func Sleep

func Sleep(d Duration)

睡眠至少在持续时间d内暂停当前goroutine. 持续时间为负数或零会导致休眠立即返回.

Example

func Tick

func Tick(d Duration) <-chan Time

Tick是NewTicker的便捷包装,仅提供对滴答通道的访问. 虽然Tick对于不需要关闭Ticker的客户端很有用,但是请注意,没有办法关闭它,底层的Ticker不能被垃圾收集器恢复; 它"泄漏". 与NewTicker不同,如果d <= 0,则Tick将返回nil.

Example

type Duration

持续时间表示两个瞬间之间经过的时间,以int64纳秒计数. 该表示将最大可表示持续时间限制为大约290年.

type Duration int64

Example

func ParseDuration

func ParseDuration(s string) (Duration, error)

ParseDuration解析持续时间字符串. 持续时间字符串是可能带符号的十进制数字序列,每个序列都有可选的分数和一个单位后缀,例如" 300ms","-1.5h"或" 2h45m". 有效时间单位为" ns"," us"(或" µs")," ms"," s"," m"," h".

Example

10h0m0s
1h10m10s
There are 4210 seconds in 1h10m10s.
There are 1000 nanoseconds in 1µs.
There are 1.00e-06 seconds in 1µs.

func Since

func Since(t Time) Duration

从返回t以来经过的时间. 它是time.Now().Sub(t)的简写.

func Until 1.8

func Until(t Time) Duration

直到返回t之前的持续时间. 它是t.Sub(time.Now())的简写.

func (Duration) Hours

func (d Duration) Hours() float64

Hours将持续时间返回为小时的浮点数.

Example

I've got 4.5 hours of work left.

func (Duration) Microseconds 1.13

func (d Duration) Microseconds() int64

微秒以整数微秒计数返回持续时间.

Example

One second is 1000000 microseconds.

func (Duration) Milliseconds 1.13

func (d Duration) Milliseconds() int64

毫秒返回持续时间,以整数毫秒计数.

Example

One second is 1000 milliseconds.

func (Duration) Minutes

func (d Duration) Minutes() float64

"分钟"返回持续时间,以分钟为单位的浮点数.

Example

The movie is 90 minutes long.

func (Duration) Nanoseconds

func (d Duration) Nanoseconds() int64

纳秒返回持续时间,以整数纳秒计数.

Example

One microsecond is 1000 nanoseconds.

func (Duration) Round 1.9

func (d Duration) Round(m Duration) Duration

舍入运算将d舍入到m的最接近倍数的结果. 中途值的舍入行为是从零舍入. 如果结果超过可以在"持续时间"中存储的最大(或最小)值,则"回合"返回最大(或最小)持续时间. 如果m <= 0,则Round返回d不变.

Example

d.Round(   1ns) = 1h15m30.918273645s
d.Round(   1µs) = 1h15m30.918274s
d.Round(   1ms) = 1h15m30.918s
d.Round(    1s) = 1h15m31s
d.Round(    2s) = 1h15m30s
d.Round(  1m0s) = 1h16m0s
d.Round( 10m0s) = 1h20m0s
d.Round(1h0m0s) = 1h0m0s

func (Duration) Seconds

func (d Duration) Seconds() float64

秒数返回持续时间,以秒为单位的浮点数.

Example

Take off in t-90 seconds.

func (Duration) String

func (d Duration) String() string

String返回以" 72h3m0.5s"形式表示持续时间的字符串. 前导零单位被省略. 作为一种特殊情况,持续时间少于一秒的格式使用较小的单位(毫秒,微秒或纳秒),以确保前导数字不为零. 零持续时间格式为0s.

Example

4440h0m0s

func (Duration) Truncate 1.9

func (d Duration) Truncate(m Duration) Duration

截断返回将d朝零舍入到m的倍数的结果. 如果m <= 0,则Truncate不变地返回d.

Example

d.Truncate(   1ns) = 1h15m30.918273645s
d.Truncate(   1µs) = 1h15m30.918273s
d.Truncate(   1ms) = 1h15m30.918s
d.Truncate(    1s) = 1h15m30s
d.Truncate(    2s) = 1h15m30s
d.Truncate(  1m0s) = 1h15m0s
d.Truncate( 10m0s) = 1h10m0s
d.Truncate(1h0m0s) = 1h0m0s

type Location

位置会将时刻映射到当时正在使用的区域. 通常,位置表示在某个地理区域中使用的时间偏移量的集合. 对于许多位置,时间偏移量会根据当时是否使用夏令时而有所不同.

type Location struct {
    // contains filtered or unexported fields
}

Local表示系统的本地时区. 在Unix系统上,Local会查询TZ环境变量以找到要使用的时区. 没有TZ表示使用系统默认的/ etc / localtime. TZ =""表示使用UTC. TZ =" foo"表示在系统时区目录中使用文件foo.

var Local *Location = &localLoc

UTC表示世界标准时间(UTC).

var UTC *Location = &utcLoc

Example

true

func FixedZone

func FixedZone(name string, offset int) *Location

FixedZone返回一个位置,该位置始终使用给定的区域名称和偏移量(UTC以东的秒数).

Example

The time is: 10 Nov 09 23:00 UTC-8

func LoadLocation

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

LoadLocation返回具有给定名称的Location.

如果名称是""或" UTC",则LoadLocation返回UTC. 如果名称为" Local",则LoadLocation返回Local.

否则,该名称将被视为与IANA时区数据库中的文件相对应的位置名称,例如" America / New_York".

LoadLocation所需的时区数据库可能并非在所有系统上都存在,尤其是在非Unix系统上. LoadLocation查找由ZONEINFO环境变量命名的目录或未压缩的zip文件(如果有),然后查找Unix系统上的已知安装位置,最后查找$ GOROOT / lib / time / zoneinfo.zip.

Example

2018-08-30 05:00:00 -0700 PDT

func LoadLocationFromTZData 1.10

func LoadLocationFromTZData(name string, data []byte) (*Location, error)

LoadLocationFromTZData返回一个具有给定名称的位置,该位置是从IANA时区数据库格式的数据中初始化的. 数据应采用标准IANA时区文件的格式(例如,Unix系统上/ etc / localtime的内容).

func (*Location) String

func (l *Location) String() string

String返回时区信息的描述性名称,对应于LoadLocation或FixedZone的名称参数.

type Month

一个月指定一年中的一个月(一月= 1,...).

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

Example

func (Month) String

func (m Month) String() string

String返回月份的英文名称(" January"," February",...).

type ParseError

ParseError描述了解析时间字符串的问题.

type ParseError struct {
    Layout     string
    Value      string
    LayoutElem string
    ValueElem  string
    Message    string
}

func (*ParseError) Error

func (e *ParseError) Error() string

Error返回ParseError的字符串表示形式.

type Ticker

一个股票代号持有一个通道,该通道每隔一段时间便发出一个时钟信号.

type Ticker struct {
    C <-chan Time // The channel on which the ticks are delivered.
    // contains filtered or unexported fields
}

func NewTicker

func NewTicker(d Duration) *Ticker

NewTicker返回一个新的Ticker,其中包含一个通道,该通道将发送时间,该时间由duration参数指定. 它调整间隔或滴答滴答声以弥补接收速度慢的问题. 持续时间d必须大于零; 如果没有,NewTicker将惊慌. 停止行情自动收录器以释放关联的资源.

Example

func (*Ticker) Stop

func (t *Ticker) Stop()

停止将关闭置顶栏. 停止后,将不再发送任何报价. 停止并不会关闭通道,以防止同时从通道读取goroutine时看到错误的"滴答声".

type Time

时间代表具有纳秒精度的时间瞬间.

使用时间的程序通常应将其存储并作为值(而不是指针)传递. 也就是说,时间变量和结构字段的类型应该是time.Time,而不是* time.Time.

除了GobDecode,UnmarshalBinary,UnmarshalJSON和UnmarshalText方法不是并发安全的方法外,多个goroutine可以同时使用Time值.

可以使用Before,After和Equal方法比较时刻. Sub方法减去两个瞬间,产生持续时间. Add方法添加一个时间和一个持续时间,产生一个时间.

时间类型的零值为1年1月1日,00:00:00.000000000 UTC. 由于实际上不太可能出现此时间,因此IsZero方法提供了一种检测未明确初始化的时间的简单方法.

Each Time has associated with it a Location, consulted when computing the presentation form of the time, such as in the Format, Hour, and Year methods. The methods Local, UTC, and In return a Time with a specific location. Changing the location in this way changes only the presentation; it does not change the instant in time being denoted and therefore does not affect the computations described in earlier paragraphs.

GobEncode,MarshalBinary,MarshalJSON和MarshalText方法保存的Time值的表示形式存储Time.Location的偏移量,但不存储位置名称. 因此,他们会丢失有关夏令时的信息.

除了所需的"挂钟"读数外,"时间"还可以包含当前过程单调时钟的可选读数,以提供更高的比较或减法精度. 有关详细信息,请参见包装文档中的"单声道时钟"部分.

请注意,Go ==运算符不仅会比较即时时间,还会比较"位置"和单调时钟读数. 因此,在不首先确保已为所有值设置相同的"位置"的情况下,不应将"时间"值用作地图或数据库键,这可以通过使用UTC或"本地"方法来实现,并且单调时钟读数已被设置t = t.Round(0). 通常,首选t.Equal(u)而不是t == u,因为t.Equal使用可用的最精确比较,并且仅当其参数之一具有单调时钟读数时才能正确处理这种情况.

type Time struct {
    // contains filtered or unexported fields
}

func Date

func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time

日期返回对应的时间

yyyy-mm-dd hh:mm:ss + nsec nanoseconds

在给定位置在该时间段的适当区域内.

月,日,小时,分钟,秒和nsec值可能超出其通常范围,并且将在转换过程中进行标准化. 例如,10月32日转换为11月1日.

夏令时过渡会跳过或重复时间. 例如,在美国,从未发生过2011年3月13日凌晨2:15,而2011年11月6日凌晨1:15发生了两次. 在这种情况下,时区的选择以及时间的选择都不明确. 日期返回的时间在过渡涉及的两个区域之一中是正确的,但不能保证是正确的.

如果loc为零,则日期出现紧急情况.

Example

Go launched at 2009-11-10 15:00:00 -0800 PST

func Now

func Now() Time

现在返回当前本地时间.

func Parse

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

解析解析一个格式化的字符串,并返回它表示的时间值. 该布局通过显示参考时间(定义为

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

如果它是值,将被解释; 它用作输入格式的示例. 然后将对输入字符串进行相同的解释.

预定义的布局ANSIC,UnixDate,RFC3339和其他布局描述了参考时间的标准和便捷表示形式. 有关格式和参考时间的定义的更多信息,请参见ANSIC文档以及此程序包定义的其他常量. 另外,Time.Format的可执行示例详细说明了布局字符串的工作原理,是一个很好的参考.

从值中省略的元素假定为零,或者当不可能为零时为1,因此解析" 3:04 pm"将返回与世界标准时间1月1日,0、15:04:00对应的时间(请注意,因为年份为0,此时间早于零时间). 年份必须在0000..9999的范围内. 将检查星期几的语法,否则将忽略该语法.

对于指定两位数字的年份06的布局,将值NN> = 69视为19NN,将值NN <69视为20NN.

在没有时区指示符的情况下,Parse以UTC返回时间.

解析时间偏移为-0700的时间时,如果偏移对应于当前位置(本地)使用的时区,则Parse在返回的时间中使用该位置和时区. 否则,它将时间记录为处于伪造位置,时间固定在给定的区域偏移处.

解析带有MST之类的区域缩写的时间时,如果区域缩写在当前位置具有已定义的偏移,则使用该偏移. 区域缩写" UTC"被识别为UTC,与位置无关. 如果区域缩写未知,则Parse将时间记录在具有给定区域缩写和零偏移的虚构位置中. 此选择意味着可以使用相同的布局无损地解析和重新格式化这样的时间,但是表示中使用的确切瞬间将因实际区域偏移而有所不同. 为避免此类问题,请首选使用数字区域偏移量的时间布局或使用ParseInLocation.

Example

2013-02-03 19:54:00 -0800 PST
2013-02-03 00:00:00 +0000 UTC
2006-01-02 15:04:05 +0000 UTC
2006-01-02 15:04:05 +0700 +0700
error parsing time "2006-01-02T15:04:05Z07:00": extra text: 07:00

func ParseInLocation 1.1

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

ParseInLocation类似于Parse,但在两个重要方面有所不同. 首先,在没有时区信息的情况下,Parse将时间解释为UTC. ParseInLocation将时间解释为给定位置. 其次,当给定区域偏移量或缩写时,Parse尝试将其与本地位置进行匹配. ParseInLocation使用给定的位置.

Example

2012-07-09 05:02:00 +0200 CEST
2012-07-09 00:00:00 +0200 CEST

func Unix

func Unix(sec int64, nsec int64) Time

从1970年1月1日UTC开始,Unix返回与给定的Unix时间,秒秒和nsec纳秒相对应的本地时间. 通过nsec超出[0,999999999]范围是有效的. 并非所有秒值都有相应的时间值. 这样的值之一就是1 << 63-1(最大的int64值).

func (Time) Add

func (t Time) Add(d Duration) Time

加法返回时间t + d.

Example

start = 2009-01-01 12:00:00 +0000 UTC
start.Add(time.Second * 10) = 2009-01-01 12:00:10 +0000 UTC
start.Add(time.Minute * 10) = 2009-01-01 12:10:00 +0000 UTC
start.Add(time.Hour * 10) = 2009-01-01 22:00:00 +0000 UTC
start.Add(time.Hour * 24 * 10) = 2009-01-11 12:00:00 +0000 UTC

func (Time) AddDate

func (t Time) AddDate(years int, months int, days int) Time

AddDate返回与将给定的年,月和天数添加到t对应的时间. 例如,应用于2011年1月1日的AddDate(-1,2,3)返回2010年3月4日.

AddDate以与Date相同的方式对其结果进行规范化,例如,向10月31日添加一个月将产生12月1日,即11月31日的规范化形式.

Example

oneDayLater: start.AddDate(0, 0, 1) = 2009-01-02 00:00:00 +0000 UTC
oneMonthLater: start.AddDate(0, 1, 0) = 2009-02-01 00:00:00 +0000 UTC
oneYearLater: start.AddDate(1, 0, 0) = 2010-01-01 00:00:00 +0000 UTC

func (Time) After

func (t Time) After(u Time) bool

After报告时刻t是否在u之后.

Example

year3000.After(year2000) = true
year2000.After(year3000) = false

func (Time) AppendFormat 1.5

func (t Time) AppendFormat(b []byte, layout string) []byte

AppendFormat类似于Format,但将文本表示形式附加到b并返回扩展的缓冲区.

Example

Time: 11:00AM

func (Time) Before

func (t Time) Before(u Time) bool

之前报告时间t是否早于u.

Example

year2000.Before(year3000) = true
year3000.Before(year2000) = false

func (Time) Clock

func (t Time) Clock() (hour, min, sec int)

时钟返回t指定的日期内的小时,分​​钟和秒.

func (Time) Date

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

日期返回发生t的年,月和日.

Example

year = 2000
month = February
day = 1

func (Time) Day

func (t Time) Day() int

Day返回t指定的月份中的日期.

Example

day = 1

func (Time) Equal

func (t Time) Equal(u Time) bool

相等报告t和u是否代表同一时刻. 即使它们位于不同的位置,两次也可以相等. 例如,6:00 +0200和4:00 UTC相等. 有关在时间值上使用==的陷阱,请参见时间类型的文档. 大多数代码应改用Equal.

Example

datesEqualUsingEqualOperator = false
datesEqualUsingFunction = true

func (Time) Format

func (t Time) Format(layout string) string

Format返回根据布局格式化的时间值的文本表示形式,它通过显示参考时间(定义为

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

如果是该值将显示; 它作为所需输出的示例. 然后,将相同的显示规则应用于时间值.

通过在布局字符串的秒部分的末尾添加句点和零来表示小数秒,如" 15:04:05.000"中所示,以毫秒级精度格式化时间戳.

预定义的布局ANSIC,UnixDate,RFC3339和其他布局描述了参考时间的标准和便捷表示形式. 有关格式和参考时间的定义的更多信息,请参见ANSIC文档以及此程序包定义的其他常量.

Example

default format: 2015-03-07 11:06:39 -0800 PST
Unix format: Sat Mar  7 11:06:39 PST 2015
Same, in UTC: Sat Mar  7 19:06:39 UTC 2015

Formats:

Basic           "Mon Jan 2 15:04:05 MST 2006" gives "Sat Mar 7 11:06:39 PST 2015"
No pad          "<2>" gives "<7>"
Spaces          "<_2>" gives "< 7>"
Zeros           "<02>" gives "<07>"
Suppressed pad  "04:05" gives "06:39"
Unix            "Mon Jan _2 15:04:05 MST 2006" gives "Sat Mar  7 11:06:39 PST 2015"
AM/PM           "3PM==3pm==15h" gives "11AM==11am==11h"
No fraction     "Mon Jan _2 15:04:05 MST 2006" gives "Sat Mar  7 11:06:39 PST 2015"
0s for fraction "15:04:05.00000" gives "11:06:39.12340"
9s for fraction "15:04:05.99999999" gives "11:06:39.1234"

func (*Time) GobDecode

func (t *Time) GobDecode(data []byte) error

GobDecode实现gob.GobDecoder接口.

func (Time) GobEncode

func (t Time) GobEncode() ([]byte, error)

GobEncode实现gob.GobEncoder接口.

func (Time) Hour

func (t Time) Hour() int

Hour返回由t指定的一天中的小时,范围为[0,23].

func (Time) ISOWeek

func (t Time) ISOWeek() (year, week int)

ISOWeek返回发生t的ISO 8601年和周号. 周的范围是1到53.n年的1月1日到1月03日可能属于n-1年的52周或53周,12月29日到12月31日可能属于n + 1年的第1周.

func (Time) In

func (t Time) In(loc *Location) Time

In返回代表同一时刻的t副本,但副本的位置信息设置为loc以便显示.

如果loc为零,则处于恐慌状态.

func (Time) IsZero

func (t Time) IsZero() bool

IsZero报告t是否代表1年1月1日UTC 00:00:00 UTC的零时间点.

func (Time) Local

func (t Time) Local() Time

本地返回t,并且位置设置为本地时间.

func (Time) Location

func (t Time) Location() *Location

位置返回与t关联的时区信息.

func (Time) MarshalBinary 1.2

func (t Time) MarshalBinary() ([]byte, error)

MarshalBinary实现了encoding.BinaryMarshaler接口.

func (Time) MarshalJSON

func (t Time) MarshalJSON() ([]byte, error)

MarshalJSON实现json.Marshaler接口. 时间是RFC 3339格式的带引号的字符串,如果存在,则添加亚秒精度.

func (Time) MarshalText 1.2

func (t Time) MarshalText() ([]byte, error)

MarshalText实现encoding.TextMarshaler接口. 时间以RFC 3339格式格式化,如果存在,则添加亚秒精度.

func (Time) Minute

func (t Time) Minute() int

Minute返回t所指定的小时内的分钟偏移量,范围为[0,59].

func (Time) Month

func (t Time) Month() Month

月返回由t指定的一年中的月份.

func (Time) Nanosecond

func (t Time) Nanosecond() int

纳秒级返回t指定的秒内的纳秒级偏移,范围为[0,999999999].

func (Time) Round 1.1

func (t Time) Round(d Duration) Time

舍入将舍入t的结果舍入到d的最接近倍数(因为零时间). 中途值的舍入行为是向上舍入. 如果d <= 0,则Round返回t,去除了任何单调时钟读数,但未更改.

回合以从零时间开始的绝对持续时间为准; 它不能按时间的显示形式进行操作. 因此,Round(Hour)可能会返回一个非零分钟的时间,具体取决于该时间的位置.

Example

t.Round(   1ns) = 12:15:30.918273645
t.Round(   1µs) = 12:15:30.918274
t.Round(   1ms) = 12:15:30.918
t.Round(    1s) = 12:15:31
t.Round(    2s) = 12:15:30
t.Round(  1m0s) = 12:16:00
t.Round( 10m0s) = 12:20:00
t.Round(1h0m0s) = 12:00:00

func (Time) Second

func (t Time) Second() int

Second返回t所指定的分钟内的第二个偏移量,范围[0,59].

func (Time) String

func (t Time) String() string

字符串返回使用格式字符串格式化的时间

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

如果时间具有单调时钟读数,则返回的字符串包括最后一个字段" m =±<value>",其中value是格式为十进制秒数的单调时钟读数.

返回的字符串用于调试; 为了获得稳定的序列化表示形式,请使用带有显式格式字符串的t.MarshalText,t.MarshalBinary或t.Format.

Example

withNanoseconds = 2000-02-01 12:13:14.000000015 +0000 UTC
withoutNanoseconds = 2000-02-01 12:13:14 +0000 UTC

func (Time) Sub

func (t Time) Sub(u Time) Duration

Sub返回持续时间tu. 如果结果超过可以在"持续时间"中存储的最大(或最小)值,则将返回最大(或最小)持续时间. 要计算持续时间d的td,请使用t.Add(-d).

Example

difference = 12h0m0s

func (Time) Truncate 1.1

func (t Time) Truncate(d Duration) Time

Truncate返回将t向下舍入为d的倍数的结果(因为零时间). 如果d <= 0,则Truncate返回t,去除了任何单调时钟读数,但未更改.

截断以自零时间开始的绝对持续时间为准. 它不能按时间的显示形式进行操作. 因此,取决于时间的位置,Truncate(Hour)可能会返回一个非零分钟的时间.

Example

t.Truncate(  1ns) = 12:15:30.918273645
t.Truncate(  1µs) = 12:15:30.918273
t.Truncate(  1ms) = 12:15:30.918
t.Truncate(   1s) = 12:15:30
t.Truncate(   2s) = 12:15:30
t.Truncate( 1m0s) = 12:15:00
t.Truncate(10m0s) = 12:10:00

func (Time) UTC

func (t Time) UTC() Time

UTC返回t,并将位置设置为UTC.

func (Time) Unix

func (t Time) Unix() int64

Unix返回t作为Unix时间,即自UTC 1970年1月1日起经过的秒数. 结果不取决于与t关联的位置. 类似于Unix的操作系统通常将时间记录为32位秒数,但是由于此处的方法返回的是64位值,因此它在过去或将来的数十亿年内都有效.

Example

2001-09-09 01:46:40 +0000 UTC
2001-09-09 01:46:40 +0000 UTC
2001-09-09 01:46:40 +0000 UTC
1000000000
1000000000000000000

func (Time) UnixNano

func (t Time) UnixNano() int64

UnixNano返回t作为Unix时间,这是自1970年1月1日UTC以来经过的纳秒数. 如果Unix时间(以纳秒为单位)不能用int64(日期在1678年之前或2262年之后)表示,则结果是不确定的. 注意,这意味着在零时间调用UnixNano的结果是不确定的. 结果不取决于与t关联的位置.

func (*Time) UnmarshalBinary 1.2

func (t *Time) UnmarshalBinary(data []byte) error

UnmarshalBinary实现encoding.BinaryUnmarshaler接口.

func (*Time) UnmarshalJSON

func (t *Time) UnmarshalJSON(data []byte) error

UnmarshalJSON实现json.Unmarshaler接口. 该时间应为RFC 3339格式的带引号的字符串.

func (*Time) UnmarshalText 1.2

func (t *Time) UnmarshalText(data []byte) error

UnmarshalText实现encoding.TextUnmarshaler接口. 该时间预计为RFC 3339格式.

func (Time) Weekday

func (t Time) Weekday() Weekday

工作日返回由t指定的星期几.

func (Time) Year

func (t Time) Year() int

Year返回发生t的年份.

func (Time) YearDay 1.1

func (t Time) YearDay() int

YearDay返回由t指定的一年中的日期,非ap年的范围为[1,365],in年的范围为[1,366].

func (Time) Zone

func (t Time) Zone() (name string, offset int)

区域会计算在时间t生效的时区,并返回该区域的缩写名称(例如" CET")及其在UTC以东的秒数内的偏移量.

type Timer

Timer类型代表一个事件. 当计时器到期时,当前时间将在C上发送,除非计时器是由AfterFunc创建的. 必须使用NewTimer或AfterFunc创建一个计时器.

type Timer struct {
    C <-chan Time
    // contains filtered or unexported fields
}

func AfterFunc

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

AfterFunc等待持续时间过去,然后在其自己的goroutine中调用f. 它返回一个计时器,该计时器可使用其Stop方法取消通话.

func NewTimer

func NewTimer(d Duration) *Timer

NewTimer创建一个新的Timer,它将至少在持续时间d之后在其通道上发送当前时间.

func (*Timer) Reset 1.1

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

重置将计时器更改为在持续时间d之后过期. 如果计时器处于活动状态,则返回true;如果计时器已过期或已停止,则返回false.

只能在通道耗尽的停止或到期计时器上调用复位. 如果程序已经从tC接收到一个值,则说明计时器已到期且通道已耗尽,因此可以直接使用t.Reset. 但是,如果程序尚未从tC接收值,则必须停止计时器,并且-如果Stop报告计时器在停止之前已到期,则该通道将被清空:

if !t.Stop() {
	<-t.C
}
t.Reset(d)

不应与定时器通道的其他接收同时进行.

请注意,由于在耗尽通道和新计时器到期之间存在竞争条件,因此无法正确使用Reset的返回值. 如上所述,应始终在停止或过期的通道上调用复位. 返回值的存在是为了保持与现有程序的兼容性.

func (*Timer) Stop

func (t *Timer) Stop() bool

停止可防止定时器触发. 如果调用停止计时器,则返回true;如果计时器已过期或已停止,则返回false. 停止不会关闭通道,以防止从通道读取错误.

为确保在调用Stop后通道为空,请检查返回值并清空通道. 例如,假设尚未从tC收到程序:

if !t.Stop() {
	<-t.C
}

不能与计时器通道的其他接收或计时器的Stop方法的其他调用同时进行.

对于使用AfterFunc(d,f)创建的计时器,如果t.Stop返回false,则说明该计时器已经到期,并且函数f已在其自己的goroutine中启动; 停止不等待f完成后再返回. 如果呼叫者需要知道f是否完成,则它必须与f明确协调.

type Weekday

一个工作日指定一周中的一天(星期日= 0,...).

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

func (Weekday) String

func (d Weekday) String() string

String返回当天的英文名称(" Sunday"," Monday",...).

by  ICOPY.SITE