Golang标准库-Time 时间操作大全

最新推荐文章于 2024-12-24 18:38:55 发布

付少华

最新推荐文章于 2024-12-24 18:38:55 发布

阅读量2.5k

点赞数 2

分类专栏： Go基础 go标准库的使用文章标签： golang

本文链接：https://blog.csdn.net/weixin_44014995/article/details/112596932

版权

Go基础同时被 2 个专栏收录

72 篇文章

订阅专栏

go标准库的使用

15 篇文章

订阅专栏

平时开发过程中，时间相关的操作用的还是很多的。接下来就与大家一起总结下与时间有关的操作，主要涉及到 time 包，核心数据结构是 time.Time，如下：

type Time struct {
    wall uint64
    ext  int64
    loc *Location
}

1.获取时间相关函数

获取当前时间

// 返回当前时间，注意此时返回的是 time.Time 类型
now := time.Now()
fmt.Println(now)
// 当前时间戳
fmt.Println(now.Unix())
// 纳秒级时间戳
fmt.Println(now.UnixNano())
// 时间戳小数部分 单位：纳秒
fmt.Println(now.Nanosecond())

输出：

2021-01-10 14:56:15.930562 +0800 CST m=+0.000124449
1610261775
1610261775930562000
930562000

返回当前年月日时分秒、星期几、一年中的第几天等操作

package main

import (
	"fmt"
	"time"
)

func main() {
	now := time.Now()

	// 返回日期
	year, month, day := now.Date()
	fmt.Printf("year:%d, month:%d, day:%d\n", year, month, day)
	//输出:year:2021, month:1, day:22
	// 年
	fmt.Println(now.Year())
	// 月
	fmt.Println(now.Month())
	// 日
	fmt.Println(now.Day())
	//输出：2021
	//January
	//22

	// 时分秒
	//Clock：返回由t指定的一天内的 时 分 秒
	hour, minute, second := now.Clock()
	fmt.Printf("hour:%d, minute:%d, second:%d\n", hour, minute, second)
	//输出:hour:10, minute:3, second:9
	// 时
	fmt.Println(now.Hour())
	// 分
	fmt.Println(now.Minute())
	// 秒
	fmt.Println(now.Second())

	// 返回星期
	//Weekday：返回由t指定的星期几
	fmt.Println(now.Weekday())
	spr := fmt.Sprintf("%d", now.Weekday())//根据格式化说明符进行格式化并返回结果字符串
	fmt.Println("spr",spr)
	fmt.Printf("%d\n",now.Weekday())
	//返回一年中对应的第几天
	fmt.Println(now.YearDay())
	//返回时区
	fmt.Println(now.Location())

	// 返回一年中第几天
	fmt.Println(now.YearDay())
}

格式化时间

Go 语言提供了时间类型格式化函数 Format()，需要注意的是 Go 语言格式化时间模板不是常见的 Y-m-d H:i:s，而是 2006-01-02 15:04:05，也很好记忆(2006 1 2 3 4 5)

	now := time.Now()

	fmt.Println(now.Format("2006-01-02 15:03:04"))
	fmt.Println(now.Format("2006-01-02"))
	fmt.Println(now.Format("15:03:04"))
	fmt.Println(now.Format("2006/01/02 15:04"))
	fmt.Println(now.Format("15:04 2006/01/02"))

2.时间戳与日期字符串相互转化

时间戳怎么转成日期格式呢？需要先转成将时间戳转成 time.Time 类型再格式化成日期格式。

根据秒数、纳秒数返回 time.Time 类型

package main

import (
	"fmt"
	"time"
)

func main() {
	now := time.Now()
	layout := "2006-01-02 15:04:05"
	t := time.Unix(now.Unix(),0) // 参数分别是：秒数,纳秒数
	fmt.Println(t)
	fmt.Println(t.Format(layout))
	//2021-01-22 10:29:19 +0800 CST
	//2021-01-22 10:29:19
}

栗子

func GetDateDay(starUnix, endUnix int64) (string, string) {
	starDay := time.Unix(starUnix, 0).Format(DateLayout)
	endDay := time.Unix(endUnix, 0).Format(DateLayout)
	return starDay, endDay
}

根据指定时间返回 time.Time 类型，使用函数 time.Date()

package main

import (
	"fmt"
	"time"
)

func main() {
	now := time.Now()
	layout := "2006-01-02 15:04:05"

	//根据指定时间返回 time.Time 类型
	//分别指定年，月，日，时，分，秒，纳秒，时区
	t := time.Date(2011, time.Month(3), 12, 15, 30, 20, 0, now.Location())
	fmt.Println(t.Format(layout))
	//输出：2011-03-12 15:30:20
}

日期字符串解析成 time.Time 类型

package main

