时间对象

创建gtime.Time对象可以通过标准库time.Time对象、Unix时间戳、时间字符串（如：2018-07-18 12:01:00）、自定义时间字符串（需要给定格式，支持自定义格式及标准库格式）。

创建对象

可以通过gtime.New方法创建gtime.Time对象，该方法支持time.Time、时间戳、时间字符串创建对象。其中时间戳支持到纳秒的时间整型长度。 例如：

  1. // 通过时间字符串创建
  2. gtime.New("2020-10-24 12:00:00")
  3. // 通过time.Time对象创建
  4. gtime.New(time.Now())
  5. // 通过时间戳(秒)创建
  6. gtime.New(1603710586)
  7. // 通过时间戳(纳秒)创建
  8. gtime.New(1603710586660409000)

此外，时间字符串支持常见时间类型，例如：

  1. 2017-12-14 04:51:34 +0805 LMT
  2. 2017-12-14 04:51:34 +0805 LMT
  3. 2006-01-02T15:04:05Z07:00
  4. 2014-01-17T01:19:15+08:00
  5. 2018-02-09T20:46:17.897Z
  6. 2018-02-09 20:46:17.897
  7. 2018-02-09T20:46:17Z
  8. 2018-02-09 20:46:17
  9. 2018/10/31 - 16:38:46
  10. 2018-02-09
  11. 2018.02.09
  13. 01-Nov-2018 11:50:28
  14. 01/Nov/2018 11:50:28
  15. 01.Nov.2018 11:50:28
  16. 01.Nov.2018:11:50:28
  17. 日期连接符号支持'-'、'/'、'.'

使用示例

示例1，自定义格式化语法

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/v2/os/gtime"
  6. )
  8. func main() {
  9.     formats := []string{
  10.         "Y-m-d H:i:s.u",
  11.         "D M d H:i:s T O Y",
  12.         "\\T\\i\\m\\e \\i\\s: h:i:s a",
  13.         "2006-01-02T15:04:05.000000000Z07:00",
  14.     }
  15.     t := gtime.Now()
  16.     for _, f := range formats {
  17.         fmt.Println(t.Format(f))
  18.     }
  19. }

在该示例中，我们给定了四种format格式，并将当前时间用这四种格式转换后打印出来。执行后，输出结果如下：

  1. 2018-07-22 11:17:13.797
  2. Sun Jul 22 11:17:13 CST +0800 2018
  3. Time is: 11:17:13 am
  4. 2006-01-02CST15:04:05.000000000Z07:00

可以看到，这个示例演示了几个需要注意的地方：

  1. 如果使用的字母与格式化字符冲突时，可以使用\符号转义该字符，这样时间格式解析器会认为该字符不是格式化字符，而是普通字母。因此这里的第三个字符串示例输出为：Time is: 11:17:13 am
  2. 使用Format方法接收的是自定义的时间格式化语法（如：Y-m-d H:i:s），而非标准库的时间格式语法（如：2006-01-02 15:04:05），因此在这里的第四个字符串示例中原样输出参数值；

示例2，标准库格式化语法

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/v2/os/gtime"
  6. )
  8. func main() {
  9.     formats := []string{
  10.         "2006-01-02 15:04:05.000",
  11.         "Mon Jan _2 15:04:05 MST 2006",
  12.         "Time is: 03:04:05 PM",
  13.         "2006-01-02T15:04:05.000000000Z07:00 MST",
  14.     }
  15.     t := gtime.Now()
  16.     for _, f := range formats {
  17.         fmt.Println(t.Layout(f))
  18.     }
  19. }

在该示例中，我们使用四种标准库的时间格式化语法格式化当前的时间并输出结果到终端。执行后，输出结果为：

  1. 2018-07-22 11:28:13.945
  2. Sun Jul 22 11:28:13 CST 2018
  3. Time is: 11:28:13 AM
  4. 2018-07-22T11:28:13.945153275+08:00 CST

有几个需要说明的地方：

  1. 自定义时间格式化语法与标准库时间格式化语法并不冲突，前者使用Format方法，后者使用Layout方法行格式化，相互独立，互不冲突，无法混用；
  2. 标准库的时间格式化语法自有特点，是不是感觉有点复杂；

示例3，时间对象链式操作

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/v2/os/gtime"
  6.     "time"
  7. )
  9. func main() {
  10.     // 去年今日，系统时间
  11.     fmt.Println(gtime.Now().AddDate(-1, 0, 0).Format("Y-m-d"))
  13.     // 去年今日，UTC时间
  14.     fmt.Println(gtime.Now().AddDate(-1, 0, 0).Format("Y-m-d H:i:s T"))
  15.     fmt.Println(gtime.Now().AddDate(-1, 0, 0).UTC().Format("Y-m-d H:i:s T"))
  17.     // 下个月1号凌晨0点整
  18.     fmt.Println(gtime.Now().AddDate(0, 1, 0).Format("Y-m-01 00:00:00"))
  20.     // 1个小时前
  21.     fmt.Println(gtime.Now().Add(-time.Hour).Format("Y-m-d H:i:s"))
  22. }

执行后，输出结果为：

  1. 2020-09-19
  2. 2020-09-19 15:51:48 CST
  3. 2020-09-19 07:51:48 UTC
  4. 2021-10-01 00:00:00
  5. 2021-09-19 14:51:48

该示例比较简单，便不多赘述。