Go time包

time包

   time包提供了时间显示与测量所使用的函数。

时间类型

   time.Time类型表示时间,使用time.now()函数获取当前时间对象。对当前时间使用以下函数可获取不同的时间字段。

方法 描述
Year() 获取年
Month() 获取月
Day() 获取日
Hour() 获取时
Second() 获取秒

   操作如下所示:

package main

import (
	"fmt"
	"time"
)

func main(){
	currentTime := time.Now()
	fmt.Println(currentTime)  // 2020-10-09 13:47:55.654372 +0800 CST m=+0.002998001
	fmt.Println(currentTime.Year())
	fmt.Println(currentTime.Month())
	fmt.Println(currentTime.Day())
	fmt.Println(currentTime.Hour())
	fmt.Println(currentTime.Minute())
	fmt.Println(currentTime.Second())
}

时间戳

   获取时间戳共有两种方法

方法 描述
Unix() 获取时间戳
UnixNano() 获取纳秒级的时间戳

   操作如下所示:

package main

import (
	"fmt"
	"time"
)

func main(){
	currentTime := time.Now() 
	timestamp1 := currentTime.Unix()
	timestamp2 := currentTime.UnixNano()
	fmt.Println(timestamp1)
	fmt.Println(timestamp2)
}

时间转换

时间戳转日期

   使用Unix()方法可将时间戳转为日期。

   如下所示:

package main

import (
	"fmt"
	"time"
)

func main() {
	var timestamp1 int64 = 1602222762  // 时间类型是int64
	date := time.Unix(timestamp1, 0) // 最后放入一个0即可
	fmt.Println(date) // 2020-10-09 13:52:42 +0800 CST
}

日期转字符串

   日期转字符串使用Format()函数进行格式化。

   需要注意的是Go语言中格式化时间模板不是常见的Y-m-d H:M:S,而是使用Go的诞生时间2006年1月2号15点04分(记忆口诀为2006 1 2 3 4)。

Go中的日期格式 其他语言日期格式 描述
2006 Y 代表年
1 m 代表月
2 d 代表日
3 H 代表时
4 M 代表分
5 S 代表秒

   如果想格式化为12小时方式,需指定PM。

  

   如下,我们为当前时间进行转换成字符串格式:

package main

import (
	"fmt"
	"time"
)

func main() {
	currentTime := time.Now()
	strTime := currentTime.Format("2006年1月2日 (3时-4分-5秒) PM")  // 加上PM为12小时制
	fmt.Println(strTime) // 2020年10月9日 (2时-23分-1秒) PM
}

字符串转日期

   字符串转日期需要先设定时区,其次使用ParseInLocation()函数进行转换。

   如下所示:

package main

import (
	"fmt"
	"time"
)

func main() {
	strTime := "2010-12-03 12:0:0"
	// 设置时区
	loc, _ := time.LoadLocation("Asia/Shanghai")
	// 设置转换,参数1:指定格式 ,参数2:转换的字符串时间
	timeObj, _ := time.ParseInLocation("2006-1-2 3:4:5", strTime, loc) 
	fmt.Println(timeObj) // 2010-12-03 12:00:00 +0800 CST
}

时间操作

时间间隔

   time.Durationtime包定义的一个类型,它代表两个时间点之间经过的时间,以纳秒为单位。

   time.Duration表示一段时间间隔,可表示的最长时间段大约290年。

   time包中定义的时间间隔类型的常量如下:

const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond  
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second  // 秒
    Hour                 = 60 * Minute // 小时
)

Add

   下列将展示求当前时间一天后的时间:

package main

import (
	"fmt"
	"time"
)

func main() {
	currentTime := time.Now()
	tomorrow := currentTime.Add(time.Hour * 24)
	fmt.Println(tomorrow)
}

Sub

   下列将展示两个时间中的差值。

package main

import (
	"fmt"
	"time"
)

func main() {
	var timestamp1 int64 = 1502222762
	date := time.Unix(timestamp1, 0)   // 旧时间

	result := time.Now().Sub(date) // 当前时间减去旧时间
	fmt.Println(result) // 27778h25m19.987857s 
}

Equal

   判断两个时间是否相等,不用考虑时区的差异,因为内部已经做好了处理。

package main

import (
	"fmt"
	"time"
)

func main() {
	var timestamp1 int64 = 1502222762
	date := time.Unix(timestamp1, 0) // 旧时间

	result := time.Now().Equal(date) // 现在是否等于设置好的旧时间?
	fmt.Println(result) // false
}

Before

   判断该时间是否在某一时间之前,返回布尔值。

package main

import (
	"time"
	"fmt"
)

func main() {
	oldTime := time.Unix(1502222762, 0)
	newTime := time.Unix(1692223444, 0)
	result := oldTime.Before(newTime) // 旧时间是不是在新时间之前?
	fmt.Println(result) // true
}

After

   判断该时间是否在某一时间之后,返回布尔值。

package main

import (
	"time"
	"fmt"
)

func main() {
	oldTime := time.Unix(1502222762, 0)
	newTime := time.Unix(1692223444, 0)
	result := oldTime.After(newTime) // 旧时间是不是在新时间之后?
	fmt.Println(result) // false
}

定时器

   使用time.Tick()来设置一个定时器。

   如下所示,每隔三秒运行一次show()函数。

package main

import (
	"fmt"
	"time"
)

func show(count *int) {
	fmt.Printf("运行了,这是第%v次\n", *count)
	*count++
}

func main() {
	count := 1
	for range time.Tick(3 * time.Second) {
		show(&count)
	}

}

线程睡眠

   使用time.Sleep()来让当前线程进行阻塞。

package main

import (
	"fmt"
	"time"
)


func main() {
	count := 1
	for {
		time.Sleep(3 * time.Second)
		fmt.Println("运行次数:", count)
		count++
	}
}

Tags: