3

「有问必答」Gopher如何优雅的对时间进行格式化?

 1 year ago
source link: https://www.51cto.com/article/757570.html
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.
neoserver,ios ssh client

「有问必答」Gopher如何优雅的对时间进行格式化?

作者：王中阳Go 2023-06-13 07:50:49
时间类型有一个自带的方法Format进行格式化，需要注意的是Go语言中格式化时间模板不是常见的Y-m-d H:M:S而是使用Go的诞生时间2006年1月2号15点04分（记忆口诀为2006 1 2 3 4）。

昨天 交流群 关于「Go如何优雅地对时间进行格式化?」展开了讨论：

图片
图片

如何在不循环的情况下，把列表数据结构体的时间修改为咱们习惯的格式，而不是UTC模式

我们要实现的效果如下:

  • created_at 是go语言原生的方式，
  • updated_at 是我们期望优化成的方式
{
    "code": 200,
    "data": {
        "count": 12,
        "info": [
            {
                "created_at": "2021-03-17T07:11:24+08:00" //原生方式
                "updated_at": "2021-03-17 07:11:24",  //需要优化成这种
            }
        ]
    },
    "message": "成功"
}
  1. 首先我们引入一个包，在控制台运行
go get github.com/liamylian/jsontime
  1. 下载相关依赖
go mod download
  1. 修改结构体，声明要处理的时间字段
type Order struct {
    .
    .
    .
 CreatedAt       time.Time `json:"created_at" time_format:"sql_datetime" time_utc:"false"`       // 格式化时间示例
 UpdatedAt       string  `json:"updated_at"`       // 原生状态示例
}
  1. 取值时调用MarshalToString把结构体数据转为字符串
  2. 但是转完的字符串存在反斜线的问题，使用json.RawMessage()处理一下
var timeJson = jsontime.ConfigWithCustomTimeFormat

func AllOrder(c *gin.Context) {
 limitStr := c.DefaultQuery("limit", "10")
 pageStr := c.DefaultQuery("page", "0")
 orderType := c.DefaultQuery("orderType", "desc")
 orderField := c.DefaultQuery("orderField", "id")
 orderSql := orderField + " " + orderType
 limit, _ := strconv.Atoi(limitStr)
 page, _ := strconv.Atoi(pageStr)
 count, res := model.QueryOrder(0, limit, page, orderSql)
 //处理1：MarshalToString
 bytes, _ := timeJson.MarshalToString(&res)

 jsonInfo := map[string]interface{}{
  "count": count,
  //处理2：解决反斜线的问题
  "info":  json.RawMessage(bytes), 
 }

 c.JSON(http.StatusOK, ReturnJson{
  http.StatusOK,
  jsonInfo,
  "成功",
 })
}

我们最终实现出来的效果

{
    "code": 200,
    "data": {
        "count": 12,
        "info": [
            {
                "updated_at": "2021-03-17 07:13:24",
                "created_at": "2021-03-17 07:11:24",  
            }
        ]
    },
    "message": "成功"
}

好了，通过引入上面的神器就解决了我们的问题。

我们再深入理解一下time包的使用：

time包

time包提供了时间的显示和测量用的函数。日历的计算采用的是公历。

time.Time类型表示时间。我们可以通过time.Now()函数获取当前的时间对象，然后获取时间对象的年月日时分秒等信息。示例代码如下：

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

 year := now.Year()     //年
 month := now.Month()   //月
 day := now.Day()       //日
 hour := now.Hour()     //小时
 minute := now.Minute() //分钟
 second := now.Second() //秒
 fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}

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

基于时间对象获取时间戳的示例代码如下：

func timestampDemo() {
 now := time.Now()            //获取当前时间
 timestamp1 := now.Unix()     //时间戳
 timestamp2 := now.UnixNano() //纳秒时间戳
 fmt.Printf("current timestamp1:%v\n", timestamp1)
 fmt.Printf("current timestamp2:%v\n", timestamp2)
}

