大家好～ 上一篇我们精讲了Go标准库的基础核心模块，今天继续深挖最常用的3个实用模块：net/http（HTTP客户端/服务端）、encoding/json（JSON编解码）、time（时间处理/定时任务）。
这三个模块是日常Go开发（尤其是Web开发、接口开发）的“高频工具”，几乎所有项目都会用到。本文全程贴合实战，每个知识点配简短可运行代码，标注官方文档/权威引用，避免冗余，看完直接上手用！
1. HTTP客户端
net/http包提供了完整的HTTP客户端实现，无需依赖第三方库（如requests），就能轻松发送GET、POST等请求，核心是http.Get()、http.Post()和http.Client结构体。
核心场景：调用第三方接口、爬虫基础请求、服务间通信。
1.1 基础GET请求（最常用）
最简单的GET请求，用http.Get()一键发送，自动处理TCP连接，无需手动关闭（底层会复用连接）。
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
// 发送GET请求，参数是请求URL
resp, err := http.Get("https://httpbin.org/get")
if err != nil {
fmt.Printf("请求失败：%v\n", err)
return
}
// 延迟关闭响应体（必须做，避免资源泄露）
defer resp.Body.Close()
// 读取响应体内容（字节流）
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Printf("读取响应失败：%v\n", err)
return
}
// 转换为字符串并打印
fmt.Printf("响应状态：%s\n", resp.Status)
fmt.Printf("响应内容：%s\n", string(body))
}
关键说明：
-
resp.Body必须用defer关闭，否则会导致文件描述符泄露，长期运行会引发程序异常； -
ioutil.ReadAll()已兼容Go 1.21+，也可替换为os.ReadFile()，效果一致； -
响应状态码可通过
resp.StatusCode获取（int类型，如200、404）。
1.2 基础POST请求
发送POST请求（表单提交、JSON提交），核心用http.Post()，需指定请求体类型（Content-Type）。
package main
import (
"fmt"
"io/ioutil"
"net/http"
"strings"
)
func main() {
// 1. 表单提交（Content-Type: application/x-www-form-urlencoded）
formData := strings.NewReader("name=golang&age=10")
resp1, err := http.Post("https://httpbin.org/post", "application/x-www-form-urlencoded", formData)
if err != nil {
fmt.Printf("表单请求失败：%v\n", err)
return
}
defer resp1.Body.Close()
body1, _ := ioutil.ReadAll(resp1.Body)
fmt.Printf("表单响应：%s\n", string(body1))
// 2. JSON提交（Content-Type: application/json）
jsonData := strings.NewReader(`{"name":"golang","version":"1.21"}`)
resp2, err := http.Post("https://httpbin.org/post", "application/json", jsonData)
if err != nil {
fmt.Printf("JSON请求失败：%v\n", err)
return
}
defer resp2.Body.Close()
body2, _ := ioutil.ReadAll(resp2.Body)
fmt.Printf("JSON响应：%s\n", string(body2))
}
1.3 自定义客户端（进阶）
当需要设置超时时间、请求头（如Cookie、Token）、代理时，需用http.Client自定义配置，避免使用默认客户端（默认无超时，可能导致请求挂死）。
package main
import (
"fmt"
"io/ioutil"
"net/http"
"time"
)
func main() {
// 自定义客户端配置
client := &http.Client{
Timeout: 5 * time.Second, // 超时时间（关键：避免请求无限挂起）
// 可额外配置Transport（代理、TLS等），按需添加
}
// 构建请求（可自定义请求头）
req, err := http.NewRequest("GET", "https://httpbin.org/get", nil)
if err != nil {
fmt.Printf("构建请求失败：%v\n", err)
return
}
// 添加请求头（如Token、User-Agent）
req.Header.Set("User-Agent", "Go-http-client/1.1")
req.Header.Set("Token", "golang123456")
// 发送请求
resp, err := client.Do(req)
if err != nil {
fmt.Printf("请求失败：%v\n", err)
return
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Printf("响应内容：%s\n", string(body))
}
引用来源：Go官方文档 - http.Client
2. HTTP服务
net/http包不仅能做客户端，还能快速搭建HTTP服务，无需额外依赖，核心是http.HandleFunc()（注册路由）和http.ListenAndServe()（启动服务）。
Go的HTTP服务是“并发安全”的，底层会为每个请求启动一个goroutine，性能优异，适合快速开发接口服务。
2.1 最简HTTP服务
package main
import (
"fmt"
"net/http"
)
// 定义处理器函数（处理请求的逻辑）
// w: 用于写入响应；r: 用于读取请求
func helloHandler(w http.ResponseWriter, r *http.Request) {
// 向客户端返回响应内容
fmt.Fprintf(w, "Hello Golang! 你访问的路径是：%s", r.URL.Path)
}
func main() {
// 1. 注册路由：路径"/hello" 对应 helloHandler 处理器
http.HandleFunc("/hello", helloHandler)
// 2. 启动HTTP服务：监听本地8080端口，无TLS（http）
// 第二个参数为nil，使用默认的ServeMux（路由分发器）
fmt.Println("服务启动成功，监听端口：8080，访问：http://localhost:8080/hello")
err := http.ListenAndServe(":8080", nil)
if err != nil {
fmt.Printf("服务启动失败：%v\n", err)
}
}
运行步骤：
-
运行代码，控制台输出“服务启动成功”；
-
浏览器访问
http://localhost:8080/hello，即可看到响应内容； -
访问其他路径（如
/test），会返回404（默认路由未匹配）。
2.2 服务端返回JSON响应
日常开发中，接口常返回JSON格式，需手动设置Content-Type: application/json，再写入JSON字符串。
package main
import (
"encoding/json"
"net/http"
)
// 定义响应结构体（对应JSON格式）
type UserResp struct {
Name string `json:"name"` // JSON字段名
Age int `json:"age"` // 结构体字段与JSON字段映射
Version string `json:"version"`
}
func userHandler(w http.ResponseWriter, r *http.Request) {
// 1. 设置响应头（必须在写入响应体之前）
w.Header().Set("Content-Type", "application/json;charset=utf-8")
// 2. 构建响应数据
user := UserResp{
Name: "Golang标准库",
Age: 10,
Version: "1.21",
}
// 3. 将结构体转换为JSON字符串（后续JSON编码会详细讲）
jsonData, err := json.Marshal(user)
if err != nil {
w.WriteHeader(http.StatusInternalServerError) // 返回500状态码
w.Write([]byte(`{"error": "JSON编码失败"}`))
return
}
// 4. 返回JSON响应
w.Write(jsonData)
}
func main() {
http.HandleFunc("/user", userHandler)
fmt.Println("服务启动：http://localhost:8080/user")
http.ListenAndServe(":8080", nil)
}
访问 http://localhost:8080/user，响应结果：
{
"name": "Golang标准库",
"age": 10,
"version": "1.21"
}
2.3 启动HTTPS服务
使用http.ListenAndServeTLS()启动HTTPS服务，需提供证书文件（.pem）和密钥文件（.key）（可通过openssl生成测试证书）。
package main
import (
"fmt"
"net/http"
)
func helloHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "HTTPS服务：Hello Golang!")
}
func main() {
http.HandleFunc("/", helloHandler)
// 启动HTTPS服务：证书文件路径、密钥文件路径、监听端口
err := http.ListenAndServeTLS(":443", "server.pem", "server.key", nil)
if err != nil {
fmt.Printf("HTTPS服务启动失败：%v\n", err)
}
}
引用来源：Go官方文档 - http.ListenAndServe
3. 路由处理
路由即“请求路径与处理器的映射关系”，Go标准库默认提供ServeMux（路由分发器），支持基础路由匹配，若需复杂路由（如参数路由、正则路由），需使用第三方库（如gorilla/mux）。
3.1 标准库默认路由（ServeMux）
默认路由的匹配规则：前缀匹配（最长匹配优先），路径末尾带/表示“目录”，不带表示“文件”。
package main
import (
"fmt"
"net/http"
)
func indexHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "首页：/")
}
func userHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "用户页：/user")
}
func userDetailHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "用户详情页：/user/detail")
}
func main() {
// 注册3个路由，测试前缀匹配规则
http.HandleFunc("/", indexHandler) // 匹配所有未命中的路径（前缀为/）
http.HandleFunc("/user", userHandler) // 匹配 /user
http.HandleFunc("/user/detail", userDetailHandler) // 匹配 /user/detail
fmt.Println("服务启动：http://localhost:8080")
http.ListenAndServe(":8080", nil)
}
测试结果：
-
访问
/→ 首页（匹配/indexHandler）； -
访问
/user→ 用户页（匹配/userHandler，最长匹配）； -
访问
/user/detail→ 用户详情页（匹配/userDetailHandler，最长匹配）； -
访问
/user/123→ 首页（未匹配其他路由，匹配/）。
3.2 自定义ServeMux
默认路由使用全局的ServeMux，若需多个路由分发器（如分模块路由），可自定义&http.ServeMux{}。
package main
import (
"fmt"
"net/http"
)
// 模块1：用户相关路由
func userLogin(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "用户登录：/user/login")
}
// 模块2：商品相关路由
func goodsList(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "商品列表：/goods/list")
}
func main() {
// 1. 自定义用户模块路由
userMux := &http.ServeMux{}
userMux.HandleFunc("/user/login", userLogin)
// 2. 自定义商品模块路由
goodsMux := &http.ServeMux{}
goodsMux.HandleFunc("/goods/list", goodsList)
// 3. 全局路由分发：将模块路由挂载到全局路径
http.Handle("/user/", userMux) // 所有/user/开头的请求，交给userMux处理
http.Handle("/goods/", goodsMux) // 所有/goods/开头的请求，交给goodsMux处理
fmt.Println("服务启动：http://localhost:8080")
http.ListenAndServe(":8080", nil)
}
3.3 第三方路由（gorilla/mux）
标准库路由不支持参数路由（如/user/{id}）和正则路由，实际开发中常用gorilla/mux（最流行的第三方路由库）。
package main
import (
"fmt"
"net/http"
"github.com/gorilla/mux" // 需先安装：go get github.com/gorilla/mux
)
// 处理参数路由：/user/{id}
func userDetailHandler(w http.ResponseWriter, r *http.Request) {
// 获取路由参数id
vars := mux.Vars(r)
userId := vars["id"]
fmt.Fprintf(w, "用户ID：%s", userId)
}
func main() {
// 1. 创建mux路由实例
r := mux.NewRouter()
// 2. 注册路由（支持参数、正则、方法限制）
r.HandleFunc("/user/{id}", userDetailHandler).Methods("GET") // 只允许GET请求
r.HandleFunc("/goods/{id:[0-9]+}", func(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
goodsId := vars["id"]
fmt.Fprintf(w, "商品ID（数字）：%s", goodsId)
})
// 3. 启动服务，使用mux路由
fmt.Println("服务启动：http://localhost:8080")
http.ListenAndServe(":8080", r)
}
测试结果：
-
访问
/user/123→ 输出“用户ID：123”； -
访问
/goods/456→ 输出“商品ID（数字）：456”； -
访问
/goods/abc→ 404（正则限制只能是数字）； -
用POST请求访问
/user/123→ 405（方法限制只能GET）。
引用来源：gorilla/mux 官方文档
4. JSON编码
JSON是前后端、服务间通信的主流格式，Go标准库encoding/json提供了完整的JSON编解码功能，核心函数：json.Marshal()（结构体/切片 → JSON字符串）。
关键：结构体字段必须是导出的（首字母大写），否则JSON编码会忽略该字段。
4.1 基础编码（结构体→JSON）
package main
import (
"encoding/json"
"fmt"
)
// 定义结构体（字段首字母大写，可导出）
type Student struct {
Name string `json:"name"` // json:"name"：指定JSON字段名（小写）
Age int `json:"age"` // 若不指定，JSON字段名与结构体一致（首字母大写）
Score int `json:"score"`
// 未导出字段（首字母小写），编码时会忽略
address string
}
func main() {
// 1. 初始化结构体
stu := Student{
Name: "小明",
Age: 18,
Score: 95,
address: "北京", // 未导出，编码后无此字段
}
// 2. JSON编码（结构体 → JSON字节流）
jsonData, err := json.Marshal(stu)
if err != nil {
fmt.Printf("JSON编码失败：%v\n", err)
return
}
// 3. 转换为字符串并打印
fmt.Printf("JSON字符串：%s\n", string(jsonData))
// 输出：{"name":"小明","age":18,"score":95}
}
4.2 常用JSON标签
结构体字段后的json:"xxx"是标签，用于控制JSON编码的行为，常用标签如下：
package main
import (
"encoding/json"
"fmt"
)
type User struct {
Name string `json:"name"` // 正常映射，JSON字段名name
Age int `json:"age,omitempty"` // omitempty：字段为零值（0、""、nil）时，不显示该字段
Gender string `json:"-"` // "-"：忽略该字段，无论是否有值
NickName string `json:"nick_name,omitempty"` // 字段名映射+omitempty
}
func main() {
user1 := User{
Name: "小红",
Age: 0, // 零值，omitempty生效，不显示age
Gender: "女", // "-"标签，忽略
NickName: "红红", // 有值，显示nick_name
}
json1, _ := json.Marshal(user1)
fmt.Printf("user1 JSON：%s\n", string(json1))
// 输出：{"name":"小红","nick_name":"红红"}
user2 := User{
Name: "小李",
Age: 20,
Gender: "男",
NickName: "", // 零值，omitempty生效，不显示nick_name
}
json2, _ := json.Marshal(user2)
fmt.Printf("user2 JSON：%s\n", string(json2))
// 输出：{"name":"小李","age":20}
}
4.3 切片/Map编码
除了结构体，切片、Map也能直接编码为JSON数组/对象，无需额外处理。
package main
import (
"encoding/json"
"fmt"
)
func main() {
// 1. 切片编码（JSON数组）
slice := []string{"golang", "java", "python"}
jsonSlice, _ := json.Marshal(slice)
fmt.Printf("切片JSON：%s\n", string(jsonSlice)) // 输出：["golang","java","python"]
// 2. Map编码（JSON对象）
m := map[string]interface{}{
"name": "golang",
"version": 1.21,
"is_ok": true,
}
jsonMap, _ := json.Marshal(m)
fmt.Printf("Map JSON：%s\n", string(jsonMap)) // 输出：{"is_ok":true,"name":"golang","version":1.21}
}
5. JSON解码
JSON解码即“JSON字符串 → 结构体/Map/切片”，核心函数：json.Unmarshal()，与编码对应，同样需要注意结构体字段的导出和标签匹配。
5.1 基础解码（JSON→结构体）
package main
import (
"encoding/json"
"fmt"
)
type Student struct {
Name string `json:"name"`
Age int `json:"age"`
Score int `json:"score"`
}
func main() {
// 1. JSON字符串（模拟接口响应）
jsonStr := `{"name":"小明","age":18,"score":95}`
// 2. 初始化结构体（用于接收解码后的数据）
var stu Student
// 3. JSON解码（JSON字节流 → 结构体）
err := json.Unmarshal([]byte(jsonStr), &stu) // 注意：第二个参数是指针
if err != nil {
fmt.Printf("JSON解码失败：%v\n", err)
return
}
// 4. 打印解码结果
fmt.Printf("解码后：Name=%s, Age=%d, Score=%d\n", stu.Name, stu.Age, stu.Score)
// 输出：解码后：Name=小明, Age=18, Score=95
}
关键注意：json.Unmarshal()的第二个参数必须是指针，否则解码后的数据无法赋值给原变量（值传递特性）。
5.2 解码到Map（无需定义结构体）
若JSON格式不固定，或不想定义结构体，可解码到map[string]interface{}（万能Map），适合快速解析未知格式的JSON。
package main
import (
"encoding/json"
"fmt"
)
func main() {
jsonStr := `{"name":"golang","version":1.21,"is_ok":true,"tags":["http","json","time"]}`
// 定义万能Map，接收解码后的数据
var m map[string]interface{}
// 解码（第二个参数是Map指针）
err := json.Unmarshal([]byte(jsonStr), &m)
if err != nil {
fmt.Printf("解码失败：%v\n", err)
return
}
// 读取Map中的数据（需类型断言）
fmt.Printf("Name：%s\n", m["name"].(string)) // 字符串类型断言
fmt.Printf("Version：%v\n", m["version"].(float64)) // 数字类型解码后默认是float64
fmt.Printf("IsOk：%t\n", m["is_ok"].(bool)) // 布尔类型断言
// 切片类型断言
tags := m["tags"].([]interface{})
for i, tag := range tags {
fmt.Printf("Tag[%d]：%s\n", i, tag.(string))
}
}
5.3 解码JSON数组
JSON数组可解码到切片，需指定切片的类型（如[]Student、[]string）。
package main
import (
"encoding/json"
"fmt"
)
type Student struct {
Name string `json:"name"`
Age int `json:"age"`
}
func main() {
// JSON数组字符串
jsonStr := `[{"name":"小明","age":18},{"name":"小红","age":17},{"name":"小李","age":19}]`
// 定义切片，接收解码后的数据
var students []Student
// 解码（第二个参数是切片指针）
err := json.Unmarshal([]byte(jsonStr), &students)
if err != nil {
fmt.Printf("解码失败：%v\n", err)
return
}
// 遍历切片
for i, stu := range students {
fmt.Printf("学生[%d]：Name=%s, Age=%d\n", i, stu.Name, stu.Age)
}
}
6. 时间类型
time包是Go标准库中处理时间的核心模块，提供了时间的创建、计算、格式化等功能，核心类型是time.Time（时间对象）和time.Duration（时间间隔）。
6.1 获取当前时间
用time.Now()获取当前本地时间，返回time.Time对象，可通过方法获取年、月、日、时、分、秒等信息。
package main
import (
"fmt"
"time"
)
func main() {
// 1. 获取当前本地时间
now := time.Now()
fmt.Printf("当前时间：%v\n", now) // 输出：2024-05-20 15:30:00.123456789 +0800 CST m=+0.000123456
// 2. 获取时间的各个组件
fmt.Printf("年份：%d\n", now.Year()) // 年份：2024
fmt.Printf("月份：%d\n", now.Month()) // 月份：5（Month类型，可转换为int）
fmt.Printf("日期：%d\n", now.Day()) // 日期：20
fmt.Printf("小时：%d\n", now.Hour()) // 小时：15（24小时制）
fmt.Printf("分钟：%d\n", now.Minute()) // 分钟：30
fmt.Printf("秒：%d\n", now.Second()) // 秒：0
fmt.Printf("纳秒：%d\n", now.Nanosecond()) // 纳秒：123456789
// 3. 获取时间戳（秒级、毫秒级、微秒级、纳秒级）
fmt.Printf("秒级时间戳：%d\n", now.Unix()) // 秒级时间戳（从1970-01-01 00:00:00 UTC开始）
fmt.Printf("毫秒级时间戳：%d\n", now.UnixMilli()) // 毫秒级时间戳
fmt.Printf("微秒级时间戳：%d\n", now.UnixMicro()) // 微秒级时间戳
fmt.Printf("纳秒级时间戳：%d\n", now.UnixNano()) // 纳秒级时间戳
}
6.2 时间格式化（重点）
Go的时间格式化与其他语言不同，不能使用yyyy-MM-dd HH:mm:ss，而是使用固定的参考时间Mon Jan 2 15:04:05 MST 2006（记忆口诀：1月2日3点4分5秒6年）。
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
// 1. 常用格式化格式
fmt.Printf("格式1（yyyy-MM-dd HH:mm:ss）：%s\n", now.Format("2006-01-02 15:04:05"))
fmt.Printf("格式2（yyyy年MM月dd日 HH时mm分ss秒）：%s\n", now.Format("2006年01月02日 15时04分05秒"))
fmt.Printf("格式3（MM/dd/yyyy）：%s\n", now.Format("01/02/2006"))
fmt.Printf("格式4（HH:mm:ss）：%s\n", now.Format("15:04:05"))
// 2. 注意：月份和日期若不足两位，会自动补0（使用01、02）
// 若用1、2，则不补0（如5月显示为5，而非05）
fmt.Printf("不补0格式：%s\n", now.Format("2006-1-2 3:4:5"))
}
6.3 时间间隔（time.Duration）
time.Duration表示两个时间之间的间隔，单位有纳秒（ns）、微秒（µs）、毫秒（ms）、秒（s）、分钟（m）、小时（h）等，可直接进行加减运算。
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
// 1. 定义时间间隔（常用单位）
oneSecond := 1 * time.Second // 1秒
oneMinute := 1 * time.Minute // 1分钟
oneHour := 1 * time.Hour // 1小时
oneMillisecond := 1 * time.Millisecond // 1毫秒
fmt.Printf("1秒 = %d 纳秒\n", oneSecond.Nanoseconds()) // 1秒 = 1000000000 纳秒
// 2. 时间加减运算
later := now.Add(oneMinute) // 当前时间加1分钟
earlier := now.Add(-oneSecond) // 当前时间减1秒
fmt.Printf("1分钟后：%s\n", later.Format("2006-01-02 15:04:05"))
fmt.Printf("1秒前：%s\n", earlier.Format("2006-01-02 15:04:05"))
// 3. 计算两个时间的间隔
diff := later.Sub(now)
fmt.Printf("时间间隔：%v\n", diff) // 输出：1m0s
fmt.Printf("间隔（秒）：%f\n", diff.Seconds()) // 输出：60.000000
}
引用来源：Go官方文档 - time包
7. 定时任务
time包提供了两种常用的定时任务方式：time.AfterFunc()（一次性定时）和time.Ticker（周期性定时），无需第三方库，就能实现简单的定时功能。
7.1 一次性定时任务（time.AfterFunc）
延迟指定时间后，执行一次任务（函数），适合“延迟执行某操作”（如延迟5秒发送通知）。
package main
import (
"fmt"
"time"
)
// 定义定时执行的函数
func task() {
fmt.Println("定时任务执行：延迟3秒后执行，仅执行一次！")
}
func main() {
fmt.Println("程序启动，开始倒计时3秒...")
// 一次性定时任务：延迟3秒后执行task函数
// 返回一个*time.Timer对象，可用于取消任务
timer := time.AfterFunc(3*time.Second, task)
// 防止程序提前退出（main函数退出，所有goroutine都会退出）
time.Sleep(4 * time.Second)
// 取消定时任务（若任务未执行）
// timer.Stop()
}
关键：main函数需延迟退出（如time.Sleep()），否则main函数结束，定时任务的goroutine也会被终止，任务无法执行。
7.2 周期性定时任务（time.Ticker）
每隔指定时间，执行一次任务（周期性执行），适合“定时轮询、定时同步数据”等场景，可通过Stop()取消任务。
package main
import (
"fmt"
"time"
)
func main() {
fmt.Println("周期性定时任务启动，每隔2秒执行一次，按Ctrl+C退出...")
// 1. 创建Ticker：每隔2秒触发一次
ticker := time.NewTicker(2 * time.Second)
// 2. 用通道接收Ticker的触发信号（ticker.C是一个time.Time类型的通道）
// 启动goroutine，避免阻塞main函数
go func() {
for t := range ticker.C {
fmt.Printf("定时任务执行：%s\n", t.Format("2006-01-02 15:04:05"))
}
}()
// 3. 程序持续运行（防止退出），可通过其他逻辑触发退出
select {} // 阻塞main函数，无限运行
// 4. 取消定时任务（按需调用，如收到退出信号后）
// ticker.Stop()
// fmt.Println("定时任务已取消")
}
7.3 定时任务的优雅退出
实际开发中，定时任务需要优雅退出（避免任务执行到一半被终止），可通过“退出通道”控制。
package main
import (
"fmt"
"os"
"os/signal"
"syscall"
"time"
)
func main() {
// 1. 创建退出通道（用于接收退出信号）
quit := make(chan os.Signal, 1)
// 监听Ctrl+C、kill等退出信号
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
// 2. 创建周期性Ticker
ticker := time.NewTicker(2 * time.Second)
// 3. 启动定时任务
go func() {
for {
select {
case t := <-ticker.C:
// 定时任务逻辑
fmt.Printf("定时任务执行：%s\n", t.Format("2006-01-02 15:04:05"))
case <-quit:
// 收到退出信号，取消Ticker，退出goroutine
ticker.Stop()
fmt.Println("\n收到退出信号，定时任务取消，优雅退出...")
return
}
}
}()
// 4. 阻塞main函数，等待退出信号
<-quit
}
测试：运行程序后，按Ctrl+C，会触发退出信号，定时任务优雅取消，不会直接终止。
8. 时区处理
Go的time包默认支持时区处理，time.Now()获取的是本地时区（CST，中国标准时间，UTC+8），可通过time.LoadLocation()加载其他时区，实现跨时区时间转换。
8.1 加载时区与转换
常用时区：Asia/Shanghai（中国时区）、UTC（世界标准时间）、America/New_York（纽约时区）等。
package main
import (
"fmt"
"time"
)
func main() {
// 1. 获取当前UTC时间
utcNow := time.Now().UTC()
fmt.Printf("当前UTC时间：%s\n", utcNow.Format("2006-01-02 15:04:05"))
// 2. 加载中国时区（Asia/Shanghai）
shLocation, err := time.LoadLocation("Asia/Shanghai")
if err != nil {
fmt.Printf("加载时区失败：%v\n", err)
return
}
// 3. UTC时间转换为中国时区时间
shNow := utcNow.In(shLocation)
fmt.Printf("UTC时间转换为中国时间：%s\n", shNow.Format("2006-01-02 15:04:05"))
// 4. 加载纽约时区（America/New_York）
nyLocation, err := time.LoadLocation("America/New_York")
if err != nil {
fmt.Printf("加载时区失败：%v\n", err)
return
}
// 5. 中国时间转换为纽约时间
nyNow := shNow.In(nyLocation)
fmt.Printf("中国时间转换为纽约时间：%s\n", nyNow.Format("2006-01-02 15:04:05"))
}
8.2 时区相关注意事项
-
加载时区时，时区名称必须是标准名称（如
Asia/Shanghai，而非Shanghai、中国）； -
若系统缺少时区数据库，
time.LoadLocation()会失败，可通过安装tzdata包解决（go get github.com/golang/time/tzdata）； -
时间戳（
Unix()）是“时区无关”的，无论哪个时区，同一时刻的时间戳相同，转换时区只是改变时间的显示格式。
// 解决时区数据库缺失问题（导入tzdata包即可）
package main
import (
"fmt"
"time"
_ "github.com/golang/time/tzdata" // 自动加载时区数据库
)
func main() {
loc, _ := time.LoadLocation("Asia/Shanghai")
now := time.Now().In(loc)
fmt.Printf("中国时间：%s\n", now.Format("2006-01-02 15:04:05"))
}
引用来源：Go官方文档 - time.LoadLocation
总结
本文精讲了Go标准库中3个高频实用模块，核心要点总结：
-
net/http：客户端（Get/Post/自定义Client）、服务端（HandleFunc/ListenAndServe）、路由（ServeMux+第三方mux）；
-
encoding/json：编码（Marshal）、解码（Unmarshal），注意结构体字段导出和JSON标签的使用；
-
time：当前时间、格式化（2006-01-02 15:04:05）、时间间隔、定时任务（AfterFunc/Ticker）、时区转换。
这三个模块是Go开发的“基础工具”，建议多动手运行代码，熟悉API的使用场景，后续开发中能大幅提高效率。如果有疑问，欢迎在评论区交流～
