关于challenge:一文详解Go-time包时间处理

6次阅读

共计 4158 个字符，预计需要花费 11 分钟才能阅读完成。

本文次要介绍应用规范库中的 time 包 进行工夫解决。疾速把握时区设置、工夫戳获取，以及工夫格式化等操作。

本地指的是程序运行所属环境（物理机或容器等）。例如本地设置的是北京工夫（Asia/Shanghai），则获取到的工夫就是东八区的工夫

func main() {fmt.Println(time.Now())
  fmt.Println(time.Now().Location())
}
输入：2023-02-19 22:52:38.217136 +0800 CST m=+0.000072078
Local

应用 os 包设置 环境变量 TZ为对应时区。留神：1. 该设置肯定要在 time 包应用之前，否则有效；2. 依赖以后零碎的时区数据库，有则能够加载一个地位失去对应的时区，无则兜底应用 UTC

func main() {os.Setenv("TZ", "Asia/Shanghai")
  fmt.Println(time.Now())
  fmt.Println(time.Now().Location())
}
输入：2023-02-19 22:54:05.885626 +0800 CST m=+0.000077761
Asia/Shanghai

依赖以后零碎的时区数据库，有则能够加载一个地位失去对应的时区，无则会返回一个 error

func main() {loc, err := time.LoadLocation("Asia/Shanghai")
  if err != nil {fmt.Println("LoadLocation error:" + err.Error())
    return
  }
  fmt.Println(time.Now().In(loc))
  fmt.Println(time.Now().In(loc).Location())
}
正确输入：2023-02-19 23:03:22.543069 +0800 CST
Asia/Shanghai

谬误输入：LoadLocation error: unknown time zone Asia/ShanghaiA

time.UTC设置为 UTC；time.Local设置为本地默认时区

func main() {fmt.Println(time.Now().In(time.UTC))
  fmt.Println(time.Now().In(time.UTC).Location())
  fmt.Println(time.Now().In(time.Local))
  fmt.Println(time.Now().In(time.Local).Location())
}
输入：2023-02-19 15:22:41.626207 +0000 UTC
UTC
2023-02-19 23:22:41.626254 +0800 CST
Local

通过 time.Now 获取以后的工夫对象，而后从工夫对象中能够获取到年、月、日、时、分、秒等信息

func main() {t := time.Now() // 获取以后工夫
  fmt.Printf("以后工夫:%v\n", t)

  year := t.Year()     // 年
  month := t.Month()   // 月
  day := t.Day()       // 日
  hour := t.Hour()     // 小时
  minute := t.Minute() // 分钟
  second := t.Second() // 秒
  fmt.Println(year, month, day, hour, minute, second)
}
输入：以后工夫:2023-02-19 23:36:46.75675 +0800 CST m=+0.000270495
2023 February 19 23 36 46

通过 time.Now 获取以后的工夫对象，而后应用工夫对象调用相干办法获取工夫戳。

留神：毫秒和微秒的办法，在 Go1.17 之后能力应用，之前的版本能够通过纳秒进行计算转换

func main() {t := time.Now()
  
  sec := t.Unix()              // 秒
  mill := t.UnixNano() / 1e6   // 毫秒
  //mill := t.UnixMilli()      // 毫秒，要求 Go1.17+
  micro := t.UnixNano() / 1e3  // 微秒
  //micro := t.UnixMicro()     // 微秒，要求 Go1.17+
  nano := t.UnixNano()         // 纳秒
  fmt.Println(sec, mill, micro, nano) 
}
输入：1676821481 1676821481283 1676821481283263 1676821481283263000

应用 time.ParseInLocation 指定时区解析指定工夫，并获取到工夫对象，而后调用相干办法获取工夫戳

func main() {t, err := time.ParseInLocation("2006-01-02 15:04:05", "2023-02-19 21:00:00", time.Local)
  if err != nil {fmt.Println("ParseInLocation error:" + err.Error())
  }
  fmt.Println(t)

  sec := t.Unix()             // 秒
  mill := t.UnixNano() / 1e6  // 毫秒
  micro := t.UnixNano() / 1e3 // 微秒
  nano := t.UnixNano()        // 纳秒
  fmt.Println(sec, mill, micro, nano)
}
输入：2023-02-19 21:00:00 +0800 CST
1676811600 1676811600000 1676811600000000 1676811600000000000

