在编程中,我们经常会遭遇八小时时间差问题。这是由时区差异引起的,为了能更好地解决它们,我们需要理解几个时间定义标准。

GMT(Greenwich Mean Time),格林威治平时。GMT 根据地球的自转和公转来计算时间,它规定太阳每天经过位于英国伦敦郊区的皇家格林威治天文台的时间为中午12点。GMT 是前世界标准时。

UTC(Coordinated Universal Time),协调世界时。UTC 比 GMT 更精准,它根据原子钟来计算时间。在不需要精确到秒的情况下,可以认为 UTC=GMT。UTC 是现世界标准时。

从格林威治本初子午线起,往东为正,往西为负,全球共划分为 24 个标准时区,相邻时区相差一个小时。

package main

import (
 "fmt"
 "time"
)

func main() {
 fmt.Println(time.Now())
}

中国大陆使用的是东八时区的标准时,即北京时间 CST,China Standard Time。

$ go run main.go 
2022-07-17 16:37:31.186043 +0800 CST m=+0.000066647

这是默认时区下的结果,time.Now()的打印中会标注+0800 CST

假设我们是在美国洛杉矶时区下,那得到的结果是什么呢?

$ TZ="America/Los_Angeles" go run main.go
2022-07-17 01:39:12.391505 -0700 PDT m=+0.000069514

可以看到,此时的结果是-0700 PDT 时间,即 PDT(Pacific Daylight Time)太平洋夏季时间。由于时区差异,两次执行的时间结果相差了 15 小时。

注意,在使用 Docker 容器时,系统默认的时区就是 UTC 时间(0 时区),和我们实际需要的北京时间相差八个小时,这是导致八小时时间差问题的经典场景。

时区问题的应对策略,可以详细查看 src/time/zoneinfo_unix.go 中 initLocal() 函数的加载逻辑。例如,可以通过指定环境变量 TZ,修改/etc/localtime文件等方式来解决。

因为时区问题非常重要,所以放在了文章第一部分讲述。下面开始介绍 time 库的使用。

时间瞬间 time.Time

time 库,最核心的对象是 time.Time 结构体。它的定义如下,用以表示某个瞬间的时间。

type Time struct {
  // wall and ext encode the wall time seconds, wall time nanoseconds,
 // and optional monotonic clock reading in nanoseconds.
   wall uint64
   ext  int64
   loc *Location
}

计算机在时间处理上,主要涉及到两种时钟。

  • 墙上时钟(wall time),又称为钟表时间,用于表示具体的日期与时间。

  • 单调时钟(monotonic clocks),总是保证时间是向前的,不会出现墙上时钟的回拨问题,因此它很适合用于测量持续时间段。

wall 和 ext 字段就是用于记录墙上时钟和单调时钟,精度为纳秒。字段的对应位数上关联着用于确定时间的具体年、月、日、小时、分钟、秒等信息。

loc 字段记录时区位置,当 loc 为 nil 时,默认为 UTC 时间。

因为 time.Time 用于表示具有纳秒精度的时间瞬间,在程序中通常应该将它作为值存储和传递,而不是指针。

即在时间变量或者结构体字段中,我们应该使用 time.Time,而非 *time.Time。

获取 time.Time

我们可以通过 Now 函数获取当前本地时间

func Now() Time {}

也可以通过 Date 函数,根据年、月、日等时间和时区参数获取指定时间

func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time {}
转换时间戳

计算机世界中,将 UTC 时间 1970 年1月1日 0 时 0 分 0 秒作为 Unix 时间 0。所谓的时间瞬间转换为 Unix 时间戳,即计算的是从 Unix 时间 0 到指定瞬间所经过的秒数、微秒数等。

func (t Time) Unix() int64 {}      // 从 Unix 时间 0 经过的秒数
func (t Time) UnixMicro() int64 {} // 从 Unix 时间 0 经过的微秒数
func (t Time) UnixMilli() int64 {} // 从 Unix 时间 0 经过的毫秒数
func (t Time) UnixNano() int64 {}  // 从 Unix 时间 0 经过的纳秒数
获取基本字段
 t := time.Now()
 fmt.Println(t.Date())      // 2022 July 17
 fmt.Println(t.Year())      // 2022
 fmt.Println(t.Month())     // July
 fmt.Println(t.ISOWeek())   // 2022 28
 fmt.Println(t.Clock())     // 22 21 56
 fmt.Println(t.Day())       // 17
 fmt.Println(t.Weekday())   // Sunday
 fmt.Println(t.Hour())      // 22
 fmt.Println(t.Minute())    // 21
 fmt.Println(t.Second())    // 56
 fmt.Println(t.Nanosecond())// 494313000
 fmt.Println(t.YearDay())   // 198

