go

time(时间)包使用

目录
  1. 1. 1.获取时间
    1. 1.1. 1.1 当前时间
    2. 1.2. 1.2 当前年、月、日、时、分、秒、星期几
    3. 1.3. 1.3 获取时分秒
    4. 1.4. 1.4 创建指定时间
    5. 1.5. 1.5 获取所属第几周
    6. 1.6. 1.6 获取x年的第几天
  2. 2. 2.字符串转时间
    1. 2.1. 2.1 字符串转时间类型
    2. 2.2. 2.2 格式化时间
  3. 3. 3.时间比较
  4. 4. 4.时间计算
    1. 4.1. 4.1 时间相加
    2. 4.2. 4.2 时间相减
  5. 5. 5.定时器
    1. 5.1. 5.1 NewTicker
    2. 5.2. 5.2 Tick
  6. 6. 6.延迟执行
    1. 6.1. 6.1 NewTimer
    2. 6.2. 6.2 After

1.获取时间

1.1 当前时间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
unix := time.Now().Unix()
fmt.Printf("当前时间戳(单位秒): %v \n",unix)
nano := time.Now().UnixNano()
fmt.Printf("当前时间戳(单位纳秒): %v\n",nano)
format := time.Now().Format("2006-01-02 15:04:05")
fmt.Printf("当前时间(Y-m-d H:i:s): %v\n",format)
format2 := time.Now().Format("20060102150405")
fmt.Printf("当前时间(YmdHis): %v\n",format2)
/**
当前时间戳(单位秒): 1616251448 
当前时间戳(单位纳秒): 1616251448041163000
当前时间(Y-m-d H:i:s): 2021-03-20 22:44:08
当前时间(YmdHis): 20210320224408
*/

1.2 当前年、月、日、时、分、秒、星期几

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
format := time.Now().Format("2006-01-02 15:04:05")
fmt.Printf("当前时间(Y-m-d H:i:s): %v\n",format)
fmt.Printf("当前年: %v\n", time.Now().Year())
fmt.Printf("当前月: %v\n", time.Now().Month())
fmt.Printf("当前日: %v\n", time.Now().Day())
fmt.Printf("当前小时: %v\n", time.Now().Hour())
fmt.Printf("当前分钟: %v\n", time.Now().Minute())
fmt.Printf("当前秒: %v\n", time.Now().Second())
fmt.Printf("当前星期几: %v\n", time.Now().Weekday())
/**输出
当前时间(Y-m-d H:i:s): 2021-03-21 17:32:24
当前年: 2021
当前月: March
当前日: 21
当前小时: 17
当前分钟: 32
当前秒: 24
当前星期几: Sunday
*/

1.3 获取时分秒

1
2
3
4
now := time.Now()
hour, min, sec := now.Clock()
fmt.Printf("时间:%v   huor: %v min:%v sec:%v \n",now,hour,min,sec)
//时间:2021-03-22 23:18:43.245006 +0800 CST m=+0.000108086   huor: 23 min:18 sec:43

1.4 创建指定时间

1
2
3
date := time.Date(2020,8,23,13,53,32,0,time.Local)
fmt.Printf("类型: %T , %v ",date,date)
// 输出:类型: time.Time , 2020-08-23 13:53:32 +0800 CST

1.5 获取所属第几周

1
2
3
4
// 获取当前时间是，今年的第几周
week, w := time.Now().ISOWeek()
fmt.Printf("year: %v w:%v \n",week,w)
// year: 2021 w:12

1.6 获取x年的第几天

1
2
3
num := time.Now().YearDay()
fmt.Printf("今天是今年的第 %v 天 \n",num)
// 今天是今年的第 81 天

2.字符串转时间

2.1 字符串转时间类型

1
2
3
4
5
6
7
8
9
10
11
12
13
str := "1616319808"
unix, _ := strconv.ParseInt(str,10,64)
format := time.Unix(unix, 0)
fmt.Printf("字符串时间戳-> 类型:%T 值:%v \n",format,format)
// 字符串时间,
strDate := "2019-04-10 12:54:03"
// 注意layout格式需要和字符串时间格式一致
location, _ := time.Parse("2006-01-02 15:04:05", strDate)
fmt.Printf("字符串时间-> 类型:%T 值:%v \n",location,location)
/**
字符串时间戳-> 类型:time.Time 值:2021-03-21 17:43:28 +0800 CST 
字符串时间-> 类型:time.Time 值:2019-04-10 12:54:03 +0000 UTC 
*/

2.2 格式化时间

Format根据layout指定的格式返回t代表的时间点的格式化文本表示；Format中内置了几个固定的layout常量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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"
)

使用:

1
2
3
4
5
6
7
8
// 将字符时间: 2020-09-12 14:34:10 转成 20200912143410
strDate := "2020-09-12 14:34:10"
// 1.先转成时间类型
location, _ := time.ParseInLocation("2006-01-02 15:04:05", strDate, time.Local)
// 2.再格式化
format := location.Format("20060102150405")
fmt.Println(format)
// 输出:20200912143410

3.时间比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
strDate := "2020-09-12 12:00:00"
strDate2 := "2020-09-12 12:00:00"
// 1.先转成时间类型
time1, _ := time.ParseInLocation("2006-01-02 15:04:05", strDate, time.Local)
time2, _ := time.ParseInLocation("2006-01-02 15:04:05", strDate2, time.Local)
// 2.比较 strDate2 > strDate ?
before := time1.Before(time2)
fmt.Printf("strDate2 > strDate ? %t \n",before)
// 3.比较 strDate2 = strDate ?
equal := time1.Equal(time2)
fmt.Printf("strDate2 = strDate ? %t \n",equal)
/**输出
strDate2 > strDate ? false 
strDate2 = strDate ? true 
*/

