02GO进阶004 time包

## 一、time.Time 类型与当前时间获取
time.Time 是 Go 中表示时间的核心类型，它封装了一个时间点的年、月、日、时、分、秒、纳秒等信息。

### 1.1 获取当前时间
要获取当前时间，我们可以使用` time.Now() 函数`，该函数返回一个 `time.Time` 类型的对象，表示当前系统时间。

```go
package main

import (
	"fmt"
	"time"
)

func main() {
	currentTime := time.Now()
	fmt.Println("当前时间:", currentTime)
}
```

这个例子会输出当前时间，包括日期、时间和时区：
> 当前时间: 2024-10-11 14:45:02.123456789 +0800 CST m=+0.000000001

### 1.2 time.Time 类型的组件
`time.Time `对象内部包含了许多时间组件，你可以通过调用特定的方法来获取它们：
```go
fmt.Println("年:", currentTime.Year())
fmt.Println("月:", currentTime.Month())
fmt.Println("日:", currentTime.Day())
fmt.Println("小时:", currentTime.Hour())
fmt.Println("分钟:", currentTime.Minute())
fmt.Println("秒:", currentTime.Second())
fmt.Println("纳秒:", currentTime.Nanosecond())
fmt.Println("星期几:", currentTime.Weekday())
```
这些方法分别返回当前时间的年、月、日、小时等信息。例如：
```
年: 2024
月: October
日: 11
小时: 14
分钟: 45
秒: 2
纳秒: 123456789
星期几: Friday
```
### 1.3 UNIX 时间戳
`time.Time `可以通过 `Unix()` 和 `UnixNano() `方法转换为 UNIX 时间戳。UNIX 时间戳表示自 1970 年 1 月 1 日 00:00:00 UTC 以来的秒数或纳秒数。

```go
fmt.Println("Unix 时间戳（秒）:", currentTime.Unix())
fmt.Println("Unix 时间戳（纳秒）:", currentTime.UnixNano())

```
## 二、时间格式化与解析
在实际开发中，我们经常需要将时间以特定的格式转换为字符串，或者将字符串解析为 `time.Time` 对象。Go 语言的 `time` 包使用一组固定的时间布局来完成这些操作。

### 2.1 时间格式化
在 Go 中，时间格式化通过 `Format()` 方法实现。`time` 包使用的是一种独特的布局字符串，而不是常见的 `YYYY-MM-DD` 之类的占位符。

Go 使用日期`2006-01-02 15:04:05` 作为参考时间，按照该布局中的特定数字代表时间组件：
`2006`：年份
`01`：月份
`02`：日期
`15`：小时（24 小时制）
`04`：分钟
`05`：秒
例如：

```go
formattedTime := currentTime.Format("2006-01-02 15:04:05")
fmt.Println("格式化后的时间:", formattedTime)
```

#### 常见时间格式化布局
你可以根据自己的需求定义不同的时间格式：
`2006-01-02`：标准日期格式（年-月-日）
`15:04:05`：24 小时制的时间格式
`03:04:05 PM`：12 小时制的时间格式，带 AM/PM 标志
```go
fmt.Println(currentTime.Format("2006-01-02"))         // 2024-10-11
fmt.Println(currentTime.Format("15:04:05"))           // 14:45:02
fmt.Println(currentTime.Format("03:04:05 PM"))        // 02:45:02 PM
```
### 2.2 时间解析
`time.Parse()` 方法可以将一个字符串解析为 `time.Time` 对象，解析时你需要提供相应的布局字符串来匹配时间格式。

```go
timeStr := "2024-10-11 14:45:02"
parsedTime, err := time.Parse("2006-01-02 15:04:05", timeStr)
if err != nil {
    fmt.Println("解析时间出错:", err)
} else {
    fmt.Println("解析后的时间:", parsedTime)
}
```
输出结果为解析后的 time.Time 对象：
> 解析后的时间: 2024-10-11 14:45:02 +0000 UTC

## 三、时间间隔与时间操作
在 Go 语言中，`time.Duration` 用于表示两个时间点之间的时间间隔。`Duration` 的单位是纳秒，可以用来表示从纳秒到小时之间的时间段。

