Golang使用教程

全面掌握 Golang使用教程:从语言基础到生产级工程实践

本 Golang使用教程 系统覆盖 Go 语言核心语法、并发模型、标准库深度应用、Web 开发实战、微服务架构设计、性能调优策略、工程化工具链及高频面试题解析,结合真实项目经验与社区最佳实践,助您构建扎实的 Go 开发能力体系。

一、Go语言核心语法体系:构建扎实基础

Go 语言由 Google 于 2009 年开源,以简洁、高效、高并发著称,其语法设计强调可读性与工程化,摒弃了复杂特性(如继承、异常处理),采用组合与接口实现高内聚低耦合。本节梳理 Golang使用教程 中最核心的语法结构,帮助学习者建立清晰的语言认知框架。

Go 的变量声明采用 `var` 或 `:=` 形式,如:

var name string = "Go"
count := 10

注意:`:=` 仅能在函数内部使用,且右侧必须有明确类型推导能力。多变量初始化可写为:

var (
    host = "localhost"
    port = 8080
)

Go 支持值传递与指针传递,但无引用传递。典型指针操作:

func increment(p *int) {
    *p++
}
n := 5
increment(&n) // n = 6

Go 的函数支持多返回值,常用于错误处理:

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

Go 的控制结构高度精简:`if`、`for`、`switch` 均无括号;`for` 是唯一循环关键字;`switch` 支持类型断言与多条件分支。例如:

for i := 0; i < len(slice); i++ {
    fmt.Println(slice[i])
}

Go 的数组是值类型,长度固定;切片(slice)是引用类型,可动态扩容。切片底层结构包含指针、长度、容量三要素,理解其扩容机制(容量翻倍)对性能优化至关重要:

slice := make([]int, 3, 5) // len=3, cap=5
slice = append(slice, 4, 5)  // 新切片 len=5, cap=10

结构体支持嵌入字段(匿名字段),实现类似继承的效果:

type Person struct {
    Name string
    Age  int
}
type Employee struct {
    Person
    Salary float64
}

Go 的接口(interface)采用隐式实现,无需显式 `implements` 关键字。空接口 `interface{}` 可接收任意类型,常用于通用容器或反射场景:

type Serializer interface {
    Serialize() []byte
}
type JSONSerializer struct{}
func (j JSONSerializer) Serialize() []byte { return []byte("{}") }

Go 的包管理采用 `go mod` 模块化方案,通过 `go.mod` 文件声明模块路径与依赖版本,支持语义化版本控制(SemVer)。典型项目结构:

project/
├── go.mod          // module example.com/project
├── main.go
├── internal/       // 内部包,仅本模块可访问
└── pkg/            // 公开包

Go 的错误处理哲学强调显式与可控:`error` 是接口类型,函数返回 `error` 作为最后一个值,调用方需主动检查。`fmt.Errorf` 用于包装错误并保留上下文:

if err != nil {
    return fmt.Errorf("read config: %w", err)
}

Go 的泛型(自 1.18 起)采用类型参数实现,支持约束(constraint)与接口组合:

type Number interface {
    ~int | ~float64
}
func Sum[T Number](vals []T) T {
    var total T
    for _, v := range vals {
        total += v
    }
    return total
}

Go 的 `context` 包用于管理请求作用域的上下文信息,如超时、取消信号、元数据传递,是构建健壮网络服务的核心组件:

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
res, err := http.GetWithContext(ctx, url)

二、Go并发编程模型:GPM调度与通道设计

Go 的并发模型基于 CSP(通信顺序进程)理论,核心是 goroutine 与 channel。goroutine 是轻量级协程,初始栈空间仅 2KB,可轻松启动数万级并发任务;channel 实现 goroutine 间安全通信,避免共享内存竞争。

启动 goroutine 仅需在函数调用前加 `go` 关键字:

go func() {
    fmt.Println("Hello from goroutine")
}()

但需注意:主 goroutine 退出会导致其他 goroutine 强制终止,因此常配合 `sync.WaitGroup` 或 channel 实现同步:

var wg sync.WaitGroup
wg.Add(3)
for i := 0; i < 3; i++ {
    go func(id int) {
        defer wg.Done()
        fmt.Println("Worker", id)
    }(i)
}
wg.Wait()

channel 分为无缓冲(同步阻塞)与有缓冲(异步非阻塞)两类。无缓冲 channel 要求发送与接收方必须同时就绪:

ch := make(chan int) // 无缓冲
go func() { ch <- 42 }() // 阻塞直到接收
fmt.Println(<-ch)

有缓冲 channel 允许在缓冲区未满时异步发送:

ch := make(chan int, 2)
ch <- 1
ch <- 2 // 不阻塞
// ch <- 3 // 阻塞,缓冲已满

`select` 用于多 channel 并发监听,支持默认分支避免阻塞:

select {
case v := <-ch1:
    fmt.Println("ch1:", v)
case v := <-ch2:
    fmt.Println("ch2:", v)
case <-time.After(time.Second):
    fmt.Println("timeout")
}

Go 的调度器采用 GPM 模型(Goroutine-Processor-Machine):G 为 goroutine,P 为逻辑处理器(绑定 OS 线程),M 为机器线程。默认 `GOMAXPROCS` 等于 CPU 核心数,可通过 `runtime.GOMAXPROCS()` 动态调整。

常见并发陷阱包括:未关闭 channel 导致 goroutine 泄漏、缓冲区过大引发内存积压、未处理 panic 导致整个进程崩溃。推荐使用 `sync.Once` 初始化共享资源:

var once sync.Once
var instance *Singleton
func GetInstance() *Singleton {
    once.Do(func() {
        instance = &Singleton{}
    })
    return instance
}

Go 的 `context` 与并发结合紧密:网络请求、数据库操作均支持传入 context 实现级联取消。例如,HTTP 客户端配合 context 可实现请求超时控制:

ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
resp, err := http.DefaultClient.Do(req)

Go 1.22 引入 `runtime.LockOSThread` 的替代方案:`runtime.SetGoroutineLabels` 支持为 goroutine 设置标签,便于性能分析与日志追踪:

labels := []string{"worker", "batch-1"}
runtime.SetGoroutineLabels(labels)

在高并发系统中,推荐使用 `sync.Pool` 复用对象以减少 GC 压力,但需注意其适用于无状态对象,且不能保证对象存活时间:

var bufPool = sync.Pool{
    New: func() interface{} { return make([]byte, 1024) },
}
buf := bufPool.Get().([]byte)
defer bufPool.Put(buf)

Go 的 `pprof` 工具链(CPU、内存、goroutine 分析)是并发调试的核心手段。通过在 HTTP 服务中引入 `net/http/pprof`,可实时查看 goroutine 栈信息:

import _ "net/http/pprof"
go func() {
    log.Println(http.ListenAndServe("localhost:6060", nil))
}()

三、Go Web开发:从标准库到框架选型

Go 标准库 `net/http` 提供了简洁而强大的 HTTP 服务与客户端实现。其核心是 `http.Handler` 接口与 `http.HandleFunc` 装饰器,支持中间件链式调用。典型服务启动代码:

http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
    io.WriteString(w, "Hello, World!")
})
http.ListenAndServe(":8080", nil)

Go 的 `http.ResponseWriter` 是接口类型,封装了写回响应体、设置头信息等功能;`http.Request` 包含请求方法、URL、头、表单数据等字段。处理 JSON 请求体的通用模式:

type User struct {
    Name  string `json:"name"`
    Email string `json:"email"`
}
var u User
if err := json.NewDecoder(r.Body).Decode(&u); err != nil {
    http.Error(w, "invalid JSON", http.StatusBadRequest)
    return
}

Go 的路由设计支持自定义 `mux`,也可使用第三方库如 `gorilla/mux` 或 `chi`。`chi` 因轻量、高性能、兼容标准库而广受欢迎:

import "github.com/go-chi/chi/v5"
r := chi.NewRouter()
r.Get("/users/{id}", func(w http.ResponseWriter, r *http.Request) {
    id := chi.URLParam(r, "id")
    fmt.Fprintf(w, "User ID: %s", id)
})

