Golang 的时刻处理是 Golang 编程中的一个重要方面,它涉及到了时刻类型、时刻格局化、时刻核算、时区处理以及守时器和超时机制等多个方面。在本文中,咱们将从更深化的视点来讨论 Golang 的时刻处理。

1. 时刻的表明

Go 语言中时刻的表明方式是经过 time.Time 结构体来表明的。time.Time 类型代表了一个时刻,它包含了年月日时分秒和纳秒等信息。

咱们能够运用 time.Now() 函数获取当时时刻,或许运用 time.Date() 函数创立一个指定的时刻。

以下是一个简略的示例代码:

package main
​
import (
  "fmt"
  "time"
)
​
func main() {
    // 获取当时时刻
    t1 := time.Now()
    fmt.Println("当时时刻:", t1)
​
    // 创立指守时刻
    t2 := time.Date(2023, 4, 28, 10, 0, 0, 0, time.Local)
    fmt.Println("指守时刻:", t2)
}

输出成果:

当时时刻: 2023-04-28 14:09:41.517139748 +0800 CST m=+0.000011717
指守时刻: 2023-04-28 10:00:00 +0800 CST

咱们能够看到,当时时刻和指守时刻的格局都是 年-月-日 时:分:秒.纳秒 时区 的方式。

在Go语言中,还供给了一些常用的时刻常量,如 time.RFC3339time.RFC822 等。这些常量能够用于解析或格局化时刻字符串,如下所示:

package main
​
import (
  "fmt"
  "time"
)
​
func main() {
  // 解析时刻字符串
  t1, _ := time.Parse(time.RFC3339, "2023-04-28T16:12:34Z")
  fmt.Println("解析时刻字符串:", t1)
​
  // 格局化时刻
  t2 := time.Now().Format(time.RFC822)
  fmt.Println("格局化时刻:", t2)
}

输出成果:

解析时刻字符串: 2023-04-28 16:12:34 +0000 UTC
格局化时刻: 28 Apr 23 14:10 CST

留意事项:

  • time.Time 类型是一个值类型,不能运用指针来传递或比较。
  • Go 语言中的时刻默认运用的是 UTC 时刻,假如需求运用本地时刻,能够运用 time.Local 来指守时区。

2. 时刻的核算

在 Go 语言中,时刻的核算是经过 time.Duration 类型来表明的。time.Duration 类型代表了一段时刻,能够表明一段时刻的长度,例如 5 分钟、10 小时等。

time.Duration 类型能够运用 time.ParseDuration() 函数从字符串中解析出来,也能够运用 time.Duration 类型的常量来表明,例如 5 * time.Minute 表明 5 分钟。

以下是一个简略的示例代码:

package main
​
import (
  "fmt"
  "time"
)
​
func main() {
  // 核算时刻差
  t1 := time.Now()
  time.Sleep(3 * time.Second)
  t2 := time.Now()
  d := t2.Sub(t1)
  fmt.Println("时刻差:", d)
​
  // 时刻加减
  t3 := time.Now().Add(10 * time.Minute)
  fmt.Println("当时时刻加10分钟:", t3)
}

输出成果:

时刻差: 3.001366444s
当时时刻加10分钟: 2023-04-28 14:23:36.470921569 +0800 CST m=+603.001549491

留意事项:

  • time.Duration 类型的值能够是正数、负数或零,能够进行加减运算。
  • time.Time 类型的 Add() 办法能够用于时刻的加法运算,能够接纳一个 time.Duration 类型的参数,也能够运用负数表明时刻的减法运算。

3. 时刻的比较

在 Go 语言中,能够运用 time.Before()、time.After() 和 time.Equal() 等办法来比较两个时刻的先后顺序以及是否持平。

以下是一个简略的示例代码:

package main
​
import (
  "fmt"
  "time"
)func main() {
    // 时刻比较
    t1 := time.Date(2022, 9, 1, 10, 0, 0, 0, time.Local)
    t2 := time.Date(2023, 4, 28, 16, 12, 34, 567890123, time.Local)
    if t1.Before(t2) {
        fmt.Println("t1 在 t2 之前")
    }
    if t1.After(t2) {
        fmt.Println("t1 在 t2 之后")
    }
    if t1.Equal(t2) {
        fmt.Println("t1 和 t2 持平")
    } else {
        fmt.Println("t1 和 t2 不持平")
    }
}