### 3.1 时间间隔的计算
通过 `time.Since()` 可以计算某个时间点距离当前的时间间隔，返回的是一个 `time.Duration` 对象。
```go
startTime := time.Now()
time.Sleep(2 * time.Second) // 模拟耗时操作
elapsed := time.Since(startTime)
fmt.Println("操作耗时:", elapsed)
```
输出的结果类似：
> 操作耗时: 2s

### 3.2 时间加减操作
可以通过 `Add()` 方法对时间进行加减操作，例如加上或减去一定的时间间隔。
```go
nextWeek := currentTime.Add(7 * 24 * time.Hour)
fmt.Println("一周后的时间:", nextWeek)

yesterday := currentTime.Add(-24 * time.Hour)
fmt.Println("昨天的时间:", yesterday)

```

### 3.3 时间差计算
通过 Sub() 方法，可以计算两个时间点之间的时间差。
```go
startTime := time.Date(2024, 10, 1, 9, 0, 0, 0, time.Local)
duration := currentTime.Sub(startTime)
fmt.Println("时间差:", duration)

```
该方法返回两个 `time.Time` 对象之间的 `Duration`，可以进一步转换为天数、小时数等。
```go
fmt.Println("时间差（小时）:", duration.Hours())
fmt.Println("时间差（分钟）:", duration.Minutes())
fmt.Println("时间差（秒）:", duration.Seconds())
fmt.Println("时间差（纳秒）:", duration.Nanoseconds())

```
## 四、定时器与超时处理
time 包提供了两种常用的定时功能：`Ticker` 和 `Timer`。

### 4.1 `time.Sleep`：延时执行
最简单的定时操作是 time.Sleep()，它会让当前 goroutine 暂停指定的时间。

```go
fmt.Println("延时 3 秒执行")
time.Sleep(3 * time.Second)
fmt.Println("延时结束")

```
### 4.2 `time.After`：延时后触发
time.After() 返回一个通道，指定时间之后会向该通道发送当前时间。常用于超时控制。

```go
select {
case <-time.After(2 * time.Second):
    fmt.Println("2 秒后执行")
}
```

### 4.3 `time.Ticker`：周期性触发
Ticker 是一种定时器，它会按照指定的时间间隔周期性地触发事件。Ticker 通过 NewTicker() 创建，返回一个通道，通道会定期发送时间信号。

```go
ticker := time.NewTicker(1 * time.Second)
go func() {
    for t := range ticker.C {
        fmt.Println("每秒触发一次，当前时间:", t)
    }
}()
time.Sleep(5 * time.Second)
ticker.Stop()
fmt.Println("Ticker 已停止")

```
### 4.4 `time.Timer`：一次性定时器
Timer 是一种一次性触发的定时器，指定时间后触发一次。

```go
timer := time.NewTimer(3 * time.Second)
fmt.Println("等待 3 秒")
<-timer.C
fmt.Println("Timer 触发")

```

## 五、时区与时间转换
time 包支持不同的时区处理，通过 `time.LoadLocation()` 可以加载不同的时区，并将时间转换为该时区的时间。

```go
loc, _ := time.LoadLocation("America/New_York")
nyTime := currentTime.In(loc)
fmt.Println("纽约时间:", nyTime)

```

## 六、time包的其他常用功能
### 6.1 随机时间生成
通过随机生成时间，可以模拟一些时间上的变化。

```go
import "math/rand"

randomDuration := time.Duration(rand.Intn(1000)) * time.Millisecond
randomTime := currentTime.Add(randomDuration)
fmt.Println("随机时间:", randomTime)

```

### 6.2 测量代码执行时间
通过记录操作开始和结束时间，可以很方便地计算代码执行时间。
```go
start := time.Now()
// 执行一些代码
elapsed := time.Since(start)
fmt.Println("代码执行时间:", elapsed)
```

通过上面的内容，详细介绍了 Go 语言中的 time 包常见的用法以及对应的实例。time 包不仅仅可以处理时间的获取、格式化、解析，还涉及时间的加减、间隔计算、定时器等功能。希望通过这些详细的讲解，能够帮助大家在开发中更好地应用 time 包，轻松应对时间处理相关的场景。