golang-基础-Go语言常用标准库
本文最后更新于 2025-07-25，文章内容可能已经过时。
Go语言的标准库（Standard Library）是其核心优势之一，提供了丰富的功能模块，涵盖从基础数据操作到网络编程、加密、并发控制等广泛领域。以下是Go语言标准库的详细分类及常用包的说明：
1. 数据处理
1.1 编码与序列化
encoding/...：提供多种数据格式的编码/解码功能。encoding/json：JSON数据的编码和解码。encoding/xml：XML数据的编码和解码。encoding/gob：Go特有的二进制序列化格式。encoding/base64：Base64编码和解码。
hash/...：哈希算法实现。hash/crc32,hash/adler32：校验和计算。hash/fnv：FNV哈希算法。
bytes：字节切片的操作（类似strings包）。strconv：字符串与基本数据类型（整型、浮点型等）的相互转换。
示例：
import "encoding/json"
data := map[string]int{"a": 1, "b": 2}
jsonBytes, _ := json.Marshal(data) // 转换为JSON字节
1.2 容器与集合
container/...：提供常用数据结构。container/heap：堆（优先队列）实现。container/list：双向链表。container/ring：环形缓冲区。
sort：排序和搜索功能（支持自定义排序逻辑）。
示例：
heapDemo.go
-----------------------------
package d0
// 定义任务结构体
type Task struct {
ID int
Priority int
}
// 实现 heap.Interface 接口
type TaskHeap []Task
func (h TaskHeap) Len() int { return len(h) }
func (h TaskHeap) Less(i, j int) bool { return h[i].Priority > h[j].Priority } // 最大堆
func (h TaskHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
// Push 和 Pop 方法必须使用指针接收者
func (h *TaskHeap) Push(x interface{}) {
*h = append(*h, x.(Task))
}
func (h *TaskHeap) Pop() interface{} {
old := *h
n := len(old)
item := old[n-1]
*h = old[0 : n-1]
return item
}
//main.go
// 初始化任务堆
tasks := &d0.TaskHeap{
{ID: 1, Priority: 5},
{ID: 2, Priority: 3},
{ID: 3, Priority: 8},
}
heap.Init(tasks)
// 添加新任务
heap.Push(tasks, d0.Task{ID: 4, Priority: 2})
heap.Push(tasks, d0.Task{ID: 5, Priority: 7})
// 按优先级取出任务
for tasks.Len() > 0 {
task := heap.Pop(tasks).(d0.Task)
fmt.Printf("ID: %d, Priority: %d\n", task.ID, task.Priority)
}
//list
// 创建双向链表
l := list.New()
// 添加元素
e4 := l.PushBack(4) // 从尾部插入
e1 := l.PushFront(1) // 从头部插入
l.InsertBefore(3, e4) // 在 e4 前插入
l.InsertAfter(2, e1) // 在 e1 后插入
// 遍历链表
fmt.Println("Forward traversal:")
for e := l.Front(); e != nil; e = e.Next() {
fmt.Print(e.Value, " ")
}
fmt.Println()
// 反向遍历
fmt.Println("Backward traversal:")
for e := l.Back(); e != nil; e = e.Prev() {
fmt.Print(e.Value, " ")
}
fmt.Println()
// 创建一个大小为 5 的环形链表
r := ring.New(5)
// 为每个节点赋值
for i := 0; i < r.Len(); i++ {
r.Value = i
r = r.Next() // 移动到下一个节点
}
// 遍历环形链表
fmt.Println("Ring elements:")
r.Do(func(p interface{}) {
fmt.Print(p.(int), " ")
})
fmt.Println()
// 使用 Move 方法移动位置
newPos := r.Move(2) // 向前移动 2 个位置
fmt.Println("Elements starting from position 2:")
newPos.Do(func(p interface{}) {
fmt.Print(p.(int), " ")
})
// 1. 排序字符串切片
strs := []string{"banana", "apple", "cherry"}
sort.Strings(strs)
fmt.Println("Sorted strings:", strs)
// 2. 排序整数切片
ints := []int{5, 2, 9, 1}
sort.Ints(ints)
fmt.Println("Sorted integers:", ints)
// 3. 自定义排序（按结构体字段）
type Person struct {
Name string
Age int
}
people := []Person{
{"Alice", 30},
{"Bob", 25},
{"Charlie", 35},
}
// 使用 sort.Slice 自定义排序规则
sort.Slice(people, func(i, j int) bool {
return people[i].Age < people[j].Age
})
fmt.Println("Sorted by age:", people)
// 4. 二分查找（需先排序）
index := sort.SearchInts([]int{1, 2, 3, 4, 5}, 3)
fmt.Println("Index of 3:", index)
2. 文件操作
2.1 基础文件操作
os：操作系统接口（文件读写、进程管理等）。path/filepath：跨平台的文件路径操作。io：基础输入输出接口（如Reader、Writer）。bufio：带缓冲的I/O操作（提高读写效率）。compress/...：压缩与解压。compress/gzip：GZIP压缩。compress/zlib：ZLIB压缩。
示例：
// 创建文件
file, err := os.Create("example.txt")
if err != nil {
panic(err)
}
defer file.Close()
// 写入内容
_, err = file.WriteString("Hello World,又是一只Gopher！\n")
if err != nil {
panic(err)
}
fmt.Println("File written successfully.")
// 获取环境变量
homeDir := os.Getenv("PATH")
fmt.Printf("Home directory: %s\n", homeDir)
// 设置环境变量（仅当前进程）
os.Setenv("MY_VAR", "123")
fmt.Printf("MY_VAR: %s\n", os.Getenv("MY_VAR"))
// 拼接路径（自动适配不同平台）
path := filepath.Join("data", "logs", "access.log")
fmt.Println("Constructed path:", path)
// 读取目录内容
dir, err := os.Open(".")
if err != nil {
panic(err)
}
defer dir.Close()
files, err := dir.Readdirnames(0) // 0 表示读取所有文件
if err != nil {
panic(err)
}
fmt.Println("Files in current directory:")
for _, f := range files {
fmt.Println(f)
}
//使用 io.Copy 复制文件
srcFile, err := os.Open("example.txt")
if err != nil {
panic(err)
}
defer srcFile.Close()
dstFile, err := os.Create("destination.txt")
if err != nil {
panic(err)
}
defer dstFile.Close()
// 使用 io.Copy 复制文件内容
_, err = io.Copy(dstFile, srcFile)
if err != nil {
panic(err)
}
//使用 bufio.Scanner 逐行读取
file, err := os.Open("example.txt")
if err != nil {
panic(err)
}
defer file.Close()
scanner := bufio.NewScanner(file)
for scanner.Scan() {
fmt.Println("Line:", scanner.Text())
}
if err := scanner.Err(); err != nil {
panic(err)
}
//GZIP 压缩与解压
// 打开源文件
srcFile, err := os.Open("example.txt")
if err != nil {
panic(err)
}
defer srcFile.Close()
// 创建压缩文件
dstFile, err := os.Create("example.txt.gz")
if err != nil {
panic(err)
}
defer dstFile.Close()
// 创建 GZIP Writer
gzipWriter := gzip.NewWriter(dstFile)
defer gzipWriter.Close()
// 复制并压缩数据
_, err = io.Copy(gzipWriter, srcFile)
if err != nil {
panic(err)
}
fmt.Println("File compressed successfully.")
//解压 GZIP 文件
// 打开压缩文件
srcFile, err := os.Open("example.txt.gz")
if err != nil {
panic(err)
}
defer srcFile.Close()
// 创建 GZIP Reader
reader, err := gzip.NewReader(srcFile)
if err != nil {
panic(err)
}
defer reader.Close()
// 创建目标文件
dstFile, err := os.Create("example_unzipped.txt")
if err != nil {
panic(err)
}
defer dstFile.Close()
// 解压并写入
_, err = io.Copy(dstFile, reader)
if err != nil {
panic(err)
}
fmt.Println("File decompressed successfully.")
//使用 ZLIB 压缩数据
// 打开源文件
srcFile, err := os.Open("example.txt")
if err != nil {
panic(err)
}
defer srcFile.Close()
// 创建目标文件
dstFile, err := os.Create("example.txt.zlib")
if err != nil {
panic(err)
}
defer dstFile.Close()
// 创建 ZLIB Writer
writer := zlib.NewWriter(dstFile)
defer writer.Close()
// 复制并压缩数据
_, err = io.Copy(writer, srcFile)
if err != nil {
panic(err)
}
fmt.Println("File compressed with ZLIB.")
//解压 ZLIB 文件
// 打开压缩文件
srcFile, err := os.Open("example.txt.zlib")
if err != nil {
panic(err)
}
defer srcFile.Close()
// 创建 ZLIB Reader
reader, err := zlib.NewReader(srcFile)
if err != nil {
panic(err)
}
defer reader.Close()
// 创建目标文件
dstFile, err := os.Create("example_unzipped_zlib.txt")
if err != nil {
panic(err)
}
defer dstFile.Close()
// 解压并写入
_, err = io.Copy(dstFile, reader)
if err != nil {
panic(err)
}
fmt.Println("File decompressed with ZLIB.")
3. 网络通信
3.1 网络协议支持
net：底层网络操作（TCP/UDP/HTTP等）。net/http：HTTP客户端和服务端实现（构建Web应用的核心）。net/url：URL解析和构造。net/smtp：SMTP协议实现（发送邮件）。net/rpc：远程过程调用（RPC）框架。net/http/httputil：HTTP工具（如反向代理）。
示例：
//TCP
//TcpDemo.go
package d0
import (
"bufio"
"fmt"
"net"
"os"
)
// TCP 服务器
func StartTCPServer() {
listener, err := net.Listen("tcp", ":8080")
if err != nil {
panic(err)
}
defer listener.Close()
fmt.Println("TCP Server started on :8080")
conn, err := listener.Accept()
if err != nil {
panic(err)
}
defer conn.Close()
scanner := bufio.NewScanner(conn)
for scanner.Scan() {
fmt.Printf("Received: %s\n", scanner.Text())
conn.Write([]byte("Message received\n"))
}
}
// TCP 客户端
func StartTCPClient() {
conn, err := net.Dial("tcp", "localhost:8080")
if err != nil {
panic(err)
}
defer conn.Close()
input := bufio.NewScanner(os.Stdin)
for input.Scan() {
conn.Write([]byte(input.Text() + "\n"))
resp, _ := bufio.NewReader(conn).ReadString('\n')
fmt.Print("Server response: " + resp)
}
}
//main
package main
import (
"errors"
"fmt"
"go-demo/d0"
"math"
)
func main() {
// 启动服务器和客户端（实际使用时应分两个独立程序运行）
go d0.StartTCPServer()
d0.StartTCPClient()
}
//HTTP 服务器
package main
import (
"fmt"
"net/http"
)
func helloHandler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello, World!\n")
}
func main() {
http.HandleFunc("/", helloHandler)
fmt.Println("HTTP Server started on :8080")
http.ListenAndServe(":8080", nil)
}
//HTTP 客户端发送 GET 请求
package main
import (
"fmt"
"io"
"net/http"
)
func main() {
resp, err := http.Get("http://localhost:8080")
if err != nil {
panic(err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
panic(err)
}
fmt.Println("Response Body:", string(body))
}
//解析和构造 URL
package main
import (
"fmt"
"net/url"
)
func main() {
// 解析 URL
rawURL := "https://example.com/path?query=123#fragment"
u, err := url.Parse(rawURL)
if err != nil {
panic(err)
}
fmt.Println("Scheme:", u.Scheme)
fmt.Println("Host:", u.Host)
fmt.Println("Path:", u.Path)
fmt.Println("Query:", u.Query().Get("query")) // 获取查询参数
fmt.Println("Fragment:", u.Fragment)
// 构造 URL
base, _ := url.Parse("https://example.com")
query := base.Query()
query.Set("page", "2")
base.RawQuery = query.Encode()
fmt.Println("Constructed URL:", base.String())
}
//通过 SMTP 发送邮件
package main
import (
"fmt"
"net/smtp"
)
func main() {
// 邮件配置
from := "sender@example.com"
to := []string{"recipient@example.com"}
subject := "Test Email"
body := "This is a test email sent via Go."
// SMTP 服务器配置（示例使用 Gmail）
smtpHost := "smtp.gmail.com"
smtpPort := "587"
auth := smtp.PlainAuth("", from, "your-password", smtpHost)
// 构造邮件
msg := []byte("To: " + to[0] + "\r\n" +
"Subject: " + subject + "\r\n" +
"\r\n" +
body + "\r\n")
// 发送邮件
err := smtp.SendMail(smtpHost+":"+smtpPort, auth, from, to, msg)
if err != nil {
panic(err)
}
fmt.Println("Email sent successfully.")
}
//RpcDemo.go
package d0
// 定义 RPC 参数结构体（字段首字母大写）
type Args struct {
A int
B int
}
// 定义 RPC 服务类型
type Arith int
// 实现 RPC 方法
func (t *Arith) Multiply(args *Args, reply *int) error {
*reply = args.A * args.B
return nil
}
////RPC 服务器
//main
package main
import (
"errors"
"fmt"
"go-demo/d0"
"math"
)
func main() {
arith := new(d0.Arith)
rpc.Register(arith) // 注册 RPC 服务
rpc.HandleHTTP() // 启用 HTTP 协议支持
fmt.Println("RPC Server started on :1234")
http.ListenAndServe(":1234", nil) // 使用 HTTP 监听
}
//RPC 客户端
package main
import (
"fmt"
"go-demo-client/d0"
"net/rpc"
)
func main() {
client, err := rpc.DialHTTP("tcp", "localhost:1234")
if err != nil {
panic(err)
}
args := &d0.Args{A: 3, B: 4} // 创建参数
var reply int
// 调用 RPC 方法（服务名.Method名）
err = client.Call("Arith.Multiply", args, &reply)
if err != nil {
panic(err)
}
fmt.Printf("Multiply result: %d\n", reply)
}
4. 加密与安全
4.1 加密算法
crypto/...：加密算法实现。crypto/md5,crypto/sha1,crypto/sha256：哈希算法。crypto/aes,crypto/rsa：对称/非对称加密。crypto/tls：TLS/SSL协议支持。crypto/x509：X.509证书解析。
crypto/rand：生成加密安全的随机数。
示例：
import "crypto/sha256"
hash := sha256.Sum256([]byte("Hello World,又是一只Gopher！"))
fmt.Printf("%x", hash)
5. 并发与同步
5.1 并发控制
sync：并发原语（互斥锁、等待组等）。sync.Mutex,sync.RWMutex：互斥锁。sync.WaitGroup：等待goroutine完成。sync.Once：确保函数只执行一次。
sync/atomic：原子操作（用于无锁并发）。runtime：运行时控制（如goroutine调度）。runtime/pprof：性能分析工具（CPU/内存剖析）。
示例：
//sync.Mutex 互斥锁
//MutexDemo.go
package d0
import "sync"
type Counter struct {
mu sync.Mutex
value int
}
func (c *Counter) Increment() {
c.mu.Lock()
defer c.mu.Unlock()
c.value++
}
func (c *Counter) Value() int {
c.mu.Lock()
defer c.mu.Unlock()
return c.value
}
//main
package main
import (
"fmt"
"go-demo-client/d0"
"sync"
)
func main() {
var counter d0.Counter
var wg sync.WaitGroup
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
defer wg.Done()
counter.Increment()
}()
}
wg.Wait()
fmt.Println("Final Counter Value:", counter.Value()) // 输出 1000
}
//sync.RWMutex 读写互斥锁
//RWMutexDemo.go
package d0
import "sync"
type Cache struct {
mu sync.RWMutex
Data map[string]string
}
func (c *Cache) Get(key string) string {
c.mu.RLock()
defer c.mu.RUnlock()
return c.Data[key]
}
func (c *Cache) Set(key, value string) {
c.mu.Lock()
defer c.mu.Unlock()
c.Data[key] = value
}
//main
package main
import (
"fmt"
"go-demo-client/d0"
"time"
)
func main() {
cache := &d0.Cache{Data: make(map[string]string)}
// 写操作
go cache.Set("key", "value666")
// 读操作
time.Sleep(time.Millisecond) // 确保写操作先执行
fmt.Println("Read value:", cache.Get("key")) // 输出 value666
}
//sync.WaitGroup 等待组
package main
import (
"fmt"
"sync"
"time"
)
func worker(id int, wg *sync.WaitGroup) {
defer wg.Done()
fmt.Printf("Worker %d starting\n", id)
time.Sleep(time.Second)
fmt.Printf("Worker %d done\n", id)
}
func main() {
var wg sync.WaitGroup
for i := 1; i <= 3; i++ {
wg.Add(1)
go worker(i, &wg)
}
wg.Wait()
fmt.Println("All workers completed")
}
//sync.Once 单次执行
//OnceDemo.go
package d0
import (
"fmt"
"sync"
)
var once sync.Once
var Instance *Singleton
type Singleton struct{}
func GetInstance() *Singleton {
once.Do(func() {
Instance = &Singleton{}
fmt.Println("Creating singleton instance")
})
return Instance
}
//main
package main
import (
"fmt"
"go-demo-client/d0"
"sync"
)
func main() {
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
wg.Add(1)
go func() {
defer wg.Done()
d0.GetInstance()
}()
}
wg.Wait()
fmt.Println("Final instance:", d0.Instance)
}
//sync/atomic 原子操作
package main
import (
"fmt"
"runtime"
"sync/atomic"
)
var counter int64
func main() {
var wg sync.WaitGroup
for i := 0; i < 1000; i++ {
wg.Add(1)
go func() {
defer wg.Done()
atomic.AddInt64(&counter, 1)
}()
}
wg.Wait()
fmt.Println("Final Counter Value:", counter) // 输出 1000
}
//runtime 调度控制
package main
import (
"fmt"
"runtime"
"time"
)
func main() {
// 设置最大处理器数
runtime.GOMAXPROCS(2)
// 启动多个goroutine
for i := 0; i < 3; i++ {
go func(id int) {
for {
fmt.Printf("Goroutine %d is running\n", id)
runtime.Gosched() // 主动让出CPU时间片
time.Sleep(time.Millisecond * 100)
}
}(i)
}
// 防止主函数退出
time.Sleep(time.Second * 5)
}
//runtime/pprof 性能分析
package main
import (
"runtime"
"runtime/pprof"
"os"
"time"
"sync"
)
func main() {
// 创建CPU profile文件
f, err := os.Create("cpu.prof")
if err != nil {
panic(err)
}
defer f.Close()
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
// 创建内存 profile 文件
mf, err := os.Create("mem.prof")
if err != nil {
panic(err)
}
defer mf.Close()
defer pprof.WriteHeapProfile(mf)
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
go func() {
defer wg.Done()
time.Sleep(time.Second)
}()
}
wg.Wait()
}
6. 时间与定时
time：时间处理（获取当前时间、定时器、延时等）。time.Now()：获取当前时间。time.Sleep()：延时。time.Ticker：周期性定时器。time.Parse：时间格式化。
示例：
package main
import (
"fmt"
"time"
)
func main() {
// 获取当前时间
now := time.Now()
// 以默认格式输出时间（可读性较强）
fmt.Println("当前时间（默认格式）:", now)
// 使用特定格式格式化输出时间
// 参考时间格式为 "2006-01-02 15:04:05"
formattedTime := now.Format("2006-01-02 15:04:05")
fmt.Println("当前时间（自定义格式）:", formattedTime)
// 获取 Unix 时间戳（秒）
unixTimestamp := now.Unix()
fmt.Println("Unix 时间戳（秒）:", unixTimestamp)
}
package main
import (
"fmt"
"time"
)
func main() {
fmt.Println("开始等待...")
// 延迟 2 秒
time.Sleep(2 * time.Second)
fmt.Println("等待结束！")
}
//time.Ticker：周期性定时器
package main
import (
"fmt"
"time"
)
func main() {
// 创建一个每 500 毫秒触发一次的定时器
ticker := time.NewTicker(500 * time.Millisecond)
defer ticker.Stop()
// 定义一个计数器，触发 3 次后退出
count := 0
maxCount := 3
for {
// 从定时器的 Channel 接收时间信号
<-ticker.C
count++
fmt.Println("定时器触发第", count, "次，当前时间:", time.Now().Format("15:04:05"))
// 达到指定次数后退出循环
if count >= maxCount {
break
}
}
}
//time.Parse：字符串解析为时间
package main
import (
"fmt"
"time"
)
func main() {
// 定义一个时间字符串
dateString := "2023-10-05 14:30:00"
// 定义与时间字符串匹配的布局
// 注意：布局必须基于参考时间 "2006-01-02 15:04:05"
layout := "2006-01-02 15:04:05"
// 解析时间字符串
parsedTime, err := time.Parse(layout, dateString)
if err != nil {
fmt.Println("解析失败:", err)
return
}
// 输出解析后的时间
fmt.Println("解析后的时间:", parsedTime)
fmt.Println("格式化后的时间:", parsedTime.Format("2006-01-02 15:04:05"))
}
//错误处理示例（解析失败）
package main
import (
"fmt"
"time"
)
func main() {
dateString := "2023/10/05 14:30:00" // 使用斜杠分隔符
layout := "2006-01-02 15:04:05" // 与字符串格式不一致
parsedTime, err := time.Parse(layout, dateString)
if err != nil {
fmt.Println("解析失败:", err)
return
}
fmt.Println("解析后的时间:", parsedTime)
}
7. 文本处理
7.1 字符串与正则
strings：字符串操作（查找、替换、分割等）。unicode/utf8：UTF-8编码处理。regexp：正则表达式匹配。text/template：文本模板生成（支持变量替换）。
示例：
import "strings"
fmt.Println(strings.Replace("hello world", "world", "Go", -1))
8. 其他实用工具
fmt：格式化输入输出（如fmt.Println、fmt.Sprintf）。log：日志记录（支持文件日志、日志级别）。errors：错误处理（errors.New、fmt.Errorf）。math：数学函数（三角函数、指数运算等）。flag：命令行参数解析。context：上下文管理（用于取消goroutine或传递请求范围的值）。
示例：
import "fmt"
fmt.Printf("Name: %s, Age: %d\n", "Alice", 30)
9. 测试与调试
testing：单元测试框架（支持基准测试、覆盖率分析）。testify/assert：第三方断言库（常与testing配合使用）。go test：命令行工具（运行测试、生成覆盖率报告）。
示例：
import "testing"
func TestAdd(t *testing.T) {
if Add(2, 3) != 5 {
t.Fail()
}
}
10. HTML处理
html：HTML转义与模板处理。html.EscapeString：防止XSS攻击的HTML转义。html/template：安全生成HTML内容（自动转义特殊字符）。
示例：
import "html"
fmt.Println(html.EscapeString("<script>alert('xss')</script>"))
// 输出: <script>alert('xss')</script>
阅读建议
评论
匿名评论
隐私政策
你无需删除空行，直接评论以获取最佳展示效果