Go 的模板引擎 `html/template` 支持自动 HTML 转义,有效防止 XSS 攻击。模板定义与渲染示例:

tmpl := template.Must(template.ParseFiles("index.html"))
type Data struct { Title string; Items []string }
tmpl.Execute(w, Data{Title: "List", Items: []string{"A", "B"}})

Go 的 Web 框架生态丰富:`gin`(高性能、插件化)、`echo`(极简、零依赖)、`fiber`(仿 Express API)各具特色。`gin` 因其成熟度与社区支持成为首选:

r := gin.Default()
r.GET("/ping", func(c *gin.Context) {
    c.JSON(200, gin.H{"message": "pong"})
})

Go 的中间件实现简单:函数签名 `func(http.Handler) http.Handler`,可链式组合。常见中间件包括:日志记录、JWT 认证、CORS 处理、请求限流:

func Logging(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Printf("%s %s", r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    })
}

Go 的 WebSocket 支持通过 `gorilla/websocket` 库实现。服务端处理流程:升级连接 → 设置读写限制 → 循环收发消息:

upgrader := websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}
conn, _ := upgrader.Upgrade(w, r, nil)
for {
    mt, msg, err := conn.ReadMessage()
    if err != nil { break }
    conn.WriteMessage(mt, msg)
}

Go 的 HTTP/2 支持通过 TLS 自动启用,无需额外配置。服务端只需在 `ListenAndServeTLS` 中提供证书:

http.ListenAndServeTLS(":443", "cert.pem", "key.pem", nil)

Go 的 gRPC-Web 支持通过 `grpc-web` 代理实现浏览器与后端 gRPC 通信,适用于微服务架构。典型配置:启用 `--enable-cross-origin` 参数。

四、Go微服务架构:服务治理与分布式实践

Go 是微服务架构的理想语言:编译为单文件可执行程序、启动迅速、内存占用低、高并发处理能力强。典型微服务组件包括:服务注册发现(Consul/Etcd)、配置中心(Viper)、日志链路追踪(OpenTelemetry)、限流熔断(Resilience4go)。

Go 的服务注册与发现常用方案:Consul + `go-kit` 或 `go-micro`。以 `go-kit` 为例,服务注册流程:

consulClient, _ := api.NewClient(api.DefaultConfig())
agent := consulClient.Agent()
agent.ServiceRegister(&api.AgentServiceRegistration{
    ID:      "user-service-1",
    Name:    "user-service",
    Port:    8081,
    Tags:    []string{"primary", "v1"},
    Check:   &api.AgentServiceCheck{Interval: "10s", HTTP: "http://localhost:8081/health"},
})

Go 的配置管理采用 `viper` 库,支持多种格式(JSON/YAML/TOML)与来源(文件/环境变量/远程配置):

viper.SetConfigName("config")
viper.SetConfigType("yaml")
viper.AddConfigPath("/etc/app/")
viper.ReadInConfig()

Go 的日志与链路追踪集成 OpenTelemetry:通过 `go.opentelemetry.io/otel` 包导出指标、追踪、日志。典型 Trace 配置:

processor := batch.NewSpanProcessor(exporter)
otel.SetTracerProvider(tp)
defer tp.Shutdown(ctx)

Go 的限流器实现:令牌桶算法(Token Bucket)最常用。`golang.org/x/time/rate` 包提供标准实现:

limiter := rate.NewLimiter(rate.Every(time.Second), 10)
if !limiter.Allow() {
    http.Error(w, "too many requests", http.StatusTooManyRequests)
}

Go 的熔断器可使用 `sony/sonylink` 或 `resilience4go`,支持滑动窗口统计失败率。典型配置:10 秒窗口内失败率 >50% 触发熔断,持续 30 秒后尝试恢复。

Go 的 gRPC 是微服务间通信首选:支持双向流、流控、元数据传递。定义 `.proto` 文件后生成 Go 代码:

service UserService {
    rpc GetUser(UserRequest) returns (UserResponse);
}

Go 的消息队列集成:通过 `confluent-kafka-go` 实现 Kafka 生产者/消费者,支持事务与偏移量管理:

