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

Mon Jan 2 15:04:05 MST 2006

这是Unix time 1136239445,因为MST是GMT-0700,参考时间能够被认为是:

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

-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

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"
)

常见的持续时间,对于天或者更大的单位没有定义,避免在夏令时造成歧义.为了计数Duration单元,使用除法:

second := time.Second
fmt.Println(int64(second / time.Millisecond)) // print 1000

为了转换一个整数单元到Duration,使用乘法:

seconds := 10
fmt.Println(time.Duration(seconds) * time.Second) // print 10s

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

func After(d Duration) <-chan Time

func Sleep(d Duration)

time.Sleep(100 * time.Millisecond)

func Tick(d Duration) <- chan Time

type Duration int64

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

package main

import (
	"time"
	"fmt"
)

func main() {
	start, err := time.ParseDuration("7h20m3s")
	if err != nil {
		fmt.Println(err)
		return
	}
	end, err := time.ParseDuration("8h3m20s")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(start)
	fmt.Println(end)
	fmt.Println(end - start)
	fmt.Printf("hours in start: %f, end: %f\n", start.Hours(), end.Hours())
	fmt.Printf("minutes in start: %f, end: %f\n", start.Minutes(), end.Minutes())
	fmt.Printf("seconds in start: %f, end: %f\n", start.Seconds(), end.Seconds())
	fmt.Printf("milliseconds in start: %d, end: %d\n", start.Milliseconds(), end.Milliseconds())
	fmt.Printf("microseconds in start: %d, end: %d\n", start.Microseconds(), end.Microseconds())
	fmt.Printf("nanoseconds in start: %d, end: %d\n", start.Nanoseconds(), end.Nanoseconds())
}

package main
import (
	"time"
	"fmt"
)

func main() {
	d, err := time.ParseDuration("1h15m30.918273645s")
	if err != nil {
		fmt.Println(err)
		return
	}
	rounds := []time.Duration {
		time.Nanosecond,
		time.Microsecond,
		time.Millisecond,
		time.Second,
		2 * time.Second,
		3 * time.Second,
		time.Minute,
		10 * time.Minute,
		time.Hour,
	}
	for _, r := range rounds {
		round := d.Round(r)
		truncate := d.Truncate(r)
		fmt.Println(round)
		fmt.Println(truncate)
	}
}

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

Local表示系统的本地时区

var Local *Location = &localLoc

UTC表示世界协调时间(Universal Coordinated Time)

var UTC *Location = &utcLoc

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() strimg

type Month int

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

package main
import (
	"fmt"
	"time"
)

func main() {
	_, month, day := time.Now().Date()
	if month == time.October && day == 17 {
		fmt.Println("Happy day")
	}
}

func (m Month) String() string

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

func (e *ParseError) Error() string

type Ticker struct {
    C <-chan // ticks递送通道
    // contains filtered or unexported fields
}

func NewTicker(d Duration) *Ticker

func (t *Ticker) Stop()

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

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

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

func Now() Time

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

Mon Jan 2 15:04 -0700 MST 2006

将会被解释,如果它是value.它提供了输入格式的范例,同样的解释将会被应用于输入字符串. 预定义格式ANSIC, UnixDate, RFC3339和其他标准的格式和方便的表示参考时间 当value中元素被忽略时,假定其为0，当其不可能为0时,比如解析”3:04pm”返回时间对应于 Jan 1, year 0, 15:04:00 UTC(注意:year为0,时间先于Time的零值),Year必须是0000 … 9999的范围,星期几的语法是被检查的 缺少时间区域的指示,Parse返回时间使用UTC. 当解析携带zone offset 时间,比如 -0700,如果偏移对应于time zone通过当前位置(Local),Parse使用位置和偏移在返回的时间,否则,将会返回伪位置和其固定的位置偏移 如果解析时间携带区域缩写,比如MST,如果区域的缩写拥有定义的偏移在当前位置,然后该偏移使用.“UTC”的缩写会被视为UTC,无论位置,如果区域缩写是未知的,Parse记录时间作为伪时间和给定的区域缩写和偏移,这个选择意味着时间能够被解析和无损地格式化为同样的布局,但是精确的时刻表示可能区别于实际的区域偏移,为了避免这个问题,宁愿使用数字化的区域偏移或使用ParseLnLocation.

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

func Unix(sec, 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

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

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

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

如果时间存在monotonic clock读取,则返回的字符串包含最后的字段”m±”,表示秒的小数 该结果字符串是用于调试,对于稳定的序列化,使用t.MarshalText,t.MarshalBinary,或t.Format指定一个明确的字符串

func (t Time) Sub(u Time) Duration

func (t Time) Truncate(u 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) Year() int

func (t Time) YearDay() int

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

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

Timer呈现一个单独的事件,当Timer过期时,当前时间将会被发送到C,除非Timer是由AfterFunc创建的,一个Timer只能由NewTimer或AfterFunc创建

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

func NewTimer(d Duration) *Timer

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

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

func (t *Timer) Stop() bool

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

这个不能并发调用接收通道的值 对于AfterFunc(d, f)创建了定时器,如果t.Stop()返回false,定时器过时并且f在自己的goroutine中调用,在Stop返回之前不会等待f调用完成

type Weekday int

Weekday指示了一周的某天(Sunday 0, …)

const (
	Sunday Weekday = itoa
	Monday
	Tuesday
	Wednesday
	Thurday
	Friday
	Saturday
)

func (d Weekday) String() string

package main

import (
	"time"
	"fmt"
)

func main() {
	d, err := time.ParseDuration("50ms100us")
	if err != nil {
		fmt.Println(err)
		return
	}
	ticker := time.NewTicker(d)
	defer ticker.Stop()
	done := make(chan struct{})
	go func() {
		time.Sleep(2 * time.Second)
		done <- struct{}{}
	}()
	counter := 0
	for {
		select {
		case t := <- ticker.C:
			counter++
			fmt.Println(t)
		case <- done:
			fmt.Println("Done with counter: ", counter)
			return
		}
	}

Example

package main

import (
	"time"
	"fmt"
)

func main() {
	customLoc := time.FixedZone("customZone", 2 * 60 * 60)
	now := time.Now().In(time.UTC)
	customNow := now.In(customLoc)
	fmt.Println("Infact now: ", now)
	fmt.Println("Custom now: ", customNow)
}

Example

package main

import (
	"time"
	"fmt"
)

func main() {
	const longForm = "Jan 2, 2006 at 15:04:05pm (MST)"
	t, err := time.Parse(longForm, "Nov 1, 2019 at 22:37:58pm (PST)")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(t)
	const shortForm = "2006-Jan-2"
	t, err = time.Parse(shortForm, "2019-Nov-1")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(t)
	t, err = time.Parse(time.RFC3339, "2019-11-01T22:53:28+03:00")
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(t.In(time.UTC))
}