使用time.Unix()函数可以将时间戳转为时间格式。

func timestampDemo2(timestamp int64) {
 timeObj := time.Unix(timestamp, 0) //将时间戳转为时间格式
 fmt.Println(timeObj)
 year := timeObj.Year()     //年
 month := timeObj.Month()   //月
 day := timeObj.Day()       //日
 hour := timeObj.Hour()     //小时
 minute := timeObj.Minute() //分钟
 second := timeObj.Second() //秒
 fmt.Printf("%d-%02d-%02d %02d:%02d:%02d\n", year, month, day, hour, minute, second)
}

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

time包中定义的时间间隔类型的常量如下：

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

例如：time.Duration表示1纳秒，time.Second表示1秒。

Add 我们在日常的编码过程中可能会遇到要求时间+时间间隔的需求，Go语言的时间对象有提供Add方法如下：

func (t Time) Add(d Duration) Time 举个例子，求一个小时之后的时间：

func main() {
 now := time.Now()
 later := now.Add(time.Hour) // 当前时间加1小时后的时间
 fmt.Println(later)
}

求两个时间之间的差值：

func (t Time) Sub(u Time) Duration

返回一个时间段t-u。如果结果超出了Duration可以表示的最大值/最小值，将返回最大值/最小值。要获取时间点t-d（d为Duration），可以使用t.Add(-d)。

Equal

func (t Time) Equal(u Time) bool

判断两个时间是否相同，会考虑时区的影响，因此不同时区标准的时间也可以正确比较。本方法和用t==u不同，这种方法还会比较地点和时区信息。

Before

func (t Time) Before(u Time) bool

如果t代表的时间点在u之前，返回真；否则返回假。

After

func (t Time) After(u Time) bool

如果t代表的时间点在u之后，返回真；否则返回假。

使用time.Tick(时间间隔)来设置定时器，定时器的本质上是一个通道（channel）。

func tickDemo() {
 ticker := time.Tick(time.Second) //定义一个1秒间隔的定时器
 for i := range ticker {
  fmt.Println(i)//每秒都会执行的任务
 }
}

时间格式化

时间类型有一个自带的方法Format进行格式化，需要注意的是Go语言中格式化时间模板不是常见的Y-m-d H:M:S而是使用Go的诞生时间2006年1月2号15点04分（记忆口诀为2006 1 2 3 4）。

也许这就是技术人员的浪漫吧~（当然，也有人说这是瞎搞~）

补充：如果想格式化为12小时方式，需指定PM。

func formatDemo() {
 now := time.Now()
 // 格式化的模板为Go的出生时间2006年1月2号15点04分 Mon Jan
 // 24小时制
 fmt.Println(now.Format("2006-01-02 15:04:05.000 Mon Jan"))
 // 12小时制
 fmt.Println(now.Format("2006-01-02 03:04:05.000 PM Mon Jan"))
 fmt.Println(now.Format("2006/01/02 15:04"))
 fmt.Println(now.Format("15:04 2006/01/02"))
 fmt.Println(now.Format("2006/01/02"))
}

解析字符串格式的时间

now := time.Now()
fmt.Println(now)
// 加载时区
loc, err := time.LoadLocation("Asia/Shanghai")
if err != nil {
 fmt.Println(err)
 return
}
// 按照指定时区和指定格式解析字符串时间
timeObj, err := time.ParseInLocation("2006/01/02 15:04:05", "2019/08/04 14:15:20", loc)
if err != nil {
 fmt.Println(err)
 return
}
fmt.Println(timeObj)
fmt.Println(timeObj.Sub(now))

本文转载自微信公众号「 程序员升级打怪之旅」，作者「王中阳Go」，可以通过以下二维码关注。

856d4c3842966d091a99323f2d1a93af84ad56.jpg

转载本文请联系「 程序员升级打怪之旅」公众号。


report

Recommend

About Joyk


Aggregate valuable and interesting links.
Joyk means Joy of geeK