日期与时间

now := time.Now()
fmt.Println(now) // 2021-06-17 13:29:40.801445 +0800 CST m=+0.001636524
fmt.Println(now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second()) // 2021 June 17 13 29 40

type Time struct {
	// wall and ext encode the wall time seconds, wall time nanoseconds,
	// and optional monotonic clock reading in nanoseconds.
	//
	// From high to low bit position, wall encodes a 1-bit flag (hasMonotonic),
	// a 33-bit seconds field, and a 30-bit wall time nanoseconds field.
	// The nanoseconds field is in the range [0, 999999999].
	// If the hasMonotonic bit is 0, then the 33-bit field must be zero
	// and the full signed 64-bit wall seconds since Jan 1 year 1 is stored in ext.
	// If the hasMonotonic bit is 1, then the 33-bit field holds a 33-bit
	// unsigned wall seconds since Jan 1 year 1885, and ext holds a
	// signed 64-bit monotonic clock reading, nanoseconds since process start.
	wall uint64
	ext  int64

	// loc specifies the Location that should be used to
	// determine the minute, hour, month, day, and year
	// that correspond to this Time.
	// The nil location means UTC.
	// All UTC times are represented with loc==nil, never loc==&utcLoc.
	loc *Location
}

d1, err := time.Parse("2006-01-02 15:04:05", "2021-06-18 12:12:12")
fmt.Println(d1, err)

ts := time.Now().Unix()
fmt.Println(ts)

ts := time.Now().Unix()
fmt.Println(ts)

fmt.Println(time.Unix(ts, 0))

d1, err := time.Parse("2006-01-02 15:04:05", "2021-06-18 12:12:12")
fmt.Println(d1, err)

now := time.Now()
fmt.Println(now.After(d1))
fmt.Println(now.Before(d1))
fmt.Println(now.Equal(d1))

// A Duration represents the elapsed time between two instants
// as an int64 nanosecond count. The representation limits the
// largest representable duration to approximately 290 years.
type Duration int64

const (
	minDuration Duration = -1 << 63
	maxDuration Duration = 1<<63 - 1
)

// Common durations. There is no definition for units of Day or larger
// to avoid confusion across daylight savings time zone transitions.
//
// To count the number of units in a Duration, divide:
//	second := time.Second
//	fmt.Print(int64(second/time.Millisecond)) // prints 1000
//
// To convert an integer number of units to a Duration, multiply:
//	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
)

now := time.Now()
after1 := now.Add(time.Hour * 24)
fmt.Println(after1)

now := time.Now()
after1 := now.Add(time.Hour * 24)
fmt.Println(now.Sub(after1))

stop := false
time.AfterFunc(5*time.Second, func() {
	stop = true
})

for {
	if stop {
		fmt.Println("exit")
		break
	}

	time.Sleep(1 * time.Second)
}

m := time.NewTimer(5 * time.Second)
fmt.Println(<-m.C)
fmt.Println("exit")

// The Timer type represents a single event.
// When the Timer expires, the current time will be sent on C,
// unless the Timer was created by AfterFunc.
// A Timer must be created with NewTimer or AfterFunc.
type Timer struct {
	C <-chan Time
	r runtimeTimer
}

tk := time.NewTicker(2 * time.Second)

count := 1
for {
	if count > 2 {
		tk.Stop()
		break
	}
	fmt.Println(<-tk.C)
	count++
}

// A Ticker holds a channel that delivers ``ticks'' of a clock
// at intervals.
type Ticker struct {
	C <-chan Time // The channel on which the ticks are delivered.
	r runtimeTimer
}