开启生长之旅！这是我参与「日新方案 12 月更文应战」的第13天，点击检查活动概况

耐性和耐久胜过剧烈和狂热。

哈喽大家好，我是陈明勇，今日分享的知识是 Go time 包的运用。假如本文对你有帮助，无妨点个赞，假如你是 Go 言语初学者，无妨点个关注，一同生长一同前进，假如本文有错误的地方，欢迎指出！

前言

在日常开发中，咱们避免不了时刻的运用，咱们或许需要获取当时时刻，然后格局化保存，也或许需要在时刻类型与字符串类型之间彼此转化等。本文将会对 Go time 包里边的常用函数和办法进行介绍。

Now()：获取当时本地的时刻

import (
    "fmt"
    "time"
)
func main() {
    now := time.Now()
    fmt.Println(now) // 2022-12-03 21:06:16.1658077 +0800 CST m=+5.936223001
}

Now() 函数回来的是一个 time 包内置的一个结构体 Time。

获取具体时刻单位的值（yeah、month、day ）

根据 Now() 的回来的 Time 结构体，咱们经过其办法能够获取到具体的时刻单位的值，例如 年、月、日等等。

import (
    "fmt"
    "time"
)
func main() {
    now := time.Now()
    fmt.Println("年：", now.Year())
    fmt.Println("月：", now.Month())
    fmt.Println("数字格局的月：", int(now.Month()))
    fmt.Println("日：", now.Day())
    fmt.Println("时：", now.Hour())
    fmt.Println("分：", now.Minute())
    fmt.Println("秒：", now.Second())
}

经过 Time 结构体的 Year()、Month()、Day()、Hour()、Minute()、Second() 这些办法，能够获取到当时时刻的 年、月、日、时、分、秒的值。

时刻格局化

经过 Time 结构体的 Format(layout string) 办法能够将时刻转化成指定格局并以 string 类型回来。

import (
    "fmt"
    "time"
)
func main() {
    now := time.Now()
    format1 := now.Format("2006-01-02 15:04:05")
    format2 := now.Format("2006/01/02 15:04:05")
    format3 := now.Format("2006-01-02")
    format4 := now.Format("2006/01/02")
    format5 := now.Format("15:04:05")
    fmt.Println(format1) // 2022-12-03 22:27:56
    fmt.Println(format2) // 2022/12/03 22:27:56
    fmt.Println(format3) // 2022-12-03
    fmt.Println(format4) // 2022/12/03
    fmt.Println(format5) // 22:27:56
}

其间 layout 格局参数，Go 强制咱们运用 2006-01-02 15:04:05 这个固定的值，连接符如 - 能够改动，可是数字不能变，不然时刻会对不上。

获取秒、微秒、毫秒、纳秒

import (
    "fmt"
    "time"
)
func main() {
    now := time.Now()
    // 获取秒
    fmt.Println(now.Unix()) // 1670078476
    // 获取毫秒
    fmt.Println(now.UnixMilli()) // 1670079987508082
    // 获取微秒
    fmt.Println(now.UnixMicro()) // 1670079987508082
    // 获取纳秒
    fmt.Println(now.UnixNano()) // 1670079987508082500
}

经过 time 结构体的 Unix()、UnixMilli()、UnixMicro()、UnixNano() 办法能够获取对应是秒时刻戳、毫秒时刻戳、微秒时刻戳和纳秒时刻戳。

经过指定年月日等参数获取时刻

import (
    "fmt"
    "time"
)
func main() {
    date := time.Date(2002, 12, 03, 12, 12, 12, 0, time.UTC)
    fmt.Println(date) // 2022-12-03 12:12:12 +0000 UTC
}

经过 Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time 函数，传入指定的年月日等参数，获取指定是时刻变量。

时刻戳与时刻的转化

