✨✨ 欢迎大家来到景天科技苑✨✨

🎈🎈 养成好习惯，先赞后看哦~🎈🎈

🏆 作者简介：景天科技苑

🏆《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，CSDN全栈领域优质创作者，掘金优秀博主，51CTO博客专家等。

🏆《博客》：Python全栈，Golang开发，PyQt5和Tkinter桌面开发，小程序开发，人工智能，js逆向，App逆向，网络系统安全，数据分析，Django，fastapi，flask等框架，云原生K8S，linux，shell脚本等实操经验，网站搭建，数据库等分享。

所属的专栏：Go语言开发零基础到高阶实战

景天的主页：景天科技苑

文章目录

Go语言中的时间time1. 时间的基本获取2. 时间戳的获取与转换3. 时间的格式化4. 解析时间字符串4.1 基本解析4.2 带时区的解析

5. 时间的计算5.1 时间的加减5.2 时间间隔的计算5.3 判断时间先后

6. 时区处理6.1 时区表示6.2 时区转换

7. 总结

Go语言中的时间time

在Go语言中，time 包是处理时间和日期的核心。它提供了丰富的函数和方法，用于显示、测量、计算、格式化、解析时间等。

1. 时间的基本获取

在Go语言中，time.Time 类型用于表示时间。我们可以通过 time.Now() 函数获取当前的时间对象，进而获取年、月、日、时、分、秒等信息。

示例代码

<code>package main

import (

"fmt"

"time"

)

func main() {

now := time.Now()

fmt.Printf("current time: %v\n", now)

//得到的是time.Time类型的结构体数据，包含 常量：日月年时分秒 周日-周六 方法：获取常量，计算。

fmt.Printf("current time数据类型: %T\n", now)

//打印年月日时分秒，得到的都是int类型数据

year := now.Year()

month := now.Month()

day := now.Day()

hour := now.Hour()

minute := now.Minute()

second := now.Second()

//Printf ： 整数补位--02如果不足两位，左侧用0补齐输出

fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)

}

通过now.Year()等得到的都是int类型数据

2. 时间戳的获取与转换

时间戳是自1970年1月1日（08:00:00 GMT）至当前时间的总秒数（或毫秒数）。

Go语言中，可以通过time.Now().Unix()获取秒级时间戳，通过time.Now().UnixNano()获取纳秒级时间戳。

示例代码

<code>package main

import (

"fmt"

"time"

)

func main() {

now := time.Now()

timestamp1 := now.Unix() // 秒级时间戳

timestamp2 := now.UnixNano() // 纳秒级时间戳

fmt.Printf("current timestamp1: %v\n", timestamp1)

fmt.Printf("current timestamp2: %v\n", timestamp2)

// 将时间戳转换为时间对象

timeObj := time.Unix(timestamp1, 0)

fmt.Println(timeObj)

// 转换为指定时区的时间对象

secondsEastOfUTC := int((8 * time.Hour).Seconds())

beijing := time.FixedZone("Beijing Time", secondsEastOfUTC)

beijingTimeObj := time.Unix(timestamp1, 0).In(beijing)

fmt.Println(beijingTimeObj)

}

通过time.Now().Unix()获取的时间戳是int64数据类型

如果想要通过时间戳字符串转化为时间格式，需要将时间戳字符串转化为int64类型数据

<code>package main

import (

"fmt"

"strconv"

"time"

)

func main() {

//时间戳字符串

timrstr := "1617922800"

//时间戳是int64类型数据，将时间戳字符串转化为int64类型

timestamp, err := strconv.ParseInt(timrstr, 10, 64)

if err != nil {

fmt.Println("err:", err)

return

}

t := time.Unix(timestamp, 0)

fmt.Println(t)

}

3. 时间的格式化

Go语言允许你按照特定的格式来格式化时间对象，或者将字符串按照指定的格式解析为时间对象。

time.Time 提供了 Format 方法来格式化时间。

func (t Time) Format(layout string) string

Go语言的时间格式化模板不是常见的Y-m-d H:M:S，而是使用Go的诞生时间2006年1月2日 15点04分作为记忆口诀。

格式化模板使用Go的出生时间“2006年1月2日 15时04分05秒”（记忆口诀为“2006 1 2 3 4 5”）。

模板必须用这个时间，否则格式化不了

格式化时间

<code>package main

import (

"fmt"

"time"

)

func main() {

// 时间格式化 2023-02-23 20:43:49

// 格式化模板： yyyy-MM-dd HH:mm:ss

// Go语言诞生的时间作为格式化模板：2006年1月2号下午3点4分5秒

// Go语言格式化时间的代码：2006-01-02 15:04:05 （记忆方式：2006 12 345）

// 固定的："2006-01-02 15:04:05"

now := time.Now()

// 24小时制

fmt.Println(now.Format("2006-01-02 15:04:05")) //2024-09-29 16:34:52

// 12小时制

fmt.Println(now.Format("2006-01-02 03:04:05 PM")) //2024-09-29 04:34:52 PM

// 自定义格式

fmt.Println(now.Format("Jan 2, 2006 at 3:04pm (MST)")) // Sep 29, 2024 at 4:34pm (CST)

fmt.Println(now.Format("2006/01/02 15:04")) // 2024/09/29 16:34

fmt.Println(now.Format("15:04 2006/01/02")) // 16:34 2024/09/29

fmt.Println(now.Format("2006/01/02")) // 2024/09/29

}