Go 语言的格式化布局规定，比拟非凡，不是应用惯例的“Y-m-d H:M:S”，而是应用“2006-01-02 15:04:05.000”

含意阐明：

2006：年（Y）
01：月（m）
02：日（d）
15：时（H）。若想示意 12 小时制则写为 03，并且前面加上 PM
04：分（M）
05：秒（S）
非凡：小数局部想保留指定位数就写 0，如果想省略开端可能的 0 就写 9

应用示例：

func main() {t := time.Now()
  //24 小时制
  fmt.Println(t.Format("2006-01-02 15:04:05"))
  //12 小时制（时占位 03 并且前面加上 PM）fmt.Println(t.Format("2006-01-02 03:04:05 PM"))

  // 小数点 0 或 9
  fmt.Println(t.Format("2006-01-02 15:04:05.000"))
  fmt.Println(t.Format("2006-01-02 15:04:05.999"))

  // 只有日期
  fmt.Println(t.Format("2006-01-02"))
  // 只有工夫
  fmt.Println(t.Format("15:04:05"))
}
输入：2023-02-20 00:48:12
2023-02-20 12:48:12 AM
2023-02-20 00:48:12.223
2023-02-20 00:48:12.223
2023-02-20
00:48:12

time.Duration代表两个工夫点之间通过的工夫，以纳秒为单位。可示意的最长时间段大概 290 年

time 包定义的工夫距离常量：

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

罕用办法：

Add：func (t Time) Add(d Duration) Time，指定工夫距离（t+d），失去一个新的工夫对象
Sub：func (t Time) Sub(u Time) Duration，求两个工夫之间的差值（t-d）

应用示例：

func main() {t := time.Now()
  t2 := t.Add(1 * time.Hour)  // 一个小时之后的工夫
  t3 := t.Add(-1 * time.Hour) // 一个小时之前的工夫
  fmt.Println(t)              //2023-02-20 01:18:00.204169 +0800 CST m=+0.000410087
  fmt.Println(t2)             //2023-02-20 02:18:00.204169 +0800 CST m=+3600.000410087
  fmt.Println(t3)             //2023-02-20 00:18:00.204169 +0800 CST m=-3599.999589913

  time.Sleep(2 * time.Second)
  fmt.Println(t.Sub(time.Now())) //-2.005207034s
  fmt.Println(time.Now().Sub(t)) //2.00532078s
}

应用 time.Tick(工夫距离) 来设置定时器，定时器的实质上是一个通道（channel）。可用于解决定时执行的工作

func timeTick() {ticker := time.Tick(time.Second) // 定义一个 1 秒距离的定时器
  for i := range ticker {fmt.Println(i) // 每秒都会执行的工作
  }
}
输入：2023-02-20 01:25:18.310543 +0800 CST m=+3.010979096
2023-02-20 01:25:19.31052 +0800 CST m=+4.010955881
2023-02-20 01:25:20.31051 +0800 CST m=+5.010945974

对时区设置、工夫戳获取，以及工夫格式化等操作，做了具体的解说。记住所有的操作，都得基于工夫对象，来开展的，工夫对象是工夫解决的基石。

如果本文对你有帮忙，欢送点赞珍藏加关注，如果本文有谬误的中央，欢送指出！

本文参加了 SegmentFault 思否写作挑战赛，欢送正在浏览的你也退出。

正文完

challenge

发表至： challenge

2023-02-27

0

关于challenge:CUDA入门学习笔记

关于challenge:从零开始的知识图谱生活构建一个百科知识图谱基于ES的简单语义搜索

关于challenge:深度学习基础入门篇七常用归一化算法层次归一化算法归一化和标准化区别于联系应用案例场景分析

关于challenge:深度学习基础入门篇四激活函数介绍tanhsigmoidReLUPReLUELUsoftplus等

关于ruby-on-rails:IO阻塞和非阻塞同步和异步

关于challenge:一文详解Go-time包时间处理

前言

时区设置

1. 默认应用本地时区

2. 应用 os.Setenv()设置时区

3. 应用 time.LoadLocation()设置时区

4. 应用内置的 time.UTC 和 time.Local 疾速切换时区

获取以后工夫信息

获取工夫戳

1. 以后工夫的工夫戳

2. 指定工夫的工夫戳

工夫格式化

工夫距离

定时器

总结

站内搜索