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

前言

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

时区设置

1. 默认应用本地时区

本地指的是程序运行所属环境（物理机或容器等）。例如本地设置的是北京工夫（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

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

应用 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

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

依赖以后零碎的时区数据库，有则能够加载一个地位失去对应的时区，无则会返回一个 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

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

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

获取工夫戳

1. 以后工夫的工夫戳

通过 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

2. 指定工夫的工夫戳

应用 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 思否写作挑战赛，欢送正在浏览的你也退出。