import (
    "fmt"
    "time"
)
func main() {
    now := time.Now()
    time1 := time.Unix(now.Unix(), 0).Format("2006-01-02 15:04:05")
    time2 := time.UnixMilli(now.UnixMilli()).Format("2006-01-02 15:04:05")
    time3 := time.UnixMicro(now.UnixMicro()).Format("2006-01-02 15:04:05")
    fmt.Println(time1) // 2022-12-03 23:03:33
    fmt.Println(time2) // 2022-12-03 23:03:33
    fmt.Println(time3) // 2022-12-03 23:03:33
}

经过 Unix()、UnixMilli()、和 UnixMicro() 办法能够将对应时刻戳转化成当时时刻并格局化。

字符串转时刻格局

import (
   "fmt"
   "time"
)
func main() {
   t1, err := time.Parse("2006-01-02 15:04:05", "2022-12-03 13:00:00")
   if err != nil {
      fmt.Println("err: ", err)
      return
   }
   fmt.Println(t1) // 2022-12-03 13:00:00 +0000 UTC
   t2, err := time.Parse("2006-01-02", "2022-12-03")
   if err != nil {
      fmt.Println("err: ", err)
      return
   }
   fmt.Println(t2) // 2022-12-03 00:00:00 +0000 UTC
   t3, err := time.Parse("15:04:05", "13:00:00")
   if err != nil {
      fmt.Println("err: ", err)
      return
   }
   fmt.Println(t3) // 0000-01-01 13:00:00 +0000 UTC
}

经过 Parse(layout, value string) (Time, error) 函数将字符串转成 time 时刻。layout 格局有必要与 value 的格局相对应，不然会回来 error。

时刻的增加和削减操作

import (
    "fmt"
    "time"
)
func main() {
    now := time.Now()
    newTime := now.Add(time.Hour * 1)
    fmt.Println(newTime.Format("2006-01-02 15:04:05"))
}

• 经过 (t Time) Add(d Duration) Time 办法，能够对时刻进行增加或削减操作，传入的参数是正数表明增加，负数表明削减。增加单位有天、小时、分钟等。
• Duration 表明所增加的时刻，time.Hour 表明小时单位，除此之外还有 time.Minute 分钟单位、time.Second 秒单位等。

核算两个时刻的时刻差

import (
    "fmt"
    "time"
)
func main() {
    now := time.Now()
    newTime := now.Add(time.Hour * 1)
    fmt.Println(newTime.Sub(now)) // 1h0m0s
}

经过 Sub(u Time) Duration 办法能够核算两个时刻的时刻差。

核算当时时刻与某个时刻的时刻差

import (
    "fmt"
    "time"
)
func main() {
    beforeTime := time.Now().Add(time.Hour * -1)
    fmt.Println(time.Since(beforeTime)) // 1h0m0s
}

经过 Add(d Duration) Time 办法将当时时刻削减一小时，然后经过 Since(t Time) Duration 函数比较当时时刻与其他时刻的时刻差。

判别当时时刻是否在某个时刻之前

import (
    "fmt"
    "time"
)
func main() {
    now := time.Now()
    date := time.Date(2022, 12, 03, 12, 12, 12, 0, time.UTC)
    fmt.Println(now.Before(date)) // false
}

经过 Before(u Time) bool #办法，判别当时的时刻是否在传入的时刻之前，回来值为布尔值，true 为是，false 为否。

判别当时时刻是否在某个时刻之后

import (
    "fmt"
    "time"
)
func main() {
    now := time.Now()
    date := time.Date(2022, 12, 03, 12, 12, 12, 0, time.UTC)
    fmt.Println(now.After(date)) // true
}

经过 After(u Time) bool 办法，判别当时的时刻是否在传入的时刻之后，回来值为布尔值，true 为是，false 为否。

小结

本文介绍了假如获取当时时刻、在当时时刻的前提下获取具体的年月日时分秒、时刻格局化和时刻戳与时刻的转化以及核算时刻差的办法等。把握了这些函数和办法的运用，应对开发中 时刻操作的场景不成问题。