Go标准库_time包

打包时间提供测量和显示时间的功能。

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

time.Sleep()

/*
func Sleep(d Duration)
Sleep 会暂停当前的 goroutine，至少持续 d。 持续时间为负数或零会导致睡眠立即恢复。
*/
func main() {
	time.Sleep(1000000 * time.Microsecond)
	fmt.Println(1)
}

time.After()

/*
func After(d Duration) <-chan Time
After 等待持续时间过去，然后发送当前时间 在返回的频道上。
它等效于 NewTimer（d）.C。 垃圾回收器不会恢复基础计时器 直到计时器触发。
如果效率是一个问题，请使用 NewTimer 相反，如果不再需要计时器，则调用 Timer.Stop。
*/
func main() {
	ch := make(chan int)
	go func() {
		time.Sleep(5 * time.Second)
		ch <- 1
		close(ch)
	}()
	select {
	case v := <-ch:
		fmt.Println(v)
	case <-time.After(3 * time.Second):
		fmt.Println("超时")
	}
}

time.Tick()

/*
time.Tick时间周期
func Tick(d Duration) <-chan Time
Tick 是 NewTicker 的便利包装器，提供对滴答声的访问 仅限频道。
虽然 Tick 对于不需要关闭的客户端很有用 Ticker，请注意，如果没有办法关闭它，
底层 垃圾回收器无法恢复代码;它“泄漏”。 与 NewTicker 不同，如果 d <= 0，Tick 将返回 nil。
*/

func statusUpdate() string { return "" }

func main() {
	c := time.Tick(5 * time.Second)
	for next := range c {
		fmt.Printf("%v %s\n", next, statusUpdate())
	}
}

type Time

time.Date() 

/*
func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time
*/
func main() {
	//构造当地时间
	t1 := time.Date(2001, 3, 1, 15, 4, 6, 4, time.Local)
	fmt.Println(t1)

	//构造美国时间
	t2 := time.Date(2001, 3, 1, 15, 4, 6, 4, time.UTC)
	fmt.Println(t2)

	//转换成当地时间
	t2 = t2.Local()
	fmt.Println(t2)
}

time.Now() 

/*
func Now() Time
 */
func main() {
	//构造当前时间
	now := time.Now()
	fmt.Println(now)

}

time.Parse() 

/*
func Parse(layout, value string) (Time, error)
按照字符串转化time格式
*/
func main() {
	//构造美国时间
	t1, _ := time.Parse("2006-01-02 15:04:05", "0001-01-01 00:00:00")
	fmt.Println(t1)

	//构造本地时间
	t2, _ := time.ParseInLocation("2006-01-02", "2019-01-05", time.Local)
	fmt.Println(t2)

}

 t.Add()

/*
func (t Time) Add(d Duration) Time
const (
	Nanosecond  Duration = 1
	Microsecond          = 1000 * Nanosecond
	Millisecond          = 1000 * Microsecond
	Second               = 1000 * Millisecond
	Minute               = 60 * Second
	Hour                 = 60 * Minute
)
*/
func main() {

	now := time.Now()
	fmt.Println(now.Add(time.Hour*1 + time.Minute*1 + time.Second*1))
	fmt.Println(now.Add(-time.Hour*1 + -time.Minute*1 + -time.Second*1))

}

t.AddDate()

/*
func (t Time) AddDate(years int, months int, days int) Time
*/
func main() {
	now := time.Now()
	fmt.Println(now.AddDate(-1, -1, -1))
	fmt.Println(now.AddDate(+1, 1, 1))

}

t.Format()

/*
func (t Time) Format(layout string) string
*/
func main() {
	t1 := time.Now()
	///2023-04-12 14:11:25 格式化输出时间24小时制
	fmt.Println(t1.Format("2006-01-02 15:04:05"))

	//2023-04-12 02:11:25 格式化输出时间12小时制
	fmt.Println(t1.Format("2006-01-02 03:04:05"))

	//当地时间
	fmt.Println(t1.Local())
	//全球时间
	fmt.Println(t1.UTC())
	fmt.Println(t1.String())
	fmt.Println(t1.GoString())
	fmt.Println(t1.Year())
	fmt.Println(t1.Month())
	fmt.Println(t1.Day())
	fmt.Println(t1.Hour())
	fmt.Println(t1.Minute())
	fmt.Println(t1.Second())
	fmt.Println(t1.Weekday())
	fmt.Println(t1.YearDay())
	//时间戳
	fmt.Println(t1.Unix())
	fmt.Println(t1.UnixMilli())
	fmt.Println(t1.UnixMicro())
	//纳秒时间戳
	fmt.Println(t1.UnixNano())
	fmt.Println(t1.Nanosecond())
}

t.Before()