输出成果:

t1 在 t2 之前
t1 和 t2 不持平

留意事项:

  • time.Time 类型能够直接运用 <、> 和 == 等操作符进行比较,也能够运用 Before()、After() 和 Equal() 等办法来比较。
  • 在比较两个时刻是否持平时,尽量运用 Equal() 办法,而不是直接运用 == 操作符,因为 time.Time 类型是一个结构体类型,运用 == 操作符比较的是结构体的内存地址,而不是结构体的内容。

4. 守时器和 Ticker

Go 语言中的 time 包供给了守时器和 Ticker 两种守时功用,能够用于完成延迟履行、守时履行等功用。

package main
​
import (
  "fmt"
  "time"
)
​
func main() {
  // 创立一个守时器,在 3 秒后触发使命
  timer := time.After(3 * time.Second)
  fmt.Println("守时器已创立,等候触发...")
​
  // 等候守时器触发
  <-timer
  fmt.Println("守时器触发,使命开端履行...")
}

输出成果:

守时器已创立,等候触发...
守时器触发,使命开端履行...

Ticker 是在指定的时刻距离内重复履行使命,能够运用 time.NewTicker() 函数来创立一个 Ticker,例如:

package main
​
import (
  "fmt"
  "time"
)
​
func main() {
  // 创立一个 Ticker,每 1 秒触发一次使命
  ticker := time.NewTicker(1 * time.Second)
  fmt.Println("Ticker 已创立,等候触发...")
​
  // 等候 Ticker 触发
  for range ticker.C {
    fmt.Println("Ticker 触发,使命开端履行...")
   }
}

输出成果:

Ticker 已创立,等候触发...
Ticker 触发,使命开端履行...
Ticker 触发,使命开端履行...
Ticker 触发,使命开端履行...
...

留意事项:

  • 在运用守时器和 Ticker 时,要确保使命的履行时刻不要超过守时器的时刻距离,否则可能会呈现使命堆叠的情况。
  • 在运用 Ticker 时,要记住在使命履行完毕后将 ticker.C 的下一个事件取出,以免使命履行时刻过长导致事件堆积。

5. 时区和时刻格局化

在 Go 语言中,能够运用 time.LoadLocation() 函数来加载时区信息,以便将本地时刻转换为指守时区的时刻。同时,还能够运用 time.Parse() 函数来将字符串解析成时刻目标,并运用 time.Format() 函数将时刻目标格局化成指定格局的字符串。

以下是一个简略的示例代码:

package main
​
import (
  "fmt"
  "time"
)
​
func main() {
    // 加载时区信息
    loc, err := time.LoadLocation("Asia/Shanghai")
    if err != nil {
        fmt.Println("加载时区信息失利:", err)
        return
    }
​
    // 转换本地时刻为指守时区时刻
    t := time.Now().In(loc)
    fmt.Println("当时时刻(北京时区):", t)
​
    // 解析字符串为时刻目标
    layout := "2006-01-02 15:04:05"
    str := "2023-04-28 16:12:34"
    t2, err := time.Parse(layout, str)
    if err != nil {
        fmt.Println("解析时刻字符串失利:", err)
        return
    }
    fmt.Println("解析得到的时刻目标:", t2)
​
    // 将时刻目标格局化为字符串
    layout2 := "2006年01月02日 15点04分05秒"
    str2 := t2.Format(layout2)
    fmt.Println("格局化得到的字符串:", str2)
}

输出成果:

当时时刻(北京时区): 2023-04-28 14:24:35.802985096 +0800 CST
解析得到的时刻目标: 2023-04-28 16:12:34 +0000 UTC
格局化得到的字符串: 2023年04月28日 16点12分34秒