持续时间 time.Duration

持续时间 time.Duration 用于表示两个时间瞬间 time.Time 之间所经过的时间。它通过 int64 表示纳秒计数,能表示的极限大约为 290 年。

// A Duration represents the elapsed time between two instants
// as an int64 nanosecond count. The representation limits the
// largest representable duration to approximately 290 years.
type Duration int64

在 Go 中,持续时间只是一个以纳秒为单位的数字而已。如果持续时间等于 1000000000,则它代表的含义是 1 秒或 1000 毫秒或 1000000 微秒或 1000000000 纳秒。

例如,相隔 1 小时的两个时间瞬间 time.Time 值,它们之间的持续时间 time.Duration 值为

1*60*60*1000*1000*1000

Go 的 time 包中定义了这些持续时间常量值

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

同时,time.Duration 提供了能获取各时间粒度数值的方法

func (d Duration) Nanoseconds() int64 {}   // 纳秒
func (d Duration) Microseconds() int64 {}  // 微秒
func (d Duration) Milliseconds() int64 {}  // 毫秒
func (d Duration) Seconds() float64 {}     // 秒
func (d Duration) Minutes() float64 {}     // 分钟
func (d Duration) Hours() float64 {}       // 小时

时间计算

在学习了时间瞬间和持续时间之后,我们来看如何做时间计算。

func (t Time) Add(d Duration) Time {}
  • Add 函数用于增加/减少( d 的正值表示增加、负值表示减少) time.Time 的持续时间。我们可以对某瞬时时间,增加或减少指定纳秒级以上的时间。
func (t Time) Sub(u Time) Duration {}
  • Sub  函数可以得出两个时间瞬间之间的持续时间。
func (t Time) AddDate(years int, months int, days int) Time {}
  • AddDate 函数基于年、月和日的维度增加/减少 time.Time 的值。

当然,基于当前时间瞬间 time.Now() 的计算是最普遍的需求。因此,time 包还提供了以下便捷的时间计算函数。

func Since(t Time) Duration {}

Since 函数是 time.Now().Sub(t) 的快捷方法。

func Until(t Time) Duration {}

Until 函数是 t.Sub(time.Now()) 的快捷方法。

使用示例
 t := time.Now()
 fmt.Println(t)                      // 2022-07-17 22:41:06.001567 +0800 CST m=+0.000057466

 //时间增加 1小时
 fmt.Println(t.Add(time.Hour * 1))   // 2022-07-17 23:41:06.001567 +0800 CST m=+3600.000057466
 //时间增加 15 分钟
 fmt.Println(t.Add(time.Minute * 15))// 2022-07-17 22:56:06.001567 +0800 CST m=+900.000057466
 //时间增加 10 秒钟
 fmt.Println(t.Add(time.Second * 10))// 2022-07-17 22:41:16.001567 +0800 CST m=+10.000057466

 //时间减少 1 小时
 fmt.Println(t.Add(-time.Hour * 1))  // 2022-07-17 21:41:06.001567 +0800 CST m=-3599.999942534
 //时间减少 15 分钟
 fmt.Println(t.Add(-time.Minute * 15))// 2022-07-17 22:26:06.001567 +0800 CST m=-899.999942534
 //时间减少 10 秒钟
 fmt.Println(t.Add(-time.Second * 10))// 2022-07-17 22:40:56.001567 +0800 CST m=-9.999942534

 time.Sleep(time.Second * 5)
 t2 := time.Now()
 // 计算 t 到 t2 的持续时间
 fmt.Println(t2.Sub(t))              // 5.004318874s
 // 1 年之后的时间
 t3 := t2.AddDate(1, 0, 0)
 // 计算从 t 到当前的持续时间
 fmt.Println(time.Since(t))          // 5.004442316s
 // 计算现在到明年的持续时间
 fmt.Println(time.Until(t3))         // 8759h59m59.999864s

格式化时间

在其他语言中,一般会使用通用的时间模板来格式化时间。例如 Python,它使用 %Y 代表年、%m 代表月、%d 代表日等。

但是,Go 不一样,它使用固定的时间(需要注意,使用其他的时间是不可以的)作为布局模板,而这个固定时间是 Go 语言的诞生时间。

Mon Jan 2 15:04:05 MST 2006

格式化时间涉及到两个转换函数

func Parse(layout, value string) (Time, error) {}
  • Parse 函数用于将时间字符串根据它所能对应的布局转换为 time.Time 对象。
