格式化

to string
格式化为字符串我们需要使用 time.Format 方法来转换成我们想要的格式

fmt.Println(time.Now().Format("2006-01-02 15:04:05")) // 2021-11-11 15:32:09
fmt.Println(time.Now().Format(time.UnixDate))     // Thu Nov 11 15:32:09 CST 2021

Format 函数中可以指定你想使用的格式，同时 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"
)

注意: galang 中指定的特定时间格式为 “2006-01-02 15:04:05 -0700 MST”

年、月、日、秒、毫秒、纳秒时间戳输出

year := time.Now().Year() //年
fmt.Println(year)
month := time.Now().Month() //月
fmt.Println(month)
day := time.Now().Day() //日
fmt.Println(day)
hour := time.Now().Hour() //小时
fmt.Println(hour)
minute := time.Now().Minute() //分钟
fmt.Println(minute)
second := time.Now().Second() //秒
fmt.Println(second)
nanosecond := time.Now().Nanosecond() //纳秒
fmt.Println(nanosecond)

package main
import (
    "time"
    "fmt"
)
func main() {
    fmt.Printf("时间戳（秒）：%v;\n", time.Now().Unix())
    fmt.Printf("时间戳（毫秒）：%v;\n",time.Now().UnixNano() / 1e6)
    fmt.Printf("时间戳（纳秒）：%v;\n",time.Now().UnixNano())
    fmt.Printf("时间戳（纳秒转换为秒）：%v;\n",time.Now().UnixNano() / 1e9)
    // 1e6 = 1*10^6 = 100000
    //时间戳（秒）：1636616300;
    //时间戳（纳秒）：1636616300046251000;
    //时间戳（毫秒）：1636616300046;
    //时间戳（纳秒转换为秒）：1636616300;
}

// 秒 1636616165
fmt.Println(time.Now().Unix())
// 获取指定日期的时间戳
dt, _ := time.Parse("2006-01-02 15:04:05", "2021-11-11 15:32:09")
// 1636644729
fmt.Println(dt.Unix())
// 1636702329
fmt.Println(time.Date(2021, 11,12,15,32,9,0, time.Local).Unix())

fmt.Println(time.Hour)         // 1h0m0s     1小时
fmt.Println(time.Second)     // 1s          1秒
fmt.Println(time.Now().Hour()) //16     下午4点
// N天后的时间
d := 3 * 24 * time.Hour
afterNDay := time.Now().Add(d)
fmt.Println("3天后的日期是", afterNDay.Format("2006-01-02"))

时间的计算�

01: 获取今天0点0时0分的时间戳

currentTime := time.Now()
startTime := time.Date(currentTime.Year(), currentTime.Month(), currentTime.Day(), 0, 0, 0, 0, currentTime.Location())
fmt.Println(startTime)
fmt.Println(startTime.Format("2006/01/02 15:04:05"))

02: 获取今天23:59:59秒的时间戳

currentTime := time.Now()
endTime := time.Date(currentTime.Year(), currentTime.Month(), currentTime.Day(), 23, 59, 59, 0, currentTime.Location())
fmt.Println(endTime)
fmt.Println(endTime.Format("2006/01/02 15:04:05"))

03: 获取1分钟之前的时间

m, _ := time.ParseDuration("-1m")
result := currentTime.Add(m)
fmt.Println(result)
fmt.Println(result.Format("2006/01/02 15:04:05"))

04: 获取1小时之前的时间

m, _ := time.ParseDuration("-1h")
result := currentTime.Add(m)
fmt.Println(result)
fmt.Println(result.Format("2006/01/02 15:04:05"))

05: 获取1分钟之后的时间

m, _ := time.ParseDuration("1m")
result := currentTime.Add(m)
fmt.Println(result)
fmt.Println(result.Format("2006/01/02 15:04:05"))

06: 获取1小时之后的时间

m, _ := time.ParseDuration("1h")
result := currentTime.Add(m)
fmt.Println(result)
fmt.Println(result.Format("2006/01/02 15:04:05"))

07 :计算两个时间戳

afterTime, _ := time.ParseDuration("1h")
result := currentTime.Add(afterTime)
beforeTime, _ := time.ParseDuration("-1h")
result2 := currentTime.Add(beforeTime)
m := result.Sub(result2)
fmt.Printf("%v 分钟 \n", m.Minutes())
h := result.Sub(result2)
fmt.Printf("%v小时 \n", h.Hours())
d := result.Sub(result2)
fmt.Printf("%v 天\n", d.Hours()/24)

08: 判断一个时间是否在一个时间之后

stringTime, _ := time.Parse("2006-01-02 15:04:05", "2019-12-12 12:00:00")
beforeOrAfter := stringTime.After(time.Now())
if true == beforeOrAfter {
  fmt.Println("2019-12-12 12:00:00在当前时间之后!")
} else {
  fmt.Println("2019-12-12 12:00:00在当前时间之前!")
}

09: 判断一个时间相比另外一个时间过去了多久

startTime := time.Now()
time.Sleep(time.Second * 5)
fmt.Println("离现在过去了：", time.Since(startTime))

