time包提供了时间显示和测量的函数。日历计算采用的是公历。

时间类型

time.Time类型表示时间。我们可以通过time.Now()函数获取当前时间的对象，然受获取时间对象的年月日时分秒等信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
//时间类型
func timeDemo(){
   now := time.Now()
   fmt.Printf("current time:%v\n", now)

   year := now.Year()     //年
   month := now.Month()   //月
   day := now.Day()       //日
   hour := now.Hour()     //时
   minute := now.Minute() //分
   second := now.Second() //秒
   fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}

时间戳

时间戳是自1970年1月1日(08:00:00GMT)至当前时间的在那个毫秒数。

获取时间戳

1
2
3
4
5
6
7
8
//时间戳
func timeStamp() {
   now := time.Now()
   unix := now.Unix()     //时间戳
   nano := now.UnixNano() //纳秒时间戳
   fmt.Printf("时间戳：%v\n", unix)
   fmt.Printf("纳秒时间戳：%v\n", nano)
}

时间戳转时间

1
2
3
4
5
6
7
8
9
10
11
12
//时间戳转换为时间
func timestampConventToDate() {
   var timestmap int64 = 1594451753080069400;
   time := time.Unix(timestmap, 0)
   year := time.Year()     //年
   month := time.Month()   //月
   day := time.Day()       //日
   hour := time.Hour()     //时
   minute := time.Minute() //分
   second := time.Second() //秒
   fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}

时间间隔

time.Duration是time包定义的一个类型，他代表两个时间点之间经过的时间，以纳秒为单位，定义了时分秒常量。time.Duration表示一段时间间隔，可表示的最长时间段大约290年。

1
2
3
4
5
6
7
8
const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)

时间操作

Add

指定时间加上或者减去几天，小时等

1
func (t Time) Add(d Duration) Time
1
2
3
4
5
6
7
8
//Add 获取指定时间加上或者减去几天，小时等
func timeOperateAdd(){
   now := time.Now()
   fmt.Println(now)
   //当前时间往后一小时
   time := now.Add(time.Hour)
   fmt.Println(time)
}
### Sub

计算两个时间的时间差

1
func (t Time) Sub(u Time) Duration

返回一个时间段t-u。如果结果超出Duration可以表示的最大值/最小值，将返回最大值/最小值。

1
2
3
4
5
6
7
8
9
10
11
//Sub 计算两个时间的时间差
func timeOperateSub(){
   now := time.Now()
   fmt.Println(now)
   t,err := time.Parse("2006-01-02 15:04", "2020-07-11 12:00")
   if err != nil {
      fmt.Println("时间格式化错误")
   }
   sub := now.Sub(t)
   fmt.Printf("两个时间之间的时间差为：%v\n", sub)
}

Equal

判断是两个时间是否相同，会考虑时区的影响，因此不同时区的标准时间也可以正确比较。

1
2
3
4
5
6
7
8
9
10
11
//Equal 判断两个时间是否相同
func timeEqual(){
   time1, _ := time.Parse("2006-01-02 15:04", "2020-07-11 12:00")
   time2, _ := time.Parse("2006-01-02 15:04", "2020-07-11 12:00")
   equal := time1.Equal(time2)
   if equal {
      fmt.Println("以上两个时间相等")
   }else {
      fmt.Println("以上两个时间不相等")
   }
}

Before

判断当前时间是否在另外一个时间之前

1
2
3
4
5
6
7
8
9
10
11
//判断当前时间是否在另外一个时间之前
func timeBefore(){
   time1, _ := time.Parse("2006-01-02 15:04", "2020-07-10 12:00")
   time2, _ := time.Parse("2006-01-02 15:04", "2020-07-11 12:00")
   before := time1.Before(time2)
   if before {
      fmt.Println("2020-07-10 12:00在2020-07-11 12:00之前")
   }else {
      fmt.Println("2020-07-10 12:00不在2020-07-11 12:00之前")
   }
}

After

判断当前时间是否在另外一个时间之后

1
2
3
4
5
6
7
8
9
10
11
//判断当前时间是否在另外一个时间之后
func timeAfter(){
   time1, _ := time.Parse("2006-01-02 15:04", "2020-07-10 12:00")
   time2, _ := time.Parse("2006-01-02 15:04", "2020-07-11 12:00")
   after := time1.After(time2)
   if after {
      fmt.Println("2020-07-10 12:00在2020-07-11 12:00之后")
   }else {
      fmt.Println("2020-07-10 12:00不在2020-07-11 12:00之后")
   }
}

定时器

使用time.Tick(时间间隔)来设置定时器，定时器的本质上是一个通道(channel)。

1
2
3
4
5
6
7
8
9
//定时器
func timeTick(){
   //定义一个一秒间隔的定时器
   tick := time.Tick(time.Second)
   for time1 := range tick{
      //每秒都会执行的任务
      fmt.Println(time1)
   }
}

时间格式化

时间类型有一个自带的方法Format进行格式化，需要注意的是Go语言中格式化时间模板不是常见的Y-m-d H:M:S而是使用Go的诞生时间2006年1月2号15点04分（记忆口诀为2006 1 2 3 4）。

1
2
3
4
5
6
7
8
9
10
//时间格式化
func timeFormat(){
   now := time.Now()
   //将时间格式化为 12H制
   format1 := now.Format("2006-01-02 03:04")
   fmt.Printf("12H制时间：%v\n",format1)
   //将时间格式化为 24H制
   format2 := now.Format("2006-01-02 15:04")
   fmt.Printf("24H制时间：%v\n", format2)
}

时间解析

1
2
3
4
5
6
7
8
//时间解析
func timeParse(){
   time1, err := time.Parse("2006-01-02 15:04", "2020-07-10 12:00")
   if err != nil {
      fmt.Println("时间格式化错误")
   }
   fmt.Println(time1)
}