2025/3/19

2025-03-19 14:36:09 +08:00
commit abb37c49a7
18 changed files with 2005 additions and 0 deletions
--- a/技术/Go/常用包/fmt.md
+++ b/技术/Go/常用包/fmt.md
@@ -0,0 +1,142 @@
+在 Go 语言中，`fmt` 包是用于格式化输入和输出的核心工具包，提供了许多常用的函数来处理标准输入、输出以及字符串的格式化操作。以下是一些常用的 `fmt` 包函数及其使用方法：
+
+---
+
+### **1. 格式化输出**
+- **`Print(a ...interface{}) (n int, err error)`**  
+  将参数直接输出到标准输出（通常是终端），非字符串参数之间会添加空格，但不会自动换行。  
+  示例：
+  ```go
+  fmt.Print("Hello", "World") // 输出: HelloWorld
+  fmt.Print("Hello", " ", "World") // 输出: Hello World
+  ```
+  
+
+- **`Printf(format string, a ...interface{}) (n int, err error)`**  
+  根据格式化字符串 `format` 输出内容，支持丰富的格式化占位符（如 `%d`、`%s` 等）。  
+  示例：
+  ```go
+  name := "Alice"
+  age := 30
+  fmt.Printf("Name: %s, Age: %d\n", name, age) // 输出: Name: Alice, Age: 30
+  ```
+  
+
+- **`Println(a ...interface{}) (n int, err error)`**  
+  类似于 `Print`，但在输出末尾自动添加换行符，并且每个参数之间会自动加空格。  
+  示例：
+  ```go
+  fmt.Println("Hello", "World") // 输出: Hello World
+  ```
+
+---
+
+### **2. 格式化生成字符串**
+- **`Sprint(a ...interface{}) string`**  
+  返回格式化后的字符串，但不直接输出到标准输出。  
+  示例：
+  ```go
+  str := fmt.Sprint("Hello", " ", "World")
+  fmt.Println(str) // 输出: Hello World
+  ```
+
+- **`Sprintf(format string, a ...interface{}) string`**  
+  根据格式化字符串生成一个新的字符串，但不直接输出到标准输出。  
+  示例：
+  ```go
+  name := "Bob"
+  age := 25
+  str := fmt.Sprintf("Name: %s, Age: %d", name, age)
+  fmt.Println(str) // 输出: Name: Bob, Age: 25
+  ```
+
+- **`Sprintln(a ...interface{}) string`**  
+  类似于 `Sprint`，但会在末尾添加换行符。  
+  示例：
+  ```go
+  str := fmt.Sprintln("Hello", "World")
+  fmt.Print(str) // 输出: Hello World
+  ```
+
+---
+
+### **3. 格式化写入文件或缓冲区**
+- **`Fprint(w io.Writer, a ...interface{}) (n int, err error)`**  
+  将参数写入到指定的 `io.Writer`（如文件或缓冲区）。  
+  示例：
+  ```go
+  var buf bytes.Buffer
+  fmt.Fprint(&buf, "Hello", " ", "World")
+  fmt.Println(buf.String()) // 输出: Hello World
+  ```
+
+- **`Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error)`**  
+  根据格式化字符串将内容写入到指定的 `io.Writer`。  
+  示例：
+  ```go
+  var buf bytes.Buffer
+  fmt.Fprintf(&buf, "Name: %s, Age: %d", "Alice", 30)
+  fmt.Println(buf.String()) // 输出: Name: Alice, Age: 30
+  ```
+
+- **`Fprintln(w io.Writer, a ...interface{}) (n int, err error)`**  
+  类似于 `Fprint`，但在末尾添加换行符。  
+  示例：
+  ```go
+  var buf bytes.Buffer
+  fmt.Fprintln(&buf, "Hello", "World")
+  fmt.Println(buf.String()) // 输出: Hello World
+  ```
+
+---
+
+### **4. 格式化输入**
+- **`Scan(a ...interface{}) (n int, err error)`**  
+  从标准输入读取数据并存储到变量中，按空格分隔输入值。  
+  示例：
+  ```go
+  var name string
+  var age int
+  fmt.Print("请输入姓名和年龄：")
+  fmt.Scan(&name, &age)
+  fmt.Printf("姓名：%s，年龄：%d\n", name, age)
+  ```
+
+- **`Scanf(format string, a ...interface{}) (n int, err error)`**  
+  根据格式化字符串从标准输入读取数据。  
+  示例：
+  ```go
+  var name string
+  var age int
+  fmt.Print("请输入姓名和年龄（格式：姓名 年龄）：")
+  fmt.Scanf("%s %d", &name, &age)
+  fmt.Printf("姓名：%s，年龄：%d\n", name, age)
+  ```
+
+- **`Scanln(a ...interface{}) (n int, err error)`**  
+  类似于 `Scan`，但会以换行符结束输入。  
+  示例：
+  ```go
+  var name string
+  var age int
+  fmt.Print("请输入姓名和年龄：")
+  fmt.Scanln(&name, &age)
+  fmt.Printf("姓名：%s，年龄：%d\n", name, age)
+  ```
+
+---
+
+### **5. 常用格式化占位符**
+`fmt` 包中的格式化字符串支持多种占位符，以下是一些常用示例：
+- **`%v`**：打印值的默认格式。
+- **`%T`**：打印值的类型。
+- **`%d`**：打印整数（十进制）。
+- **`%f`**：打印浮点数。
+- **`%s`**：打印字符串。
+- **`%t`**：打印布尔值（`true` 或 `false`）。
+- **`%p`**：打印指针地址。
+
+示例：
+```go
+fmt.Printf("Value: %v, Type: %T\n", 42, 42) // 输出: Value: 42, Type: int
+```
--- a/技术/Go/常用包/sort.md
+++ b/技术/Go/常用包/sort.md
@@ -0,0 +1,149 @@
+在 Go 语言中，`sort` 包提供了用于对切片和用户自定义数据集进行排序的功能。以下是一些常用的 `sort` 包函数及其使用方法：
+
+---
+
+### **1. 基本类型切片排序**
+- **`Ints(a []int)`**  
+  对整数切片进行升序排序。  
+  示例：
+  ```go
+  nums := []int{3, 1, 4, 2}
+  sort.Ints(nums)
+  fmt.Println(nums) // 输出: [1 2 3 4]
+  ```
+
+- **`Float64s(a []float64)`**  
+  对浮点数切片进行升序排序。  
+  示例：
+  ```go
+  nums := []float64{3.5, 1.2, 4.8, 2.1}
+  sort.Float64s(nums)
+  fmt.Println(nums) // 输出: [1.2 2.1 3.5 4.8]
+  ```
+
+- **`Strings(a []string)`**  
+  对字符串切片进行升序排序（按字典顺序）。  
+  示例：
+  ```go
+  strs := []string{"banana", "apple", "cherry"}
+  sort.Strings(strs)
+  fmt.Println(strs) // 输出: [apple banana cherry]
+  ```
+
+---
+
+### **2. 判断是否已排序**
+- **`IntsAreSorted(a []int) bool`**  
+  判断整数切片是否已经按升序排序。  
+  示例：
+  ```go
+  nums := []int{1, 2, 3, 4}
+  result := sort.IntsAreSorted(nums)
+  fmt.Println(result) // 输出: true
+  ```
+
+- **`Float64sAreSorted(a []float64) bool`**  
+  判断浮点数切片是否已经按升序排序。
+
+- **`StringsAreSorted(a []string) bool`**  
+  判断字符串切片是否已经按字典顺序排序。
+
+---
+
+### **3. 自定义排序**
+对于自定义结构体或复杂数据类型的排序，需要实现 `sort.Interface` 接口，该接口包含以下三个方法：
+- **`Len() int`**：返回集合的长度。
+- **`Less(i, j int) bool`**：定义排序规则，通常是比较索引 `i` 和 `j` 的元素。
+- **`Swap(i, j int)`**：交换索引 `i` 和 `j` 的元素。
+
+示例：
+```go
+package main
+
+import (
+	"fmt"
+	"sort"
+)
+
+type Person struct {
+	Name string
+	Age  int
+}
+
+type ByAge []Person
+
+func (a ByAge) Len() int           { return len(a) }
+func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }
+func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+
+func main() {
+	people := []Person{
+		{"Alice", 30},
+		{"Bob", 25},
+		{"Charlie", 35},
+	}
+	sort.Sort(ByAge(people))
+	fmt.Println(people) // 输出: [{Bob 25} {Alice 30} {Charlie 35}]
+}
+```
+
+
+---
+
+### **4. 稳定排序**
+- **`Stable(data Interface)`**  
+  使用稳定的排序算法对数据进行排序。稳定排序保证相等元素的相对顺序不变。  
+  示例：
+  ```go
+  people := []Person{
+      {"Alice", 30},
+      {"Bob", 30},
+      {"Charlie", 25},
+  }
+  sort.Stable(ByAge(people))
+  fmt.Println(people) // 输出: [{Charlie 25} {Alice 30} {Bob 30}]
+  ```
+
+---
+
+### **5. 查找操作**
+- **`SearchInts(a []int, x int) int`**  
+  在已排序的整数切片中查找值 `x`，返回其索引。如果未找到，则返回应该插入的位置以保持排序。  
+  示例：
+  ```go
+  nums := []int{1, 3, 5, 7}
+  index := sort.SearchInts(nums, 4)
+  fmt.Println(index) // 输出: 2
+  ```
+
+- **`SearchStrings(a []string, x string) int`**  
+  在已排序的字符串切片中查找值 `x`。
+
+- **`SearchFloat64s(a []float64, x float64) int`**  
+  在已排序的浮点数切片中查找值 `x`。
+
+---
+
+### **6. 自定义切片排序**
+- **`Slice(slice interface{}, less func(i, j int) bool)`**  
+  对任意类型的切片进行排序，通过传入一个比较函数 `less` 来定义排序规则。  
+  示例：
+  ```go
+  nums := []int{3, 1, 4, 2}
+  sort.Slice(nums, func(i, j int) bool {
+      return nums[i] > nums[j] // 按降序排序
+  })
+  fmt.Println(nums) // 输出: [4 3 2 1]
+  ```
+
+---
+
+### **7. 其他功能**
+- **`Reverse(data Interface)`**  
+  对已排序的数据进行逆序排列。  
+  示例：
+  ```go
+  nums := []int{1, 2, 3, 4}
+  sort.Sort(sort.Reverse(sort.IntSlice(nums)))
+  fmt.Println(nums) // 输出: [4 3 2 1]
+  ```
--- a/技术/Go/常用包/strconv.md
+++ b/技术/Go/常用包/strconv.md
@@ -0,0 +1,129 @@
+
+在 Go 语言中，`strconv` 包提供了许多用于基本数据类型和字符串之间相互转换的函数。以下是一些常用的函数及其功能：
+
+### **1. 字符串与整数之间的转换**
+- **`Atoi(s string) (int, error)`**  
+  将字符串转换为整数（十进制）。如果转换失败，会返回错误。  
+  示例：
+  ```go
+  num, err := strconv.Atoi("123")
+  if err != nil {
+      fmt.Println("转换错误:", err)
+  } else {
+      fmt.Println("转换结果:", num) // 输出: 转换结果: 123
+  }
+  ```
+  
+
+- **`Itoa(i int) string`**  
+  将整数转换为字符串。  
+  示例：
+  ```go
+  str := strconv.Itoa(123)
+  fmt.Println("转换结果:", str) // 输出: 转换结果: "123"
+  ```
+  
+
+- **`ParseInt(s string, base int, bitSize int) (i int64, err error)`**  
+  将字符串按指定进制和位数转换为整数。  
+  示例：
+  ```go
+  num, err := strconv.ParseInt("FF", 16, 64)
+  if err != nil {
+      fmt.Println("转换错误:", err)
+  } else {
+      fmt.Println("转换结果:", num) // 输出: 转换结果: 255
+  }
+  ```
+  
+
+- **`FormatInt(i int64, base int) string`**  
+  将整数按指定进制格式化为字符串。  
+  示例：
+  ```go
+  str := strconv.FormatInt(255, 16)
+  fmt.Println("转换结果:", str) // 输出: 转换结果: "ff"
+  ```
+
+---
+
+### 2. **字符串与浮点数之间的转换**
+- **`ParseFloat(s string, bitSize int) (float64, error)`**  
+  将字符串转换为浮点数。  
+  示例：
+  ```go
+  num, err := strconv.ParseFloat("3.14", 64)
+  if err != nil {
+      fmt.Println("转换错误:", err)
+  } else {
+      fmt.Println("转换结果:", num) // 输出: 转换结果: 3.14
+  }
+  ```
+  
+
+- **`FormatFloat(f float64, fmt byte, prec, bitSize int) string`**  
+  将浮点数格式化为字符串。  
+  示例：
+  ```go
+  str := strconv.FormatFloat(3.14159, 'f', 2, 64)
+  fmt.Println("转换结果:", str) // 输出: 转换结果: "3.14"
+  ```
+
+---
+
+### 3. **字符串与布尔值之间的转换**
+- **`ParseBool(str string) (bool, error)`**  
+  将字符串转换为布尔值。支持的真值包括 `"true"`、`"True"`、`"TRUE"` 等，假值包括 `"false"`、`"False"`、`"FALSE"` 等。  
+  示例：
+  ```go
+  b, err := strconv.ParseBool("True")
+  if err != nil {
+      fmt.Println("转换错误:", err)
+  } else {
+      fmt.Println("转换结果:", b) // 输出: 转换结果: true
+  }
+  ```
+  
+
+- **`FormatBool(b bool) string`**  
+  将布尔值转换为字符串（`"true"` 或 `"false"`）。  
+  示例：
+  ```go
+  str := strconv.FormatBool(true)
+  fmt.Println("转换结果:", str) // 输出: 转换结果: "true"
+  ```
+
+---
+
+### 4. **其他常用函数**
+- **`Quote(s string) string`**  
+  返回一个带有双引号的字符串字面量表示形式。  
+  示例：
+  ```go
+  str := strconv.Quote("Hello, World!")
+  fmt.Println("转换结果:", str) // 输出: 转换结果: "\"Hello, World!\""
+  ```
+
+- **`Unquote(s string) (string, error)`**  
+  移除字符串中的双引号，并还原转义字符。  
+  示例：
+  ```go
+  str, err := strconv.Unquote("\"Hello, World!\"")
+  if err != nil {
+      fmt.Println("转换错误:", err)
+  } else {
+      fmt.Println("转换结果:", str) // 输出: 转换结果: Hello, World!
+  }
+  ```
+
+- **`Append` 系列函数**  
+  这些函数将基本数据类型直接追加到字节切片中，常用于高效的字符串拼接操作。例如：`AppendInt`、`AppendBool`、`AppendFloat` 等。  
+  示例：
+  ```go
+  b := []byte("数字是: ")
+  b = strconv.AppendInt(b, 123, 10)
+  fmt.Println(string(b)) // 输出: 数字是: 123
+  ```
+> 在 `strconv.AppendInt(b, 123, 10)` 中，第三个参数表示数字的进制（base）。具体来说：
+> **`10`** 表示将整数 `123` 按照十进制格式追加到字节切片 `b` 中。如果改为其他值，例如 `16`则表示将整数以十六进制格式追加；如果是 `2`，则表示以二进制格式追加。
+
--- a/技术/Go/常用包/strings.md
+++ b/技术/Go/常用包/strings.md
@@ -0,0 +1,169 @@
+在 Go 语言中，`strings` 包提供了许多用于字符串操作的函数，这些函数非常高效且易于使用。以下是一些常用的 `strings` 包函数及其使用方法：
+
+---
+
+### **1. 字符串查询**
+- **`Contains(s, substr string) bool`**  
+  判断字符串 `s` 是否包含子串 `substr`。  
+  示例：
+  ```go
+  result := strings.Contains("Hello, World!", "World")
+  fmt.Println(result) // 输出: true
+  ```
+
+
+- **`ContainsAny(s, chars string) bool`**  
+  判断字符串 `s` 是否包含 `chars` 中的任意字符。  
+  示例：
+  ```go
+  result := strings.ContainsAny("Hello, World!", "aeiou")
+  fmt.Println(result) // 输出: true
+  ```
+
+- **`Count(s, substr string) int`**  
+  统计子串 `substr` 在字符串 `s` 中出现的次数。  
+  示例：
+  ```go
+  count := strings.Count("banana", "a")
+  fmt.Println(count) // 输出: 3
+  ```
+
+---
+
+### **2. 字符串前缀和后缀**
+- **`HasPrefix(s, prefix string) bool`**  
+  判断字符串 `s` 是否以指定前缀开头。  
+  示例：
+  ```go
+  result := strings.HasPrefix("Hello, World!", "Hello")
+  fmt.Println(result) // 输出: true
+  ```
+  
+
+- **`HasSuffix(s, suffix string) bool`**  
+  判断字符串 `s` 是否以指定后缀结尾。  
+  示例：
+  ```go
+  result := strings.HasSuffix("Hello, World!", "World!")
+  fmt.Println(result) // 输出: true
+  ```
+
+---
+
+### **3. 字符串索引**
+- **`Index(s, substr string) int`**  
+  返回子串 `substr` 在字符串 `s` 中首次出现的位置。如果未找到，返回 `-1`。  
+  示例：
+  ```go
+  index := strings.Index("Hello, World!", "World")
+  fmt.Println(index) // 输出: 7
+  ```
+
+- **`LastIndex(s, substr string) int`**  
+  返回子串 `substr` 在字符串 `s` 中最后一次出现的位置。如果未找到，返回 `-1`。  
+  示例：
+  ```go
+  index := strings.LastIndex("Hello, World, World!", "World")
+  fmt.Println(index) // 输出: 13
+  ```
+
+---
+
+### **4. 字符串替换**
+- **`Replace(s, old, new string, n int) string`**  
+  将字符串 `s` 中的 `old` 替换为 `new`，最多替换 `n` 次。如果 `n` 为 `-1`，则替换所有匹配项。  
+  示例：
+  ```go
+  str := strings.Replace("banana", "a", "o", 2)
+  fmt.Println(str) // 输出: bonona
+  ```
+
+- **`ReplaceAll(s, old, new string) string`**  
+  替换字符串 `s` 中所有的 `old` 为 `new`。  
+  示例：
+  ```go
+  str := strings.ReplaceAll("banana", "a", "o")
+  fmt.Println(str) // 输出: bonono
+  ```
+
+---
+
+### **5. 字符串分割与拼接**
+- **`Split(s, sep string) []string`**  
+  按照分隔符 `sep` 将字符串 `s` 分割成一个字符串切片。  
+  示例：
+  ```go
+  parts := strings.Split("a,b,c", ",")
+  fmt.Println(parts) // 输出: [a b c]
+  ```
+  
+
+- **`Join(elems []string, sep string) string`**  
+  将字符串切片 `elems` 使用分隔符 `sep` 拼接成一个字符串。  
+  示例：
+  ```go
+  str := strings.Join([]string{"a", "b", "c"}, ",")
+  fmt.Println(str) // 输出: a,b,c
+  ```
+
+- **`Fields(s string) []string`**  
+  按空白字符（如空格、制表符等）将字符串 `s` 分割成一个字符串切片。  
+  示例：
+  ```go
+  parts := strings.Fields("a b   c")
+  fmt.Println(parts) // 输出: [a b c]
+  ```
+
+---
+
+### **6. 字符串大小写转换**
+- **`ToLower(s string) string`**  
+  将字符串 `s` 转换为小写形式。  
+  示例：
+  ```go
+  str := strings.ToLower("HELLO")
+  fmt.Println(str) // 输出: hello
+  ```
+
+- **`ToUpper(s string) string`**  
+  将字符串 `s` 转换为大写形式。  
+  示例：
+  ```go
+  str := strings.ToUpper("hello")
+  fmt.Println(str) // 输出: HELLO
+  ```
+
+---
+
+### **7. 字符串修剪**
+- **`Trim(s, cutset string) string`**  
+  移除字符串 `s` 开头和结尾的所有出现在 `cutset` 中的字符。  
+  示例：
+  ```go
+  str := strings.Trim("!!!Hello, World!!!", "!")
+  fmt.Println(str) // 输出: Hello, World
+  ```
+
+- **`TrimSpace(s string) string`**  
+  移除字符串 `s` 开头和结尾的所有空白字符（包括空格、制表符、换行符等）。  
+  示例：
+  ```go
+  str := strings.TrimSpace("   Hello, World!   ")
+  fmt.Println(str) // 输出: Hello, World!
+  ```
+
+---
+
+### **8. 字符串比较**
+- **`EqualFold(s1, s2 string) bool`**  
+  比较两个字符串是否相等（忽略大小写）。  
+  示例：
+  ```go
+  result := strings.EqualFold("GoLang", "golang")
+  fmt.Println(result) // 输出: true
+  ```
+  
+
+---
+
+以上是 `strings` 包中一些常用的函数及其使用方法。这些函数可以帮助开发者轻松处理各种字符串操作需求 .
--- a/技术/Go/常用包/time.md
+++ b/技术/Go/常用包/time.md
@@ -0,0 +1,137 @@
+在 Go 语言中，`time` 包提供了丰富的时间和日期处理功能，广泛应用于时间的获取、格式化、解析以及时间间隔的操作。以下是一些常用的 `time` 包函数及其使用方法：
+
+---
+
+### **1. 获取当前时间**
+- **`Now() Time`**  
+  返回当前的本地时间。  
+  示例：
+  ```go
+  now := time.Now()
+  fmt.Println("当前时间:", now) // 输出: 当前时间: 2025-03-17 14:30:00.xxx
+  ```
+
+---
+
+### **2. 时间的创建**
+- **`Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time`**  
+  根据指定的年、月、日、时、分、秒、纳秒和时区创建一个时间对象。  
+  示例：
+  ```go
+  t := time.Date(2025, time.March, 17, 14, 30, 0, 0, time.Local)
+  fmt.Println("指定时间:", t) // 输出: 指定时间: 2025-03-17 14:30:00 +0800 CST
+  ```
+
+- **`Unix(sec int64, nsec int64) Time`**  
+  根据 Unix 时间戳（秒数和纳秒数）创建时间对象。  
+  示例：
+  ```go
+  t := time.Unix(1710651000, 0)
+  fmt.Println("Unix时间对应时间:", t) // 输出: Unix时间对应时间: 2025-03-17 14:30:00 +0800 CST
+  ```
+
+---
+
+### **3. 时间格式化与解析**
+- **`Format(layout string) string`**  
+  将时间对象格式化为字符串，`layout` 是格式模板，必须使用固定的参考时间 `2006-01-02 15:04:05` 的形式。  
+  示例：
+  ```go
+  t := time.Now()
+  formatted := t.Format("2006-01-02 15:04:05")
+  fmt.Println("格式化时间:", formatted) // 输出: 格式化时间: 2025-03-17 14:30:00
+  ```
+
+- **`Parse(layout, value string) (Time, error)`**  
+  将字符串解析为时间对象，`layout` 是格式模板。  
+  示例：
+  ```go
+  t, err := time.Parse("2006-01-02 15:04:05", "2025-03-17 14:30:00")
+  if err != nil {
+      fmt.Println("解析错误:", err)
+  } else {
+      fmt.Println("解析时间:", t) // 输出: 解析时间: 2025-03-17 14:30:00 +0000 UTC
+  }
+  ```
+
+- **`ParseInLocation(layout, value string, loc *Location) (Time, error)`**  
+  类似于 `Parse`，但允许指定时区。  
+  示例：
+  ```go
+  loc, _ := time.LoadLocation("Asia/Shanghai")
+  t, _ := time.ParseInLocation("2006-01-02 15:04:05", "2025-03-17 14:30:00", loc)
+  fmt.Println("解析时间:", t) // 输出: 解析时间: 2025-03-17 14:30:00 +0800 CST
+  ```
+
+---
+
+### **4. 时间计算**
+- **`Add(d Duration) Time`**  
+  在当前时间上增加一个时间间隔（`Duration`）。  
+  示例：
+  ```go
+  t := time.Now()
+  future := t.Add(24 * time.Hour)
+  fmt.Println("一天后的时间:", future)
+  ```
+
+- **`Sub(u Time) Duration`**  
+  计算两个时间之间的差值，返回一个 `Duration`。  
+  示例：
+  ```go
+  t1 := time.Now()
+  t2 := t1.Add(2 * time.Hour)
+  duration := t2.Sub(t1)
+  fmt.Println("时间差:", duration) // 输出: 时间差: 2h0m0s
+  ```
+
+- **`Since(t Time) Duration`**  
+  返回从指定时间到当前时间的时间间隔。  
+  示例：
+  ```go
+  t := time.Date(2025, time.March, 16, 14, 30, 0, 0, time.Local)
+  duration := time.Since(t)
+  fmt.Println("距离现在的时间:", duration) // 输出: 距离现在的时间: 24h0m0s
+  ```
+
+---
+
+### **5. 时间间隔（Duration）**
+- **`time.Duration`**  
+  表示时间间隔，通常以纳秒为单位。可以通过常量如 `time.Second`、`time.Minute` 等表示固定的时间间隔。  
+  示例：
+  ```go
+  duration := 2*time.Hour + 30*time.Minute
+  fmt.Println("时间间隔:", duration) // 输出: 时间间隔: 2h30m0s
+  ```
+
+---
+
+### **6. 定时器与休眠**
+- **`Sleep(d Duration)`**  
+  让当前 Goroutine 进入休眠状态，持续指定的时间间隔。  
+  示例：
+  ```go
+  fmt.Println("开始休眠...")
+  time.Sleep(2 * time.Second)
+  fmt.Println("休眠结束!")
+  ```
+
+- **`After(d Duration) <-chan Time`**  
+  返回一个通道，在指定的时间间隔后发送当前时间。  
+  示例：
+  ```go
+  fmt.Println("等待2秒...")
+  <-time.After(2 * time.Second)
+  fmt.Println("2秒已过!")
+  ```
+
+---
+
+### **7. 时间相关常量**
+- **`time.Second`、`time.Minute`、`time.Hour` 等**  
+  提供了常用的时间单位常量，便于时间间隔的计算。  
+  示例：
+  ```go
+  fmt.Println("一小时有多少秒:", time.Hour.Seconds()) // 输出: 一小时有多少秒: 3600
+  ```