golang-时间和日期

golang中的时间模块，是由time包来完成实现的

time.Time 类型，用来表示时间

获取当前时间 now := time.Now()

简单示例

表示年月日，时分秒，并且格式化输出，休眠

	now := time.Now()
	year := now.Year()
	month := now.Month()
	day := now.Day()
	hour := now.Hour()
	minute := now.Minute()
	second := now.Second()
	fmt.Printf("now is %v,day is %v,minute is %v,month is %v,year is %v\n", now, day, minute, month, year)
	fmt.Printf("formart out: %02d-%02d-%02d  %02d:%02d:%02d\n", year, month, day, hour, minute, second)
	//结果：now is 2020-10-13 11:09:10.1265396 +0800 CST m=+0.005983801,day is 13,minute is 9,month is October,year is 2020
	//格式化输出：     formart out: 2020-10-13  11:10:20
    // 休眠1秒
    // time.Millisecond    表示1毫秒
    // time.Microsecond    表示1微妙
    // time.Nanosecond    表示1纳秒
    time.Sleep(1 * time.Second)
    // 休眠100毫秒
    time.Sleep(100 * time.Millisecond)

时间长度

时间常量

type Duration int64

const (
	Nanosecond  Duration = 1
	Microsecond          = 1000 * Nanosecond
	Millisecond          = 1000 * Microsecond
	Second               = 1000 * Millisecond
	Minute               = 60 * Second
	Hour                 = 60 * Minute
)
//时间加减
//time.ParseDuration(s string) (Duration, error)  传入时间的信息，返回一个时间结果和error
// 减去7分钟
m, _ := time.ParseDuration("-7m")
// 加上10秒
s, _ := time.ParseDuration("10s")
fmt.Println(m, s)
/*
-7m0s 10s
*/

• time.Duration表示时间长度
  • 以纳秒为基数
  • 底层数据类型为int64
• int64 类型的变量不能直接和time.Duration类型相乘，需要显示转换，常量除外
  • 不行：num * time.Second
  • 可以： time.Duration(num) * time.Second
  • 可以： 5 * time.Second

获取当前时间戳

方法：time.Now().Unix()

func timetotamp(timetamp int64) {
	timeObj := time.Unix(timetamp, 0) //使用时间戳来获取年月日的数据
	year := timeObj.Year()
	month := timeObj.Month()
	day := timeObj.Day()
	hour := timeObj.Hour()
	minute := timeObj.Minute()
	second := timeObj.Second()
	fmt.Printf("%02d-%02d-%02d  %02d:%02d:%02d\n", year, month, day, hour, minute, second)
	fmt.Printf("时间戳是：%d\n", timetamp)
}

func main() {
	timetamp := time.Now().Unix()
	timetotamp(timetamp)
}
/* 结果：
2020-10-13  11:14:17
时间戳是：1602558857
*/

time的格式化

方法：time.Now().Format()

	now := time.Now()
	fmt.Println(now.Format("02/1/2006 15:04"))
	fmt.Println(now.Format("2006/1/02 15:04"))
	fmt.Println(now.Format("2006/1/02"))
/* 
使用time的format函数，进行格式化输出，这里format函数传入的参数时间是固定的，格式可以改变，此时间为golang语言诞生时间
结果：
13/10/2020 11:16
2020/10/13 11:16
2020/10/13
*/

将字符串时间，转换为时间格式

方法：time.Parse()，返回转换后的时间格式和一个判断信息（err)

	now := "2020-10-11"
	tm1, err := time.Parse("2006-01-02", now)
	fmt.Printf("%T\n", tm1)
	fmt.Printf("%s\n", tm1)
	/*
	time.Time
	2020-10-11 00:00:00 +0000 UTC
	*/

获取前一天或者后一天时间

	//当前时间的前一天时间
	d1 := time.Now().Add(-24 * time.Hour).Format("2006-01-02 15:04:05")
	//当前时间的前一年的后两个的前三天
	d2 := time.Now().AddDate(-1, 2, -3).Format("2006-01-02 15:04:05")
	fmt.Printf("d1 = %v ; d2 = %v\n", d1, d2)
	/* 
	d1 = 2020-10-12 11:36:57 ; d2 = 2019-12-10 11:36:57
	*/

定时器的使用

time.Tick

使用time.Tick()方法来实现

简单示例：

ticker := time.Tick(time.Second * 10)
for i := range ticker {
fmt.Printf("%v\n", i)
    //在这个定时器中，可以执行相关的定时任务
}

注意：

• time.Tick 是对time.NewTicker的简化
• 不要在for循环内设置Tick，这样会造成CPU暴涨
  • 例如： for i := range time.Tick(time.Second * 10) 不可取
  • 这样会导致每次循环都创建一个计时器，即每次循环的时候都会创建一个管道
  • 应该定义在循环前
• time.Tick 仅仅应用在整个生命周期都需要时，才合适
  • 否则应该使用time.NewTicker 并手动停止
  • time.Tick函数的行为很像创建一个计时器（goroutine）在循环里面调用 定时的任务 ，然后在它每次循环是发送事件
    • 如果停止监听，但是计时器还在运行，徒劳的向一个没有计时器的管道中发送任务
    • 这样会导致计时器泄露

time.NewTicker

自定义一个tick，同样不能使用在for循环 内，这个需要手动的关闭计时器

ticker := time.NewTicker(time.Second * 2)
defer ticker.Stop()
for range ticker.C {
fmt.Println("hello world")
}