import (
	"fmt"
	"time"
)

func main() {
	t, _ := time.ParseInLocation("2006-01-02 15:04:05", time.Now().Format("2006-01-02 15:04:05"), time.Local)
	fmt.Println("t", t)
	// 输出 t 2021-01-22 10:39:30 +0800 CST(北京时间)
	//time.Local 指定本地时间
	//time.Now:返回当前本地时间
	tt, _ := time.Parse("2006-01-02 15:04:05", time.Now().Format("2006-01-02 15:04:05"))
	fmt.Println("tt", tt)
	// 输出 tt 2021-01-22 10:47:18 +0000 UTC(世界协调时间)
	//ParselnLocation功能与parse类似，但两个重要的不同之处：
	//1.当缺少时区信息时，Parse将时间解释为UTC时间，而ParselnLocation将返回值得Location设置为loc(正在使用的区域)
	//2.当时间字符串提供了时区偏移量信息时，Parse会尝试去匹配本地时区，而ParselnLocation会去匹配loc
}

解析的时候需要特别注意时区的问题：

package main

import (
	"fmt"
	"time"
)

func main() {
	fmt.Println(time.Now())
	fmt.Println(time.Now().Location())
	t, _ := time.Parse("2006-01-02 15:04:05", time.Now().Format("2006-01-02 15:04:05"))
	tt, _ := time.ParseInLocation("2006-01-02 15:04:05", time.Now().Format("2006-01-02 15:04:05"), time.Local)
	fmt.Println("t",t)
	fmt.Println("tt",tt)
	//value:(timeDatest) 需要转换的时间  layout :对应的格式 local:本地时间
	timeDatest:="2021072220"
	tt, _ := time.ParseInLocation("2006010215", timeDatestr, time.Local)
	timeunix:=time.Date(tt.Year(), tt.Month(), tt.Day(), tt.Hour(), 0, 0, 0, LocalTime)
	//转换成时间戳输出
	fmt.Println("tt",timeunix.Unix())
}

输出：

2021-01-22 11:06:12.195057 +0800 CST m=+0.002991101
Local
t 2021-01-22 11:06:12 +0000 UTC
tt 2021-01-22 11:06:12 +0800 CST

可以看到，time.Now() 使用的 CST(中国标准时间)，而 time.Parse() 默认的是 UTC(零时区)，它们相差 8 小时。所以解析时常用 time.ParseInLocation()，可以指定时区

！！重点！！

画了张图，帮助大家理清时间戳、time.Time 和日期格式之间的转化关系：
在这里插入图片描述

列子，时间戳转日期

    startTime:=1633881600
    endTime:=1639065600
    eTime := time.Unix(endTime, 0)
	sTime := time.Unix(startTime, 0)
	startTimeday := sTime.Format("2006-01-02")
	endTimeday := eTime.Format("2006-01-02")
	//输出:startTimeday: 2021-10-11
	//输出:endTimeday: 2021-12-10

例子，日期转时间戳

package main

import (
	"fmt"
	"time"
)

func TimeStr2Time(Format,valueStr, locStr string) int64 {
	loc := time.Local
	if locStr != "" {
		loc, _ = time.LoadLocation(locStr) // 设置时区
	}
	if Format == "" {
		Format = "2006-01-02"
	}
	t, _ := time.ParseInLocation(Format, valueStr, loc)
	return t.Unix()
}

func main() {
	fmt.Println(TimeStr2Time("","2021-10-11",""))
}

计算、比较日期

讲到日期的计算就不得不提 time 包提供的一种新的类型 Duration，源码是这样定义的：

type Duration int64

底层类型是 int64，表示一段时间间隔，单位是纳秒。

24小时之内的时间计算

now := time.Now()
fmt.Println(now)

// 1小时1分1s之后
t1, _ := time.ParseDuration("1h1m1s")
fmt.Println(t1)
m1 := now.Add(t1)
fmt.Println(m1)

// 1小时1分1s之前
t2, _ := time.ParseDuration("-1h1m1s")
m2 := now.Add(t2)
fmt.Println(m2)

// 3小时之前
t3, _ := time.ParseDuration("-1h")
m3 := now.Add(t3 * 3)
fmt.Println(m3)

// 10 分钟之后
t4, _ := time.ParseDuration("10m")
m4 := now.Add(t4)
fmt.Println(m4)

// Sub 计算两个时间差
sub1 := now.Sub(m3)
fmt.Println(sub1.Hours())   // 相差小时数
fmt.Println(sub1.Minutes()) // 相差分钟数

额外再介绍两个函数 time.Since()、time.Until()：

// 返回当前时间与 t 的时间差，返回值是 Duration
time.Since(t Time) Duration