/*
时间比较
func (t Time) Before(u Time) bool  当前时间时候是否这个时间之前
func (t Time) After(u Time) bool   当前时间时候是否在这个时间之后
*/

func main() {
	now := time.Now()
	fmt.Println(now.Add(time.Hour).Before(time.Now()))
	fmt.Println(now.Add(time.Hour).After(time.Now()))

}

t.Equal ()

/*
func (t Time) Equal(u Time) bool
时间比较
*/
func main() {
	//now := time.Now()
	//fmt.Println(now.Equal(time.Now()))
	var t time.Time
	t.Add(1)
	if t.Equal(time.Time{}.Add(1)) {
		fmt.Println("相同")
	}
	fmt.Println(t)
	if (time.Time{}.Add(1)).Equal(time.Time{}.Add(1)) {
		fmt.Println("相同")

	}

}

t.Sub()

/*
func (t Time) Sub(u Time) Duration
减去传入时间的差距
*/
func main() {
	// 两个时间字符串
	timeStr1 := "2007-01-03 13:20:20"
	timeStr2 := "2007-01-03 14:20:20"

	// 定义日期时间格式
	timeFormat := "2006-01-02 15:04:05"

	// 将字符串转换为时间对象
	t1, err := time.Parse(timeFormat, timeStr1)
	if err != nil {
		fmt.Println("解析时间字符串1失败:", err)
		return
	}

	t2, err := time.Parse(timeFormat, timeStr2)
	if err != nil {
		fmt.Println("解析时间字符串2失败:", err)
		return
	}

	// 计算时间间隔
	duration := t1.Sub(t2)

	// 获取间隔分钟数
	minutes := duration.Minutes()

	fmt.Printf("时间间隔分数: %.0f 分钟\n", minutes)
}

t.AppendFormat()

/*
func (t Time) AppendFormat(b []byte, layout string) []byte
AppendFormat 类似于 Format，但附加了文本 表示为 B 并返回扩展缓冲区。
*/

func main() {
	t := time.Date(2017, time.November, 4, 11, 0, 0, 0, time.UTC)
	text := []byte("Time: ")

	text = t.AppendFormat(text, time.Kitchen)
	fmt.Println(string(text))

}

type Timer

type Timer struct {
	C <-chan Time
	r runtimeTimer
}

time.AfterFunc()

/*
func AfterFunc(d Duration, f func()) *Timer
等待多久时间执行函数
*/
func main() {
	fmt.Println("Start")
	// 在 2 秒后执行 myFunc 函数
	time.AfterFunc(time.Second*2, myFunc)

	// 主函数继续执行
	time.Sleep(time.Second * 3)
	fmt.Println("End")
}

func myFunc() {
	fmt.Println("AfterFunc called")
}

time.NewTimer()

/*
func NewTimer(d Duration) *Timer
*/

func main() {
	timer := time.NewTimer(time.Second * 2)

	go func() {
		<-timer.C
		fmt.Println("Timer expired")
	}()

	// 等待一段时间以确保 Timer 有足够的时间触发
	time.Sleep(time.Second * 3)

	// 停止 Timer，避免它继续触发
	timer.Stop()
}

t.Stop()

t.Reset()

type Ticker

type Ticker struct {
	C <-chan Time // The channel on which the ticks are delivered.
	r runtimeTimer
}

time.NewTicker()

/*
func NewTicker(d Duration) *Ticker
*/

func main() {
	ticker := time.NewTicker(time.Second)
	defer ticker.Stop()
	done := make(chan bool)
	
	go func() {
		time.Sleep(10 * time.Second)
		done <- true
	}()
	for {
		select {
		case <-done:
			fmt.Println("Done!")
			return
		case t := <-ticker.C:
			fmt.Println("Current time: ", t)
		}
	}
}

t.Stop() 

package main

/*
func (t *Ticker) Stop()
*/

func main() {

}

t.Reset()

/*
func (t *Ticker) Reset(d Duration)
“重置”会停止股票行情，并将其周期重置为指定的持续时间。 下一个即时报价将在新周期过后到来。持续时间 d 必须大于零;如果没有，重置将崩溃。
*/

func main() {

}

type Duration

type Location

type Month

m.string()

func main() {
	var m time.Month
	m = 2
	fmt.Println(m)
	fmt.Println(m.String())
}

type ParseError

e.Error()

/*
type ParseError struct {
   Layout     string
   Value      string
   LayoutElem string
   ValueElem  string
   Message    string
}
ParseError 描述解析时间字符串时出现的问题。
*/
func main() {
   e := time.ParseError{}
   fmt.Println(e.Error())

}

type Weekday 

w.string()

func main() {
	var w time.Weekday
	w = 2
	fmt.Println(w)
	fmt.Println(w.String())
}