producer, _ := kafka.NewProducer(&kafka.ConfigMap{"bootstrap.servers": "localhost:9092"})
producer.Produce(&kafka.Message{Topic: &topic, Value: []byte("hello")}, nil)

Go 的分布式事务采用 Saga 模式:通过事件驱动实现最终一致性。典型流程:订单服务发布 `OrderCreated` 事件 → 库存服务监听并扣减库存 → 发布 `InventoryReserved` 事件。

五、Go工程化工具链:测试、构建与CI/CD

Go 的工具链高度集成,`go` 命令覆盖开发全流程:`go test` 单元测试、`go build` 静态编译、`go vet` 静态分析、`gofmt` 格式化、`go mod` 依赖管理。

Go 的测试框架基于 `testing` 包,支持子测试、基准测试与覆盖率分析:

func TestSum(t *testing.T) {
    t.Run("positive", func(t *testing.T) {
        result := Sum([]int{1, 2, 3})
        if result != 6 { t.Errorf("got %d", result) }
    })
}
func BenchmarkSum(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Sum([]int{1, 2, 3, 4, 5})
    }
}

覆盖率分析:`go test -coverprofile=coverage.out` 生成报告,`go tool cover -html=coverage.out` 可视化展示。

Go 的构建优化:`-ldflags="-s -w"` 移除调试信息,减小二进制体积;`-trimpath` 移除构建路径,提升可复现性:

go build -ldflags="-s -w -trimpath" -o app .

Go 的 Dockerfile 最佳实践:多阶段构建减小镜像体积:

FROM golang:1.22-alpine AS builder
WORKDIR /app
COPY . .
RUN go build -ldflags="-s -w" -o main .
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/main .
CMD ["./main"]

Go 的 CI/CD 流程:GitHub Actions 示例(测试+构建):

name: CI
on: [push]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - uses: actions/setup-go@v5
      with: { go-version: '1.22' }
    - run: go test -coverprofile=coverage.out
    - run: go build -ldflags="-s -w" -o app .

Go 的静态分析工具:`golangci-lint` 整合 `go vet`、`staticcheck`、`ineffassign` 等 50+ 分析器,通过 `.golangci.yml` 配置启用规则。

六、Go性能调优:从 profiling 到内存管理

Go 的性能调优遵循 “先测量,再优化” 原则。核心工具包括:`pprof`(CPU/内存分析)、`trace`(运行时事件追踪)、`memstats`(GC 统计)。

CPU 分析:`pprof.Lookup("cpu").WriteProfile()` 或 HTTP 接口 `/debug/pprof/profile?seconds=30`,使用 `go tool pprof` 分析火焰图:

go tool pprof -http=:8080 cpu.prof

内存分析:`pprof.Lookup("heap").WriteProfile()`,重点关注 `InUseSpace`(活跃对象)与 `AllocSpace`(总分配)。常见内存问题:对象逃逸(heap 分配)、未复用缓冲区、切片过度扩容。

Go 的逃逸分析:编译器自动决定对象是否分配到堆。通过 `-gcflags="-m"` 查看逃逸分析结果:

go build -gcflags="-m" . 2>&1 | grep "escapes to heap"

避免逃逸的技巧:使用 `sync.Pool` 复用对象、避免返回大结构体指针、限制切片容量增长(`make([]T, 0, cap)`)。

Go 的 GC 优化:通过 `GOGC` 调整 GC 触发比例(默认 100)。低延迟场景可设为 50(更频繁 GC):

GOGC=50 ./app

`GOMEMLIMIT`(Go 1.19+)设置内存上限,防止 OOM:

GOMEMLIMIT=2Gi ./app

Go 的锁竞争分析:`pprof.Lookup("mutex").WriteProfile()` 查看 `Lock`/`Unlock` 耗时。优化方案:减少锁粒度、使用 `sync.Map`、改用无锁数据结构(如 `ring.Buffer`)。

Go 的网络性能调优:调整 `net` 包参数(`TCPKeepAlive`、`ReadBuffer`、`WriteBuffer`),使用 `SetDeadline` 防止连接挂起:

conn.SetDeadline(time.Now().Add(5 * time.Second))