在上面的示例代码中,咱们加载了纽约时区的信息,并将当时时刻转换为纽约时区的时刻。接着,咱们运用 time.Parse() 函数将一个时刻字符串解析成时刻目标,再运用 time.Format() 函数将时刻目标格局化成指定格局的字符串。

需求留意的是,时刻格局字符串中的格局化符号有必要是固定的,不能随意指定。常用的格局化符号如下:

符号 意义 示例
2006 年份,有必要为四位数 2022
01 月份,带前导零 01
02 日期,带前导零 02
15 小时(24小时制),不带前导零 15
04 分钟,带前导零 04
05 秒钟,带前导零 05
.000 微秒,带固定小数点和三位数,取值规模为[000,999] .872
-0700 时区偏移量,形如 -0700 或 +0300 -0400 或 +0800 或 +0000

运用这些格局化符号,咱们就能够将时刻目标格局化成自己想要的字符串。

6. 守时使命

在Go语言中,能够运用 time.Ticker 类型的变量和 for range 循环结合起来完成守时使命。以下是一个简略的示例代码:

package main
​
import (
  "fmt"
  "time"
)
​
func main() {
  ticker := time.NewTicker(time.Second)
  done := make(chan bool)
  go func() {
    for {
      select {
      case <-done:
        return
      case t := <-ticker.C:
        fmt.Println("当时时刻:", t)
       }
     }
   }()
  time.Sleep(5 * time.Second)
  ticker.Stop()
  done <- true
  fmt.Println("守时使命已完毕...")
}

输出成果:

当时时刻: 2023-04-28 20:15:47.1884869 +0800 CST m=+1.005410901
当时时刻: 2023-04-28 20:15:48.1882789 +0800 CST m=+2.005202901
当时时刻: 2023-04-28 20:15:49.1876515 +0800 CST m=+3.004575501
当时时刻: 2023-04-28 20:15:50.1885815 +0800 CST

上面的示例代码中,咱们首要创立了一个 time.Ticker 类型的变量 ticker,用于每秒钟向通道 ticker.C 发送一个时刻信号。接着,咱们运用 make() 函数创立了一个通道 done,用于完毕守时使命。

然后,咱们运用一个匿名的 Go 协程来循环监听通道 ticker.C 和通道 done,并依据收到的信号来履行相应的操作。在每次收到通道 ticker.C 的信号时,咱们都会输出当时时刻;而在收到通道 done 的信号时,咱们则直接回来,完毕循环。

接下来,咱们运用 time.Sleep() 函数来让程序休眠 5 秒钟,以便测试。在休眠完毕后,咱们运用 ticker.Stop() 函数来中止守时器,再向通道 done 发送一个信号,告知循环协程完毕循环。最终,咱们输出一条消息,表明守时使命已经完毕。

需求留意的是,守时使命在循环协程中进行,因而需求运用 go 关键字启动一个协程来履行。别的,假如咱们不中止守时器,循环协程将一直运转下去,因而需求在适当的时候中止守时器。

7. 总结

在本文中,咱们学习了 Go 语言中的时刻处理,主要包含以下 7 个方面:

  1. 时刻类型:Go 语言中的时刻类型有 time.Time 和 time.Duration 两种。
  2. 获取时刻:能够运用 time.Now() 函数获取当时时刻,或许运用 time.Parse() 函数解析时刻字符串。
  3. 时刻核算:能够运用 time.Add() 函数和 time.Sub() 函数进行时刻加减和时刻差核算。
  4. 时刻比较:能够运用 <、<=、>、>=、==、!= 操作符进行时刻比较。
  5. 时刻格局化:能够运用 time.Format() 函数将时刻目标格局化成指定格局的字符串。
  6. 守时使命:能够运用 time.Ticker 类型的变量和 for range 循环结合起来完成守时使命。
  7. 时区处理:能够运用 time.LoadLocation() 函数加载指守时区的信息,或许运用 time.FixedZone() 函数创立一个指定偏移量的时区。

经过本文的学习,期望我们能够对 Go 语言中的时刻处理有一定的了解。在实际开发中,时刻处理是一个非常常见的需求,因而把握好时刻处理的办法对于进步代码质量和开发效率非常重要。