Go时间操作常用方法(推荐!)

目录

• 1. time 包
• 1.1. 时间类型
• 1.2. 时间戳
• 1.3. 时间间隔
• 1.4. 时间操作
• 2. 获取时间
• 2.1. 获取当前时间
• 2.2. 获取指定时间
• 3. 格式化时间
• 3.1. 时间类型转字符串
• 3.2. 字符串转时间类型
• 4. 时间常量
• 5. 时间操作
• 5.1. 获取时间戳
• 5.2. 时间间隔
• 5.3. 定时器
• 5.4. 定时器
• 6. 时区
• 7. 时区转换
•  总结

1. time 包

1.1. 时间类型

Go 语言中时间类型有两种：

• time.Time：表示时间的类型，常见的有两种方式：
  • time.Now()：获取当前的时间
  • time.Date()：根据指定的年、月、日、时、分、秒、纳秒等创建时间
• time.Duration：表示两个时间点之间经过的时间，以纳秒为单位

1.2. 时间戳

时间戳是自 1970 年 1 月 1 日（08:00:00GMT）至当前时间的总毫秒数。它也被称为 Unix 时间戳（UnixTimestamp）。

1.3. 时间间隔

time.Duration 是 time 包定义的一个类型，它代表两个时间点之间经过的时间，以纳秒为单位。time.Duration 表示一段时间间隔，可表示的最长时间段大约 290 年。

1.4. 时间操作

Go 语言中时间操作主要有两种：

• 获取时间：time.Now()、time.Date()
• 格式化时间：time.Format()、time.Parse()

2. 获取时间

2.1. 获取当前时间

Go 语言中通过 time.Now()函数获取当前时间，返回一个 time.Time 类型的本地时间。

func Now() Time

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now() // 获取当前时间
    fmt.Printf("current time:%v\n", now)
}

2.2. 获取指定时间

time.Date()函数可以获取指定的时间，其参数分别是：年、月、日、时、分、秒、纳秒、时区。

func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time

package main

import (
    "fmt"
    "time"
)

func main() {
    // 获取指定时间
    date := time.Date(2020, 1, 1, 0, 0, 0, 0, time.Local)
    fmt.Printf("date:%v\n", date)
}

3. 格式化时间

3.1. 时间类型转字符串

Go 语言中可以通过 time.Time 类型的 Format()函数对时间进行格式化，该函数的第一个参数是格式化的模板，模板里面的时间必须是 2006-01-02 15:04:05 这个时间，这个时间是固定的，不然就会出错，第二个参数是要格式化的时间。

func (t Time) Format(layout string) string

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now() // 获取当前时间
    // 格式化的模板为Go的出生时间2006年1月2号15点04分 Mon Jan
    fmt.Println(now.Format("2006-01-02 15:04:05.000 Mon Jan"))
    fmt.Println(now.Format("2006/01/02 15:04"))
    fmt.Println(now.Format("15:04 2006/01/02"))
}

3.2. 字符串转时间类型

Go 语言中可以通过 time.Parse()函数对字符串进行解析，生成对应的 time.Time 类型的时间。

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

package main

import (
    "fmt"
    "time"
)

func main() {
    // 加载时区
    loc, _ := time.LoadLocation("Asia/Shanghai")
    // 按照指定时区和指定格式解析字符串时间
    timeObj, err := time.ParseInLocation("2006/01/02 15:04:05", "2020/01/01 00:00:00", loc)
    if err != nil {
        fmt.Printf("parse time failed, err:%v\n", err)
        return
    }
    fmt.Println(timeObj)
}

4. 时间常量

const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)

5. 时间操作

5.1. 获取时间戳

时间戳是自 1970 年 1 月 1 日（08:00:00GMT）至当前时间的总毫秒数。它也被称为 Unix 时间戳（UnixTimestamp）。

func (t Time) Unix() int64

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

5.2. 时间间隔

time.Duration 是 time 包定义的一个类型，它代表两个时间点之间经过的时间，以纳秒为单位。time.Duration 表示一段时间间隔，可表示的最长时间段大约 290 年。

const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    // 程序执行到这里会暂停2秒
    time.Sleep(2 * time.Second)
    fmt.Println("2 seconds later")
    // 两个时间相减
    fmt.Printf("passed %v\n", time.Since(now))
}

5.3. 定时器

time.Timer 类型表示单次时间事件。当定时器到期时，当前时间会被发送给 C，除非定时器是被 AfterFunc 函数创建的。因此，如果程序持有定时器的唯一引用，当定时器触发时，它会被释放，并停止定时器。

func AfterFunc(d Duration, f func()) *Timer

package main

import (
    "fmt"
    "time"
)

func main() {
    timer := time.Tick(time.Second) // 定义一个1秒间隔的定时器
    for t := range timer {
        fmt.Println(t) // 1秒钟执行一次
    }
}

5.4. 定时器

time.Ticker 类型代表一个间隔触发的时间事件，它会以一个间隔（例如，1 秒、1 分钟等）触发多次，发送一个事件给一个通道。

func Tick(d Duration) *Ticker

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(time.Second) // 定义一个1秒间隔的定时器
    for t := range ticker.C {
        fmt.Println(t) // 1秒钟执行一次
    }
}

6. 时区

Go 语言中通过 LoadLocation()函数加载时区信息，它的参数是时区的名字。时区信息我们可以通过 time 包中的 LoadLocation(name string) (*Location, error)函数获取，它返回一个 Location 对象，然后我们就可以通过 LoadLocation()函数加载时区信息了。

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

package main

import (
    "fmt"
    "time"
)

func main() {
    // 加载时区
    loc, err := time.LoadLocation("Asia/Shanghai")
    if err != nil {
        fmt.Printf("load location failed, err:%v\n", err)
        return
    }
    // 按照指定时区和指定格式解析字符串时间
    timeObj, err := time.ParseInLocation("2006/01/02 15:04:05", "2020/01/01 00:00:00", loc)
    if err != nil {
        fmt.Printf("parse time failed, err:%v\n", err)
        return
    }
    fmt.Println(timeObj)
}

7. 时区转换

func (t Time) In(loc *Location) Time

package main

import (
    "fmt"
    "time"
)

func main() {
    // 加载时区
    loc, _ := time.LoadLocation("Asia/Shanghai")
    // 按照指定时区和指定格式解析字符串时间
    timeObj, err := time.ParseInLocation("2006/01/02 15:04:05", "2020/01/01 00:00:00", loc)
    if err != nil {
        fmt.Printf("parse time failed, err:%v\n", err)
        return
    }
    fmt.Println(timeObj)
    // 按照东八区的时区和格式去解析字符串时间
    timeObj, err = time.Parse("2006/01/02 15:04:05", "2020/01/01 00:00:00")
    if err != nil {
        fmt.Printf("parse time failed, err:%v\n", err)
        return
    }
    fmt.Println(timeObj)
    // 将timeObj转换到指定时区
    newTime := timeObj.In(loc)
    fmt.Println(newTime)
}

 总结