4.时间计算

4.1 时间相加

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
now := time.Now()
fmt.Printf("现在的时间: %v \n",now)
// 十分钟前
duration, _ := time.ParseDuration("-10m")
fmt.Printf("十分钟前: %v \n", now.Add(duration))
// 一小时前
duration2, _ := time.ParseDuration("-1h")
fmt.Printf("一小时前: %v \n", now.Add(duration2))
// 一天后
fmt.Printf("一天后: %v \n", now.AddDate(0,0,1))
fmt.Printf("一月后: %v \n", now.AddDate(0,1,0))
fmt.Printf("一年后: %v \n", now.AddDate(1,0,0))
/**
现在的时间: 2021-03-22 22:54:16.008615 +0800 CST m=+0.000092572 
十分钟前: 2021-03-22 22:44:16.008615 +0800 CST m=-599.999907428 
一小时前: 2021-03-22 21:54:16.008615 +0800 CST m=-3599.999907428 
一天后: 2021-03-23 22:54:16.008615 +0800 CST 
一月后: 2021-04-22 22:54:16.008615 +0800 CST 
一年后: 2022-03-22 22:54:16.008615 +0800 CST 
*/

4.2 时间相减

1
2
3
4
5
6
7
8
9
10
day1, _ := time.ParseInLocation("2006-01-02 15:04:05", "2020-11-02 12:00:00", time.Local)
day2, _ := time.ParseInLocation("2006-01-02 15:04:05", "2020-11-02 15:00:00", time.Local)
fmt.Printf("相差几秒: %v \n",day2.Sub(day1).Seconds())
fmt.Printf("相差多少分钟: %v \n",day2.Sub(day1).Minutes())
fmt.Printf("相差多少小时: %v \n",day2.Sub(day1).Hours())
/**
相差几秒: 10800 
相差多少分钟: 180 
相差多少小时: 3 
*/

5.定时器

5.1 NewTicker

NewTicker返回一个新的Ticker，该Ticker包含一个通道字段，并会每隔时间段d就向该通道发送当时的时间。它会调整时间间隔或者丢弃tick信息以适应反应慢的接收者。如果d<=0会panic。关闭该Ticker可以释放相关资源。

使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
func main() {
	// 创建定时器，间隔设置每秒
	ticker := time.NewTicker(time.Second)
	// 启动一个协程，打印定时器里面的时间
	go func(ticker *time.Ticker) {
		for i := 0; i < 3; i++ {
			fmt.Println(<-ticker.C)
		}
		// 关闭定时器
		ticker.Stop()
	}(ticker)
	// 手动阻塞
	time.Sleep(3 * time.Second)
	fmt.Println("end")
}
/**输出
2021-03-30 11:33:23.704677 +0800 CST m=+1.003656575
2021-03-30 11:33:24.704695 +0800 CST m=+2.003675713
2021-03-30 11:33:25.704271 +0800 CST m=+3.003275554
end
*/

5.2 Tick

Tick是NewTicker的封装，只提供对Ticker通道的访问。如果不需要关闭Ticker，本函数就很方便。

1
2
3
4
5
6
7
8
9
10
11
12
13
func main() {
	// 创建定时器，间隔设置每秒
	chTime := time.Tick(time.Second)
	// 启动一个协程，打印定时器里面的时间
	go func(ch <- chan time.Time) {
		for i := 0; i < 3; i++ {
			fmt.Println(<-ch)
		}
	}(chTime)
	// 手动阻塞
	time.Sleep(4 * time.Second)
	fmt.Println("end")
}

6.延迟执行

6.1 NewTimer

NewTimer创建一个Timer，它会在指定时间后，向其自身的C字段发送当时的时间。

1
2
3
4
5
6
7
8
9
10
func main() {
	fmt.Printf("开始时间: %v \n",time.Now())
	timer := time.NewTimer(time.Second * 3)
	// 此处会阻塞，直到timer.C中有数据写入
	fmt.Printf("timer通道里的时间: %v \n", <- timer.C)
}
/**输出
开始时间: 2021-03-30 14:27:04.966887 +0800 CST m=+0.001502710 
timer通道里的时间: 2021-03-30 14:27:07.970134 +0800 CST m=+3.004701898 
*/

6.2 After

After()函数相当于NewTimer(d).C,如下源码:

1
2
3
func After(d Duration) <-chan Time {
	return NewTimer(d).C
}

使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func main() {
	// 创建一个计时器,返回的是chan
	ch := time.After(5 * time.Second)
	fmt.Printf("开始时间 %v \n",time.Now())
	// 此处会阻塞5秒
	out := <- ch
	fmt.Printf("变量out->  类型: %T 值:%v  \n",out,out)
	fmt.Printf("开始时间 %v \n",time.Now())
}
/** 输出
  开始时间 2020-12-10 11:01:07.272154 +0800 CST m=+0.000153152 
  变量out->  类型: time.Time 值:2020-12-10 11:01:12.273034 +0800 CST m=+5.000956630  
  开始时间 2020-12-10 11:01:12.273153 +0800 CST m=+5.001076196 
*/

文章链接: http://liuqh.icu/2021/03/30/go/package/3-time/