func (t Time) Format(layout string) string {}
  • Formate 函数用于将 time.Time 对象根据给定的布局转换为时间字符串。
示例
const (
   layoutISO = "2006-01-02"
   layoutUS  = "January 2, 2006"
)
date := "2012-08-09"
t, _ := time.Parse(layoutISO, date)
fmt.Println(t)                  // 2012-08-09 00:00:00 +0000 UTC
fmt.Println(t.Format(layoutUS)) // August 9, 2012

在 time 库中,Go 提供了一些预定义的布局模板常量,这些可以直接拿来使用。

const (
 Layout      = "01/02 03:04:05PM '06 -0700" // The reference time, in numerical order.
 ANSIC       = "Mon Jan _2 15:04:05 2006"
 UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
 RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
 RFC822      = "02 Jan 06 15:04 MST"
 RFC822Z     = "02 Jan 06 15:04 -0700" // RFC822 with numeric zone
 RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
 RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
 RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" // RFC1123 with numeric zone
 RFC3339     = "2006-01-02T15:04:05Z07:00"
 RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
 Kitchen     = "3:04PM"
 // Handy time stamps.
 Stamp      = "Jan _2 15:04:05"
 StampMilli = "Jan _2 15:04:05.000"
 StampMicro = "Jan _2 15:04:05.000000"
 StampNano  = "Jan _2 15:04:05.000000000"
)

下面是我们可选的布局参数对照表

年         06/2006
月         01/1/Jan/January
日         02/2/_2
星期       Mon/Monday
小时       03/3/15
分         04/4
秒         05/5
毫秒       .000/.999
微秒       .000000/.999999
纳秒       .000000000/.999999999
am/pm     PM/pm
时区       MST
时区小时数差-0700/-07/-07:00/Z0700/Z07:00

时区转换

在文章开头,我们介绍了时区问题。如果在代码中,需要获取同一个 time.Time 在不同时区下的结果,我们可以使用它的 In 方法。

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

它的使用非常简单,直接看示例代码

now := time.Now()
fmt.Println(now)          // 2022-07-18 21:19:59.9636 +0800 CST m=+0.000069242

loc, _ := time.LoadLocation("UTC")
fmt.Println(now.In(loc)) // 2022-07-18 13:19:59.9636 +0000 UTC

loc, _ = time.LoadLocation("Europe/Berlin")
fmt.Println(now.In(loc)) // 2022-07-18 15:19:59.9636 +0200 CEST

loc, _ = time.LoadLocation("America/New_York")
fmt.Println(now.In(loc)) // 2022-07-18 09:19:59.9636 -0400 EDT

loc, _ = time.LoadLocation("Asia/Dubai")
fmt.Println(now.In(loc)) // 2022-07-18 17:19:59.9636 +0400 +04

总结常用time包下的方法

1)获取前一天的时间

package main

import "time"

nowTime := time.Now()
yesterdayTime := nowTime.AddDate(0,0,-1); // 年,月,日 获取前一天时间
resTime := yesterdayTime.Format('2006-01-02 15:04:05') getTime = nowTime.AddDate(0, -1, 0) //年,月,日 获取一个月前的时间
resTime = getTime.Format("2006-01-02 15:04:05") //获取的时间的格式
fmt.Println(resTime) getTime = nowTime.AddDate(-2, 0, 0) //年,月,日 获取两年前的时间
resTime = getTime.Format("20060102") //获取的时间的格式
fmt.Println(resTime)

判断当前时间是否在某个时间之前:

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 为否。