其他

摘自：知乎 go 学堂 https://zhuanlan.zhihu.com/p/343014745

再来看Time结构体在源文件中的定义：

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

获取时间相关操作

1、获取当前时间戳
函数原型：func (t Time) Unix() int64
示例代码：

seconds := time.Now().Unix()

2、获取当前年月日时分秒和星期几（数字不带前导0）
函数原型：

func (t Time) Date() (yearint, month Month, dayint)
func(t Time)Clock() (hour, min, secint)
func(t Time)Hour()int
func(t Time)Minute()int
func(t Time)Second()int

示例代码：

//获取当前时间的Time结构体实例
t := time.Now()
//通过Date函数同时获取年月日
year, month, day := t.Date()
//假设日期为2021-1-7 打印结果为 year:2021, month:1, day:7
fmt.Printf("year:%d, month:%d, day:%d\n", year, month, day)
//通过Clock函数同时获取时分秒
hour, minute, second := t.Clock()
//假设时间是18:51:9 打印结果 hour:18,minute:51,second:9
fmt.Printf("hour:%d,minute:%d,second:%d\n", hour, minute, second)
//也可以单独获取年、月、日、时、分、秒、星期几
year := t.Year() //获取所属年份
month := t.Month() //获取所属月份，不带前导零
day := t.Day() //获取所属日，不带前导零
hour := t.Hour() //获取当前小时
minutes := t.Minute() //获取当前分钟
seconds := t.Seconds() //获取当前描述
nanosecond := t.Nanosecond() //获取当前纳秒数

3、获取今天是星期几
函数原型：func (t Time) Weekday() Weekday
该函数返回值类型是Weekday，即可以表示成数字星期几，也可以输出成星期的英文表示。示例代码：

//获取当前时间的Time结构体实例
t := time.Now()
//获取是星期几， t.Weekday返回的是Weekday类型
//Weekday类型在源码的定义是 type Weekday int
weekday := t.Weekday()
// 打印出星期几的数字表示和英文表示
// 假设是星期四，打印结果：weekday=4, weekday(string)=Thursday
fmt.Printf("weekday=%d, weekday(string)=%s\n\n", weekday, weekday)

4、返回当前时间是一年中的第几天
函数原型：func (t Time) YearDay() int
示例代码：

//获取当前时间的Time结构体实例
t := time.Now()
yearday := time.Now().YearDay()
// 假设时间是2021-01-07日 打印结果 yearday = 7
fmt.Printf("yearday=%d\n\n", yearday)

时间戳和日期字符串之间的转换

1、时间戳格式化成日期字符串
函数原型：

func Unix(sec int64, nsec int64) Time
func (t Time) Format(layout string) string

该转换主要分三步：

1. 将时间戳类型转成int64类型
2. 将int64类型时间戳转换成Time结构
3. 调用Time结构体的Format函数

示例代码：

// 1、将时间戳转换成int64类型
timestamps := int64(1609945385) //该时间戳代表2021-01-06 23：03：05
//2、将int64类型时间戳转换成Time结构,time.Unix函数的第2个参数代表纳秒数
t := time.Unix(timestamps, 0)
//3、调用Time结构体的Format函数,这里我们定义一组格式
var formats = []string{
    "2006年01月02日 15时04分05秒",
    "2006-01-02 15:04:05",
    "2006/01/02 15:04:05",
    "06-01-02",
    "06年01月02日",
    "2006.01.02",
    "06/1/2",
}
for _, layout := range formats {
    result := t.Format(layout)
    fmt.Printf("日期格式:%s, 转换结果:%s \n", layout, result)
}

2、日期字符串按格式转换成时间戳函数原型：funcParseInLocation(layout, valuestring, loc *Location) (Time,error)
该转换主要分三步：

1. 调用time.LoadLocation函数，设置特定的时区。否则，在第2步，默认会按UTC时区解析时间。
2. 调用time.ParseInLocation函数，将字符串转换成Time结构体
3. 调用Time结构体的Unix函数转换成对应的时间戳

示例代码：

// 该结构体代表将value按format格式解析成Time结构体实例
type ParseFormat struct {
    format string // 日期格式
    value string // 要转换的日期
}
//这里定义一组时间格式和要转换的日期字符串
var parseFormats = []ParseFormat{
    {"2006年01月02日 15时04分05秒", "2021年01月06日 23时03分05秒"},
    {"2006-01-02 15:04:05", "2021-01-06 23:03:05"},
    {"2006/01/02 15:04:05", "2021/01/06 23:03:05"},
    {"06-01-02", "21-01-06"},
    {"06年01月02日", "21年01月06日"},
    {"2006.01.02", "2021.01.06"},
    {"06/1/2", "21/1/6"},
}
//1、设置时区为上海，即北京时间
loc, _ := time.LoadLocation("Asia/Shanghai")
for _, parseFormat := range parseFormats {
    // 2、将日期字符串按特定格式转换成特定时区下的Time结构体
    t, _ := time.ParseInLocation(parseFormat.format, parseFormat.value, loc)
    // 3、调用Time结构体的Unix函数转换成对应的时间戳
    unix := t.Unix()
    fmt.Printf("时区:%v, 时间戳（秒）:%d\n", t.Location(), unix)
}

