我要评论引言
在go语言中，time 包是处理时间和日期的核心。它提供了丰富的函数和方法，用于显示、测量、计算、格式化、解析时间等。
1. 时间的基本获取
在go语言中，time.time 类型用于表示时间。我们可以通过 time.now() 函数获取当前的时间对象，进而获取年、月、日、时、分、秒等信息。
示例代码
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()获取纳秒级时间戳。
示例代码
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类型数据
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”）。
模板必须用这个时间，否则格式化不了
格式化时间
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)
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)
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 方法可以在原有时间的基础上加上或减去一定的时间间隔。
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 方法来计算两个时间点之间的时间间隔。
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解析时间间隔字符串
d, _ := time.parseduration("1.2h")
fmt.println("parsed duration:", d)
5.3 判断时间先后
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函数创建一个固定偏移量的时区。
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 时区转换
在处理跨时区的时间时，可能需要将时间从一个时区转换到另一个时区。这通常涉及到创建两个时间对象，一个代表原始时间，另一个代表转换后的时间，并指定不同的时区。
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 包的功能，可以大大简化时间相关的操作，提高编程效率。
以上就是go语言中时间time相关处理方法详解的详细内容，更多关于go时间time相关处理方法的资料请关注代码网其它相关文章！
发表评论