golang之Time时间函数的更多相关文章

  1. go日期时间函数+常用内建函数+错误处理

    日期时间函数 // 时间日期函数包 import "time" // 1. 当前时间 time.Now()-->time.Time类型 // 2. now:=time.Now ...

  2. C++中的时间函数

    C++获取时间函数众多,何时该用什么函数,拿到的是什么时间?该怎么用?很多人都会混淆. 本文是本人经历了几款游戏客户端和服务器开发后,对游戏中时间获取的一点总结. 最早学习游戏客户端时,为了获取最精确 ...

  3. 借助JavaScript中的时间函数改变Html中Table边框的颜色

    借助JavaScript中的时间函数改变Html中Table边框的颜色 <html> <head> <meta http-equiv="Content-Type ...

  4. Loadrunner时间函数、用时间生成订单编号例子

    Loadrunner中取时间函数.用时间函数生成订单编号例子: <如要转载,请注明网络来源及作者:Cheers_Lee> 问题的提出: (1)有时候在Loadrunner中用C语言设计脚本 ...

  5. Sql Server函数全解(四)日期和时间函数

      日期和时间函数主要用来处理日期和时间值,本篇主要介绍各种日期和时间函数的功能和用法,一般的日期函数除了使用date类型的参数外,也可以使用datetime类型的参数,但会忽略这些值的时间部分.相同 ...

  6. Oracle内置函数:时间函数,转换函数,字符串函数,数值函数,替换函数

    dual单行单列的隐藏表,看不见 但是可以用,经常用来调内置函数.不用新建表 时间函数 sysdate 系统当前时间 add_months 作用:对日期的月份进行加减 写法:add_months(日期 ...

  7. mysql与oracle的日期/时间函数小结

    前言 本文的日期/时间全部格式化为”2016-01-01 01:01:01“形式: MONITOR_TIME为数据库表字段: 字符串与日期/时间相互转换函数 Oracle 日期/时间转字符串函数:to ...

  8. C库函数使用与总结之时间函数

    1. localtime(取得当地目前时间和日期) [头文件]#include <time.h> [函数原型]struct tm *localtime(const time_t * tim ...

  9. 分享一些关于PHP时间函数的常用时间

    <?php // 各种时间函数 echo "现在:".date("Y-m-d H:i:s")."<br>"; echo & ...

  10. MySQL数据库9 - 日期与时间函数

    一 日期和时间函数 函数的概念:按指定格式输入参数,返回正确结果的运算单元 1. 返回当前日期:curdate() current_date() current_date()+0可以将当前日期转换为数 ...

随机推荐

  1. electron修改vue项目打包后的exe图标

    vue用electron打包点击这里 安装electron-icon-builder 添加图标生成器:npm i electron-icon-builder 生成图标 1.在package.json的 ...

  2. Coze插件发布!PDF转Markdown功能便捷集成,打造你的专属智能体

    近日,TextIn开发的PDF转Markdown插件正式上架Coze平台. 在扣子搜索"pdf转markdown",或在Coze平台搜索"pdf2markdown&quo ...

  3. ChatGPT转发工具-springboot

    背景 国内服务器无法访问openAI接口,我想过有两种实现方式 代理工具类似 tinyproxy.nginx 开发一个转发客户端(java.python都可以实现),提供一个api接口 源码 gith ...

  4. GZY.Quartz.MUI(基于Quartz的UI可视化操作组件) 2.7.0发布 新增各项优化与BUG修复

    前言 时隔大半年,终于抽出空来可以更新这个组件了 (边缘化了,大概要被裁员了) 2.7.0终于发布了~ 更新内容: 1.添加API类任务的超时时间,可以通过全局配置也可以单个任务设置 2.设置定时任务 ...

  5. 基于Keras-YOLO实现目标检测

    Keras-YOLO 3项目使用Python语言实现了YOLO v3网络模型,并且可以导入Darknet网络预先训练好的权重文件信息直接使用网络进行目标识别. 1. 下载Keras-YOLO 3项目 ...

  6. USB协议详解第10讲(USB描述符-报告描述符)

    1.报告描述符的概念和作用 开门见山,报告描述符就是描述报告(HID接口上传输事务中的数据)的一组数据结构. 首先大家可能会问,报告又是什么?我们前面讲过,USB主机一般是以中断的方式向HID设备发送 ...

  7. Android 扫码枪输入时屏蔽软键盘和顶部状态栏

    这是个扫码枪回车输入扫码内容的界面,常用于收银收款等场景 前期踩了很多坑,网上的资料也因为 Android 历史版本不同有各种兼容问题,最后总结了下 在无霸屏设置的 android 设备上使用如下方案 ...

  8. HN CSP-J 2023 奇人鉴赏

    其中有 4 位同学提到了IOI 一位同学提到了 fk,但是并没有 Fk CCF 共有52个 CCF,其中HN-J00157同学复制了很多遍题目一位同学用了ccf当 struct 名字,并且写出了人名函 ...

  9. WPF中为Popup和ToolTip使用WindowMaterial特效 win10/win11

    先看效果图: 大致思路是:通过反射获取Popup内部的原生窗口句柄,然后通过前文已经实现的WindowMaterial类来应用窗口特效:对于ToolTip,为了保持其易用性,我使用了附加属性+全局样式 ...

  10. 云原生周刊:Helm Charts 深入探究 | 2024.3.11

    开源项目推荐 Glasskube Glasskube 提供了一个用于 Kubernetes 的缺失的包管理器.它具有图形用户界面(GUI)和命令行界面(CLI).Glasskube 包是具备依赖感知. ...