时间之间的常用计算操作

这里介绍一个新的数据类型Duration。在time源码包中的定义如下：

type Duration int64

Duration,代表的是两个时间点之间的持续时间（纳秒数），即时段。
上文的Time结构体类型，代表的是时刻，即一个时间点。如下图：

Duration = t1 - t2 单位：纳秒

1、计算两个日期之间相差多少秒该转换主要分三步：

• 调用time.LoadLocation函数，设置特定的时区。否则，第2步默认会按UTC时区解析时间。
• 调用time.ParseInLocation函数，将字符串转换成Time结构体
• 调用Time结构体的计算函数Sub，得到两个时间之间的Duration

示例代码：

t1str := "2021-01-07 15:57:23"
t2str := "2021-01-07 18:57:23"
layout := "2006-01-02 15:04:05" //时间字符串的格式
//1、将时间字符串转换成Time类型
location, _ := time.LoadLocation("Asia/Shanghai")
t1 := time.ParseInLocation(layout, t1str, location)
t2 := time.ParseInLocation(layout, t2str, location)
//2、计算两个Time结构实例之间的差
d := t2.Sub(t1)
//3、根据返回的Duration类型的d转换成相应的小时/分钟/秒数
hours := d.Hours() //转换成两个时刻相差的小时数
minutes := d.Minutes() //转换成两个时刻相差的分钟数
seconds := d.Seconds() //转换成两个时刻相差的秒数
milliseconds := d.Milliseconds() //转换成两个时刻相差的毫秒数
microseconds := d.Microseconds() //转换成两个时刻相差的微妙数
nanoseconds := d.Nanoseconds() //转换成两个时刻相差的纳秒数

2、获取从某个时间 至今 经过的时间Duration函数原型：funcSince(t Time) Duration
场景：假设你和你女朋友相识于2014-10-02 13:14:15，计算出至今你们总共认识了多长时间。示例代码：

t1str := "2014-10-02 13:14:15"
layout := "2006-01-02 15:04:05" //时间字符串的格式
//1、将时间字符串转换成Time类型
location, _ := time.LoadLocation("Asia/Shanghai")
t := time.ParseInLocation(layout, t1str, location)
//2、计算两个Time结构实例之间的差
d := time.Since(t)
//2、根据返回的d转换成响应的小时/分钟/秒数
hours := d.Hours() //转换成两个时刻相差的小时数
minutes := d.Minutes() //转换成两个时刻相差的分钟数
seconds := d.Seconds() //转换成两个时刻相差的秒数
milliseconds := d.Milliseconds() //转换成两个时刻相差的毫秒数
microseconds := d.Microseconds() //转换成两个时刻相差的微妙数
nanoseconds := d.Nanoseconds() //转换成两个时刻相差的纳秒数
fmt.Printf("从%s至今你们一起度过了共%d", t1str, d.Round(24*time.Hour))
fmt.Printf("从%s至今共一起度过了%f小时\n", t1str, time.Now().Format(layout), hours)

3、计算从今天到未来某个时间经过的时间 函数原型：funcUntil(t Time) Duration
示例代码：

t1str := "2021-12-21 13:14:15"
layout := "2006-01-02 15:04:05" //时间字符串的格式
//第1步，将时间字符串转换成Time类型
location, _ := time.LoadLocation("Asia/Shanghai")
t := time.ParseInLocation(layout, t1str, location)
//第2步，计算两个Time结构实例之间的差
d := time.Until(t)
//第3步，根据返回的d转换成响应的小时/分钟/秒数
hours := d.Hours() //转换成两个时刻相差的小时数
fmt.Printf("距女朋友生日%s还有%f小时\n", t1str, hours)

4、时间之间的比较：是早、是晚、还是相等相关函数：
func (t Time) After(u Time) bool
func (t Time) Before(u Time) bool
func (t Time) Equal(u Time) bool
场景：你和女朋友约会，约好2021-12-12 13:14:15 在餐厅门口见。这时，你看了看手表，在大脑中和约定时间快速的比较了下，判断是来早了还是来晚了

pivot := "2021-12-12 13:14:15"
layout := "2006-01-02 15:04:05" //时间字符串的格式
//第1步，将时间字符串转换成Time类型
location, _ := time.LoadLocation("Asia/Shanghai")
pivotT := time.ParseInLocation(layout, t1str, location)
//第2步，获取现在的时间
t := time.Now()
//第3步，和约定时间比较下是否来早了
if t.Before(pivotT) {
    fmt.Println("来早了")
}
//和约定时间比较一下，看是否来晚了
if t.After(pivotT) {
    fmt.Println("oh，糟糕，来晚了")
}
//和约定时间比较一下，一看，刚刚好
if t.Equal(pivotT) {
    fmt.Println("还好，还好，刚刚好")
}

参考：

• https://www.jb51.net/article/164869.htm