Go 的编译优化:Go 1.20+ 支持 `-race` 检测数据竞争(需编译时启用),`-buildmode=c-archive` 生成 C 静态库。

七、Go高频面试题解析:覆盖基础到架构

Go 面试常考知识点涵盖语言特性、并发模型、工程实践。精选高频问题与深度解答:

Q1:Go 中 `nil` slice 与空 slice 有何区别?
答:`var s []int` 是 `nil` slice,`make([]int, 0)` 是空 slice。二者 `len=0`,但 `nil` slice 不分配底层数组,内存占用更小。序列化时:JSON 编码 `nil` 为 `null`,空 slice 为 `[]`。

Q2:Go 的 `map` 是否线程安全?如何安全使用?
答:`map` 非线程安全,并发读写会 panic。解决方案:① 使用 `sync.RWMutex` 包装;② 改用 `sync.Map`(适合读多写少场景);③ 通过 channel 串行化访问。

Q3:Go 的 `defer` 执行时机与 return 值关系?
答:`defer` 在 `return` 表达式计算后、实际返回前执行。若 `return` 是命名返回值,`defer` 可修改其值:

func f() (i int) {
    defer func() { i++ }()
    return 0 // 实际返回 1
}

Q4:Go 的 `select` 有默认分支时是否阻塞?
答:有 `default` 分支时,若所有 channel 均不可用,立即执行 `default`,不阻塞。无 `default` 时,阻塞等待任一 channel 可用。

Q5:Go 的 `interface` 装箱开销?
答:接口变量包含类型指针与数据指针(24 字节),小对象(如 `int`)会逃逸到堆,引发 GC 压力。高频接口调用建议使用泛型替代。

Q6:Go 的 `context` 是否可复用?
答:`context` 不可复用。`context.WithCancel` 创建的 `cancel` 函数只能调用一次,重复调用无副作用但浪费资源。

Q7:Go 的 `time.Ticker` 如何安全停止?
答:必须消费 ticker 的 channel 直到关闭,否则 goroutine 泄漏。推荐模式:

ticker := time.NewTicker(time.Second)
go func() {
    defer ticker.Stop()
    for {
        select {
        case <-ticker.C:
            fmt.Println("tick")
        case <-ctx.Done():
            return
        }
    }
}()

Q8:Go 的 `append` 是否会修改原 slice?
答:若容量足够,`append` 修改原底层数组;若容量不足,分配新数组并复制,原 slice 不变。需注意:并发场景下修改底层数组可能引发竞争。

八、Go社区生态与前沿动态

Go 社区活跃度高,核心项目由 CNCF(云原生计算基金会)托管。关键项目包括:

Go 的最新动态(2024 年):

Go 的学习资源推荐:

Go 的职业发展路径:

Go 的局限性:

九、网友们都关心哪些问题?

基于社区提问数据整理,以下是与 Golang使用教程 高度相关的高频问题:

1. Go 和 Python 哪个更适合新手?

Go 语法更简洁、编译快、运行效率高,适合有编程基础的学习者;Python 语法更自然,库更丰富,适合零基础入门。若目标是后端开发或高并发系统,建议从 Go 入手。

2. Go 的内存泄漏如何排查?

使用 `pprof` 分析 heap profile,重点关注持续增长的 `inuse_space`;检查是否未关闭 channel、未取消 context、未释放资源(如数据库连接)。`go tool trace` 可追踪 goroutine 泄漏。

3. Go 能用于前端开发吗?

可通过 `gopherjs` 将 Go 编译为 JavaScript,但生态薄弱;更主流方案是 Go 开发后端 API,前端用 React/Vue。Go 1.22+ 支持 WebAssembly,可运行于浏览器端,适合计算密集型应用。

4. Go 的泛型性能如何?

Go 泛型在编译期展开,运行时无额外开销。但复杂约束(如接口嵌套)可能增加编译时间。实测:简单泛型容器性能与手写代码相当。

5. Go 适合做 AI 吗?

Go 缺乏成熟的深度学习框架(如 PyTorch),但可用于构建 AI 服务的后端、数据管道、模型部署。`gorgonia` 是 Go 的机器学习库,适合轻量级场景。