// 返回 t 与当前时间的时间差，返回值是 Duration
time.Until(t Time) Duration
now := time.Now()
fmt.Println(now)

t1, _ := time.ParseDuration("-1h")
m1 := now.Add(t1)
fmt.Println(m1)
fmt.Println(time.Since(m1))
fmt.Println(time.Until(m1))

输出

2021-01-13 23:49:59.1026045 +0800 CST m=+0.020941801
2021-01-13 22:49:59.1026045 +0800 CST m=-3599.979058199
1h0m0.081781s
-1h0m0.081781s

24小时之外的时间计算

涉及到一天以外的时间计算，就需要用到 time.AddDate()，函数原型：

func (t Time) AddDate(years int, months int, days int) Time

比如我们想知道一年一个月零一天之后的时间，就可以这样：

now := time.Now()
fmt.Println(now)
m1 := now.AddDate(1,1,1)
fmt.Println(m1)

再比如，我们想获得 2 天之前时间：

now := time.Now()
fmt.Println(now)
m1 := now.AddDate(0,0,-2)
fmt.Println(m1)

日期比较

日期的比较总共有三种：之前、之后和相等。

// 如果 t 代表的时间点在 u 之前，返回真；否则返回假。
func (t Time) Before(u Time) bool

// 如果 t 代表的时间点在 u 之后，返回真；否则返回假。
func (t Time) After(u Time) bool

// 比较时间是否相等，相等返回真；否则返回假。
func (t Time) Equal(u Time) bool
now := time.Now()
fmt.Println(now)

// 1小时之后
t1, _ := time.ParseDuration("1h")
m1 := now.Add(t1)
fmt.Println(m1)

fmt.Println(m1.After(now))
fmt.Println(now.Before(m1))
fmt.Println(now.Equal(m1))

输出

2021-01-13 23:55:45.2949055 +0800 CST m=+0.025930701
2021-01-14 00:55:45.2949055 +0800 CST m=+3600.025930701
true
true
false

常见例子

下面列举一些常见的例子和函数封装。

日期格式转时间戳

package main

import (
	"fmt"
	"time"
)

func TimeStr2Time(Format,valueStr, locStr string) int64 {
	loc := time.Local
	if locStr != "" {
		loc, _ = time.LoadLocation(locStr) // 设置时区
	}
	if Format == "" {
		Format = "2006-01-02"
	}
	t, _ := time.ParseInLocation(Format, valueStr, loc)
	return t.Unix()
}

func main() {
	fmt.Println(TimeStr2Time("","2021-10-11",""))
}

获取当前时间日期格式

func GetCurrentFormatStr(fmtStr string) string {
    if fmtStr == "" {
        fmtStr = "2006-01-02 15:04:05"
    }
    return time.Now().Format(fmtStr)
}

时间戳 to 日期格式

func Sec2TimeStr(sec int64, fmtStr string) string {
    if fmtStr == "" {
        fmtStr = "2006-01-02 15:04:05"
    }
    return time.Unix(sec, 0).Format(fmtStr)
}

时间格式相互转换

先来看看time包中对格式的常量定义

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"
)

将格式为：

2018-01-14T21:45:54+08:00
转换为日期格式:
2018-01-14 21:45:54

其实琢磨了一下方法还是很简单

str:="2018-01-14T21:45:54+08:00"
//先将时间转换为字符串

tt,_:=time.Parse("2006-01-02T15:04:05Z07:00",str)

//格式化时间
fmt.Println(tt.Format("2006-01-02 15:04:05"))

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

tiem.Parse()的layout参数就是上面的RFC3339如果是其他格式也只要复制对应的layout就可以了
tiem.Format（） 是将时间按照自定义的方式进行格式化

时间规整

去除时分秒

       startTime :=1630465813
       endTime :=1631081413
		fmt.Printf("时间规整前 startTime:%s,endTime:%s", time.Unix(startTime, 0).Format(SecondDateLayout), time.Unix(endTime, 0).Format(SecondDateLayout))
	    t := time.Unix(startTime, 0)
		tend := time.Unix(endTime, 0)
		tt := time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, LocalTime).Unix()
		ttend := time.Date(tend.Year(), tend.Month(), tend.Day(), 0, 0, 0, 0, LocalTime).Unix()
		fmt.Println("tt", tt)
		fmt.Println("ttend ", ttend )
      fmt.Printf("时间规整后 startTime:%s,endTime:%s", time.Unix(tt, 0).Format(SecondDateLayout), time.Unix(ttend, 0).Format(SecondDateLayout))

输出:
时间规整前 startTime:2021-09-01 11:10:13,endTime:2021-09-08 14:10:13
tt:    1630425600
ttend :1631030400
时间规整后 startTime:2021-09-01 00:00:00,endTime:2021-09-08 00:00:00