4. 解析时间字符串

time.Parse 和 time.ParseInLocation 函数可以将符合特定格式的字符串解析为 time.Time 对象。

Parse函数默认使用本地时区，而ParseInLocation允许指定时区。

4.1 基本解析

func Parse(layout, value string) (Time, error)

<code>package main

import (

"fmt"

"time"

)

func main() {

const layout = "2006-01-02 15:04:05" //模板时间必须是这个

// 假设这是需要解析的时间字符串

const timeStr = "2023-09-10 12:34:56"

t, err := time.Parse(layout, timeStr)

if err != nil {

fmt.Println("Error parsing time:", err)

return

}

fmt.Println("Parsed time:", t)

}

加入我们模板时间用错，解析报错

4.2 带时区的解析

如果时间字符串中包含时区信息，可以使用 time.ParseInLocation 进行解析，并指定时区。

加载时区

func LoadLocation(name string) (*Location, error)

<code>package main

import (

"fmt"

"time"

)

func main() {

// 假设这是需要解析的时间字符串，包含时区信息

const layout = "2006-01-02 15:04:05 MST"

const timeStr = "2023-09-10 12:34:56 CST"

// 加载时区

loc, err := time.LoadLocation("Asia/Shanghai")

if err != nil {

fmt.Println("Error loading location:", err)

return

}

t, err := time.ParseInLocation(layout, timeStr, loc)

if err != nil {

fmt.Println("Error parsing time:", err)

return

}

fmt.Println("Parsed time with location:", t)

}

5. 时间的计算

time 包提供了丰富的函数和方法来支持时间的计算，如时间的加减、时间间隔的计算等。

5.1 时间的加减

使用 time.Time 的 Add 方法可以在原有时间的基础上加上或减去一定的时间间隔。

<code>package main

import (

"fmt"

"time"

)

func main() {

now := time.Now()

// 加上一小时

oneHourLater := now.Add(time.Hour)

fmt.Println("One hour later:", oneHourLater)

// 减去一天

oneDayAgo := now.Add(-24 * time.Hour)

fmt.Println("One day ago:", oneDayAgo)

}

5.2 时间间隔的计算

time.Duration 类型代表两个时间点之间经过的时间，以纳秒为单位。可以使用 time.Time 的 Sub 方法来计算两个时间点之间的时间间隔。

<code>package main

import (

"fmt"

"time"

)

func main() {

start := time.Now()

// 假设这里有一些耗时操作

time.Sleep(2 * time.Second)

end := time.Now()

duration := end.Sub(start)

fmt.Println("Duration:", duration)

// 转换为不同单位

hours := duration.Hours()

minutes := duration.Minutes()

seconds := duration.Seconds()

fmt.Printf("Duration in hours: %v\n", hours)

fmt.Printf("Duration in minutes: %v\n", minutes)

fmt.Printf("Duration in seconds: %v\n", seconds)

}

使用time.ParseDuration解析时间间隔字符串

<code>d, _ := time.ParseDuration("1.2h")

fmt.Println("Parsed Duration:", d)

5.3 判断时间先后

<code>package main

import (

"fmt"

"time"

)

func main() {

t1 := time.Now()

t2 := t1.Add(time.Hour)

fmt.Println(t1)

fmt.Println(t2)

// 判断时间先后

fmt.Println(t1.Before(t2)) // true

fmt.Println(t1.After(t2)) // false

fmt.Println(t1.Equal(t2)) // false

}

6. 时区处理

6.1 时区表示

在Go语言中，时区通过time.Location类型表示。可以使用time.LoadLocation函数加载一个时区，或者使用time.FixedZone函数创建一个固定偏移量的时区。

<code>package main

import (

"fmt"

"time"

)

func main() {

// 加载时区

loc, err := time.LoadLocation("Asia/Shanghai")

if err != nil {

fmt.Println("Error loading location:", err)

return

}

fmt.Println(loc)

// 创建固定偏移量的时区

beijing := time.FixedZone("Beijing Time", 8*3600)

fmt.Println(beijing)

}

6.2 时区转换

在处理跨时区的时间时，可能需要将时间从一个时区转换到另一个时区。这通常涉及到创建两个时间对象，一个代表原始时间，另一个代表转换后的时间，并指定不同的时区。

<code>package main

import (

"fmt"

"time"

)

func main() {

// 原始时间（UTC）

utcTime := time.Date(2023, 9, 10, 12, 0, 0, 0, time.UTC)

fmt.Println("UTC Time:", utcTime)

// 转换为北京时间

beijingLoc, err := time.LoadLocation("Asia/Shanghai")

if err != nil {

fmt.Println("Error loading location:", err)

return

}

beijingTime := utcTime.In(beijingLoc)

fmt.Println("Beijing Time:", beijingTime)

}

7. 总结

Go 语言中的 time 包提供了强大的时间处理功能，包括时间的表示、计算、格式化和解析等。通过本文的详细介绍和实际应用案例，相信读者已经对 Go 语言中的时间处理有了更深入的了解。在实际编程中，合理利用 time 包的功能，可以大大简化时间相关的操作，提高编程效率。