十、实战项目示例:构建高并发用户服务

以下为 Golang使用教程 中的完整项目案例,涵盖用户注册、登录、令牌刷新、限流鉴权等模块:

package main
import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "sync"
    "time"
    "golang.org/x/time/rate"
)
type User struct {
    ID       string `json:"id"`
    Email    string `json:"email"`
    Password string `json:"password"`
}
type Token struct {
    AccessToken  string `json:"access_token"`
    RefreshToken string `json:"refresh_token"`
    ExpiresIn    int    `json:"expires_in"`
}
var (
    users     = make(map[string]User)
    tokens    = make(map[string]Token)
    mu        sync.RWMutex
    limiter   = rate.NewLimiter(rate.Every(time.Second), 10)
)
func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/register", handleRegister)
    mux.HandleFunc("/login", handleLogin)
    mux.HandleFunc("/refresh", handleRefresh)
    log.Println("Server starting on :8080...")
    log.Fatal(http.ListenAndServe(":8080", mux))
}
func handleRegister(w http.ResponseWriter, r *http.Request) {
    if !limiter.Allow() {
        http.Error(w, "rate limit exceeded", http.StatusTooManyRequests)
        return
    }
    var u User
    if err := json.NewDecoder(r.Body).Decode(&u); err != nil {
        http.Error(w, "invalid JSON", http.StatusBadRequest)
        return
    }
    mu.Lock()
    defer mu.Unlock()
    if _, exists := users[u.Email]; exists {
        http.Error(w, "email already registered", http.StatusConflict)
        return
    }
    users[u.Email] = u
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(map[string]string{"message": "registered"})
}

该服务支持高并发场景:通过 `rate.Limiter` 限流、`sync.RWMutex` 保护共享数据、`context.Context` 实现超时控制。完整代码见 GitHub 仓库。

十一、学习路径建议:分阶段掌握 Go

新手入门(1-2周)
进阶提升(2-4周)
实战精通(1-2月)

阶段目标

掌握 Go 基础语法、标准库核心模块、并发模型,能编写简单命令行工具。

学习内容

  1. 变量、类型、控制结构
  2. 函数、结构体、接口
  3. 包管理与模块化
  4. 错误处理与 panic/recover
  5. goroutine 与 channel 基础
  6. 标准库:fmt、io、time、net/http

推荐练习

  • 实现简易计算器(支持加减乘除)
  • 文件内容统计(行数、单词数、字节数)
  • 并发爬取 10 个网页标题

阶段目标

构建 Web 应用、集成数据库、实现 RESTful API,理解工程化实践。

学习内容

  1. HTTP 服务与路由设计
  2. 数据库连接(MySQL/PostgreSQL)
  3. JSON 处理与表单验证
  4. 中间件开发与日志记录
  5. JWT 认证与权限控制
  6. 测试驱动开发(TDD)

推荐练习

  • 开发用户管理系统(增删改查)
  • 集成 Redis 实现缓存
  • 使用 Gin 框架重构 Web 服务

阶段目标

设计微服务架构、性能调优、参与开源贡献,具备生产级开发能力。

学习内容

  1. 微服务通信(gRPC/HTTP/消息队列)
  2. 服务发现与配置中心
  3. 分布式追踪(OpenTelemetry)
  4. 性能分析与 GC 优化
  5. Docker 与 K8s 部署
  6. CI/CD 流水线搭建

推荐练习

  • 实现订单-库存-用户微服务集群
  • 用 `pprof` 优化高并发接口
  • 为开源项目提交 PR

十二、附录:Go 速查表

功能 代码示例
变量声明 var x int = 10
y := 20
切片操作 s := []int{1,2,3}
s = append(s, 4)
s2 := s[1:3]
错误处理 if err != nil { return err }
并发同步 var wg sync.WaitGroup
wg.Add(1)
go func() { defer wg.Done() }()
wg.Wait()
上下文超时 ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
JSON 序列化 data, _ := json.Marshal(obj)
json.Unmarshal(data, &obj)
时间格式化 time.Now().Format("2006-01-02 15:04:05")
文件读取 data, _ := os.ReadFile("file.txt")