Go语言标准库常用包详解Go语言的标准库是其核心优势之一被誉为 Batteries Included包含电池的哲学理念。标准库不仅功能完善、性能优异而且设计优雅、文档详尽。熟练掌握标准库是每个Go开发者必备的基本功也是开发高质量Go应用的基础。本文将深入讲解Go语言标准库中最常用的核心包通过详细的代码示例帮助读者全面理解这些包的使用方法和最佳实践。一、fmt包格式化I/O的瑞士军刀fmt包是Go语言中最常用的包之一提供了格式化字符串和标准输入输出的功能。无论是调试打印、日志输出还是用户交互fmt包都是不可或缺的工具。1.1 基础打印函数fmt包提供了多种打印函数适用于不同的场景。Print系列函数直接输出到标准输出Println会在末尾添加换行符而Printf则支持格式化输出。package main import fmt func main() { name : Alice age : 28 score : 95.5 // Println直接打印自动添加换行 fmt.Println( Println 示例 ) fmt.Println(Hello, World!) fmt.Println(姓名:, name) fmt.Println(年龄:, age, 成绩:, score) // Print不换行打印 fmt.Print( Print 示例 \n) fmt.Print(姓名: , name, \n) // Printf格式化打印 fmt.Printf( Printf 示例 \n) fmt.Printf(大家好我叫%s今年%d岁成绩%.2f分\n, name, age, score) }1.2 格式化动词详解fmt包支持丰富的格式化动词掌握这些动词对于日常开发至关重要。package main import fmt type User struct { ID int Name string Age int } func main() { // 通用动词 u : User{ID: 1, Name: 张三, Age: 25} // %v输出值的默认格式 fmt.Printf(%%v: %v\n, u) // {1 张三 25} fmt.Printf(%%v: %v\n, u) // {ID:1 Name:张三 Age:25} fmt.Printf(%%#v: %#v\n, u) // main.User{ID:1, Name:张三, Age:25} // %T输出类型 fmt.Printf(%%T: %T\n, u) // main.User // %%输出百分号 fmt.Printf(百分比: 100%%\n) // 百分比: 100% // 宽度控制 num : 42 str : Go fmt.Printf(|%d|%-5d|%5d|\n, num, num, num) // |42|42 | 42| fmt.Printf(|%s|%-10s|%10s|\n, str, str, str) // |Go|Go | Go| // 浮点数精度 pi : 3.14159265 fmt.Printf(%.2f\n, pi) // 3.14 fmt.Printf(%.4f\n, pi) // 3.1416 // 指针 ptr : 100 fmt.Printf(指针: %p\n, ptr) // 指针: 0xc00000a0b8 fmt.Printf(指针: %x\n, ptr) // 指针: c00000a0b8 }1.3 字符串格式化进阶在处理字符串时fmt包提供了Sprintf函数可以将格式化的字符串赋值给变量这在构建动态字符串时非常有用。package main import fmt func main() { // Sprintf返回格式化字符串 template : INSERT INTO users (id, name, email) VALUES (%d, %s, %s); sql : fmt.Sprintf(template, 1, 张三, zhangsanexample.com) fmt.Println(sql) // 格式化布尔值 flag : true fmt.Printf(布尔值: %t\n, flag) // 格式化多个值 fmt.Printf(%[2]s 说%[1]s\n, 你好, 李四) // 李四 说你好 // %[1] 表示使用第一个参数%[2] 表示使用第二个参数 // 错误格式化 err : fmt.Errorf(数据库连接失败: %w, fmt.Errorf(连接超时)) fmt.Println(err) // 数据库连接失败: 连接超时 }1.4 标准输入处理fmt包还提供了丰富的输入处理函数可以读取用户输入或文件内容。package main import fmt func main() { // 声明变量接收输入 var name string var age int var salary float64 // 提示并读取字符串 fmt.Print(请输入姓名: ) fmt.Scanln(name) // 读取多个值 fmt.Print(请输入年龄和薪资: ) fmt.Scanf(%d %f, age, salary) fmt.Printf(姓名: %s, 年龄: %d, 薪资: %.2f\n, name, age, salary) // 使用Scan读取多个值空格分隔 fmt.Print(输入多个字符串: ) var s1, s2, s3 string fmt.Scan(s1, s2, s3) fmt.Printf(s1%s, s2%s, s3%s\n, s1, s2, s3) // Fscan从io.Reader读取 // Fscanln读取一行 // Fscanf格式化读取 }1.5 打印进阶自定义类型格式化通过实现fmt.Stringer接口可以自定义类型的字符串表示。package main import fmt type Color struct { R, G, B byte } func (c Color) String() string { return fmt.Sprintf(#%02x%02x%02x, c.R, c.G, c.B) } type Status int const ( StatusOK Status iota StatusError StatusPending ) func (s Status) String() string { switch s { case StatusOK: return OK case StatusError: return Error case StatusPending: return Pending default: return fmt.Sprintf(Unknown(%d), s) } } func main() { c : Color{255, 128, 64} fmt.Println(颜色:, c) // 颜色: #ff8040 s : StatusPending fmt.Println(状态:, s) // 状态: Pending }二、os包操作系统功能封装os包提供了访问操作系统功能的跨平台接口包括文件操作、进程管理、环境变量等。掌握os包是编写系统级程序和工具的基础。2.1 文件和目录操作package main import ( fmt os path/filepath ) func main() { // 创建目录 dir : /tmp/gotest err : os.MkdirAll(dir, 0755) if err ! nil { fmt.Println(创建目录失败:, err) return } fmt.Println(目录创建成功:, dir) // 创建文件 filePath : filepath.Join(dir, test.txt) file, err : os.Create(filePath) if err ! nil { fmt.Println(创建文件失败:, err) return } fmt.Println(文件创建成功:, file.Name()) // 写入内容 n, err : file.WriteString(Hello, Go!\n第二行内容) if err ! nil { fmt.Println(写入失败:, err) } fmt.Printf(写入 %d 字节\n, n) file.Close() // 读取文件 data, err : os.ReadFile(filePath) if err ! nil { fmt.Println(读取失败:, err) return } fmt.Println(文件内容:, string(data)) // 检查文件是否存在 if _, err : os.Stat(filePath); err nil { fmt.Println(文件存在) } else if os.IsNotExist(err) { fmt.Println(文件不存在) } // 重命名文件 newPath : filepath.Join(dir, test_renamed.txt) err os.Rename(filePath, newPath) if err ! nil { fmt.Println(重命名失败:, err) } else { fmt.Println(文件已重命名为:, newPath) } // 删除文件 err os.Remove(newPath) if err ! nil { fmt.Println(删除文件失败:, err) } else { fmt.Println(文件已删除) } // 删除目录 err os.RemoveAll(dir) if err ! nil { fmt.Println(删除目录失败:, err) } else { fmt.Println(目录已删除) } }2.2 环境变量操作package main import ( fmt os strings ) func main() { // 设置环境变量 os.Setenv(APP_ENV, production) os.Setenv(DEBUG, true) // 读取环境变量 env : os.Getenv(APP_ENV) fmt.Println(APP_ENV:, env) // 读取不存在的环境变量返回空字符串 missing : os.Getenv(NOT_EXIST) fmt.Println(NOT_EXIST:, missing, (长度:, len(missing), )) // 获取所有环境变量 fmt.Println(\n 所有环境变量 ) for _, env : range os.Environ() { // 跳过包含敏感词的环境变量 if strings.Contains(env, PASSWORD) || strings.Contains(env, SECRET) { continue } fmt.Println(env) } // 展开环境变量中的内容 os.Setenv(HOME_DIR, /home/user) os.Setenv(CONFIG_PATH, $HOME_DIR/config) expanded : os.ExpandEnv($CONFIG_PATH/app.yaml) fmt.Println(\n展开后的路径:, expanded) }2.3 进程操作package main import ( fmt os os/exec ) func main() { // 获取当前进程信息 pid : os.Getpid() ppid : os.Getppid() fmt.Printf(当前进程 PID: %d, 父进程 PPID: %d\n, pid, ppid) // 获取当前工作目录 cwd, err : os.Getwd() if err ! nil { fmt.Println(获取工作目录失败:, err) return } fmt.Println(当前工作目录:, cwd) // 改变当前工作目录 err os.Chdir(/tmp) if err ! nil { fmt.Println(切换目录失败:, err) } else { fmt.Println(已切换到 /tmp) } // 执行外部命令 cmd : exec.Command(ls, -la) cmd.Dir /tmp output, err : cmd.Output() if err ! nil { fmt.Println(执行命令失败:, err) return } fmt.Println(命令输出:\n, string(output)) // 执行带管道的命令 cmd exec.Command(sh, -c, ls -la | grep go) output, err cmd.Output() if err ! nil { fmt.Println(执行管道命令失败:, err) return } fmt.Println(管道命令输出:, string(output)) // 退出进程 // os.Exit(1) }2.4 文件权限和属性package main import ( fmt os time ) func main() { // 创建测试文件 file, err : os.Create(/tmp/attr_test.txt) if err ! nil { fmt.Println(创建文件失败:, err) return } file.WriteString(测试内容) file.Close() // 获取文件信息 info, err : os.Stat(/tmp/attr_test.txt) if err ! nil { fmt.Println(获取文件信息失败:, err) return } fmt.Printf(文件名: %s\n, info.Name()) fmt.Printf(文件大小: %d 字节\n, info.Size()) fmt.Printf(权限: %v\n, info.Mode()) fmt.Printf(修改时间: %v\n, info.ModTime()) fmt.Printf(是否为目录: %v\n, info.IsDir()) // 修改文件权限 err os.Chmod(/tmp/attr_test.txt, 0644) if err ! nil { fmt.Println(修改权限失败:, err) } else { fmt.Println(权限已修改为 0644) } // 修改时间戳 newTime : time.Date(2024, 1, 1, 0, 0, 0, 0, time.Local) err os.Chtimes(/tmp/attr_test.txt, newTime, newTime) if err ! nil { fmt.Println(修改时间戳失败:, err) } // 清理 os.Remove(/tmp/attr_test.txt) }三、io包I/O抽象的核心io包定义了I/O操作的基础接口是Go语言I/O系统的核心。通过这些抽象接口Go实现了高度解耦的I/O操作支持文件、网络、内存等多种数据源的统一处理。3.1 核心接口package main import ( bytes fmt io strings ) func main() { // Reader 接口 fmt.Println( Reader 接口 ) r : strings.NewReader(Hello, Go Reader!) buf : make([]byte, 8) for { n, err : r.Read(buf) fmt.Printf(读取 %d 字节: %q\n, n, string(buf[:n])) if err io.EOF { fmt.Println(数据读取完毕) break } if err ! nil { fmt.Println(读取错误:, err) break } } // Writer 接口 fmt.Println(\n Writer 接口 ) var buf bytes.Buffer n, err : buf.Write([]byte(写入数据)) if err ! nil { fmt.Println(写入错误:, err) } fmt.Printf(写入 %d 字节\n, n) fmt.Println(缓冲区内容:, buf.String()) // 组合 Reader 和 Writer fmt.Println(\n ReadWriter 示例 ) reader : strings.NewReader(来自 Reader 的数据) writer : new(bytes.Buffer) rw : io.MultiWriter(writer, buf) // 同时写入多个目标 tee : io.TeeReader(reader, writer) // 读取同时复制到 writer all, _ : io.ReadAll(tee) fmt.Println(TeeReader 结果:, string(all)) fmt.Println(MultiWriter 结果:, writer.String()) }3.2 便捷复制函数package main import ( fmt io os strings ) func main() { // Copy 复制数据 fmt.Println( Copy 示例 ) src : strings.NewReader(需要复制的内容) dst : new(strings.Builder) bytes, err : io.Copy(dst, src) if err ! nil { fmt.Println(复制失败:, err) return } fmt.Printf(复制了 %d 字节\n, bytes) fmt.Println(复制结果:, dst.String()) // CopyN 复制指定字节数 fmt.Println(\n CopyN 示例 ) src2 : strings.NewReader(ABCDEFGHIJKLMNOPQRSTUVWXYZ) dst2 : new(strings.Builder) bytes2, err : io.CopyN(dst2, src2, 10) if err ! nil { fmt.Println(CopyN 错误:, err) } fmt.Printf(复制了 %d 字节: %s\n, bytes2, dst2.String()) // 带缓冲的复制 fmt.Println(\n BufferCopy 示例 ) src3 : strings.NewReader(分块读取测试数据) dst3 : new(strings.Builder) buf : make([]byte, 5) // 5字节缓冲区 for { n, err : src3.Read(buf) dst3.Write(buf[:n]) if err io.EOF { break } } fmt.Println(最终结果:, dst3.String()) }3.3 字节和字符串操作package main import ( bytes fmt io strings ) func main() { // ReadAll 读取所有数据 fmt.Println( ReadAll 示例 ) r : strings.NewReader(完整内容) data, err : io.ReadAll(r) if err ! nil { fmt.Println(读取错误:, err) return } fmt.Println(读取的数据:, string(data)) // ReadByte 和 ReadBytes fmt.Println(\n ReadByte 示例 ) r2 : strings.NewReader(ABC) b, err : r2.ReadByte() if err ! nil { fmt.Println(读取错误:, err) } fmt.Printf(读取的字节: %c\n, b) // Buffer 缓冲区操作 fmt.Println(\n Buffer 示例 ) buf : bytes.NewBuffer(nil) buf.Grow(100) // 预分配容量 for i : 0; i 10; i { buf.WriteByte(byte(A i)) } fmt.Println(缓冲区内容:, buf.String()) fmt.Printf(缓冲区长度: %d, 容量: %d\n, buf.Len(), buf.Cap()) // 截断缓冲区 buf.Truncate(5) fmt.Println(截断后:, buf.String()) // 字符串拼接器 fmt.Println(\n strings.Builder 示例 ) var sb strings.Builder sb.Grow(50) for i : 0; i 5; i { sb.WriteString(块) sb.WriteByte(-) } result : sb.String() fmt.Println(拼接结果:, result) }四、time包时间处理的完整解决方案time包提供了Go语言中时间相关的所有操作包括时间获取、格式化、解析、时间计算、定时器等功能。4.1 时间基础操作package main import ( fmt time ) func main() { // 获取当前时间 now : time.Now() fmt.Printf(当前时间: %v\n, now) fmt.Printf(Unix 时间戳: %d\n, now.Unix()) fmt.Printf(Nano 时间戳: %d\n, now.UnixNano()) // 时间组件 fmt.Printf(年: %d, 月: %d, 日: %d\n, now.Year(), now.Month(), now.Day()) fmt.Printf(时: %d, 分: %d, 秒: %d\n, now.Hour(), now.Minute(), now.Second()) // 创建指定时间 fixed : time.Date(2024, 1, 15, 10, 30, 0, 0, time.Local) fmt.Printf(指定时间: %v\n, fixed) // 时间比较 t1 : time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC) t2 : time.Date(2024, 12, 31, 0, 0, 0, 0, time.UTC) fmt.Printf(t1 before t2: %v\n, t1.Before(t2)) fmt.Printf(t2 after t1: %v\n, t2.After(t1)) fmt.Printf(t1 equal t1: %v\n, t1.Equal(t1)) // 时间差计算 duration : t2.Sub(t1) fmt.Printf(时间差: %v\n, duration) fmt.Printf(天数: %.2f\n, duration.Hours()/24) }4.2 时间格式化与解析package main import ( fmt time ) func main() { // 格式化时间 now : time.Now() // 使用 ReferenceTime 格式化 fmt.Println( 时间格式化 ) fmt.Println(标准格式:, now.Format(2006-01-02 15:04:05)) fmt.Println(日期:, now.Format(2006-01-02)) fmt.Println(时间:, now.Format(15:04:05)) fmt.Println(ISO格式:, now.Format(time.RFC3339)) // 自定义格式 fmt.Printf(中文格式: %d年%02d月%02d日 %02d:%02d:%02d\n, now.Year(), now.Month(), now.Day(), now.Hour(), now.Minute(), now.Second()) // 解析时间字符串 fmt.Println(\n 时间解析 ) // 解析时必须指定参考时间的格式 parseStr : 2024-06-15 14:30:00 parsed, err : time.Parse(2006-01-02 15:04:05, parseStr) if err ! nil { fmt.Println(解析错误:, err) return } fmt.Println(解析结果:, parsed) // 解析 ISO 格式 isoStr : 2024-06-15T14:30:00Z parsedISO, err : time.Parse(time.RFC3339, isoStr) if err ! nil { fmt.Println(ISO解析错误:, err) return } fmt.Println(ISO解析结果:, parsedISO) // 解析带时区的时间 withZone : 2024-06-15 14:30:00 0800 parsedZone, err : time.Parse(2006-01-02 15:04:05 -0700, withZone) if err ! nil { fmt.Println(带时区解析错误:, err) return } fmt.Println(带时区解析结果:, parsedZone) }4.3 时间计算和定时器package main import ( fmt time ) func main() { now : time.Now() // 时间计算 fmt.Println( 时间计算 ) tomorrow : now.Add(24 * time.Hour) yesterday : now.Add(-24 * time.Hour) fmt.Printf(明天: %v\n, tomorrow.Format(2006-01-02)) fmt.Printf(昨天: %v\n, yesterday.Format(2006-01-02)) // 相对时间计算 nextWeek : now.AddDate(0, 0, 7) nextMonth : now.AddDate(0, 1, 0) nextYear : now.AddDate(1, 0, 0) fmt.Printf(一周后: %v\n, nextWeek.Format(2006-01-02)) fmt.Printf(一月后: %v\n, nextMonth.Format(2006-01-02)) fmt.Printf(一年后: %v\n, nextYear.Format(2006-01-02)) // 时间戳转换 fmt.Println(\n 时间戳转换 ) unix : now.Unix() fromUnix : time.Unix(unix, 0) fmt.Printf(Unix时间戳: %d\n, unix) fmt.Printf(从时间戳恢复: %v\n, fromUnix) // 定时器 fmt.Println(\n 定时器示例 ) timer : time.NewTimer(2 * time.Second) fmt.Println(等待2秒...) -timer.C fmt.Println(定时器触发!) // 一次性定时 fmt.Println(再次等待1秒...) -time.After(1 * time.Second) fmt.Println(After 触发!) // 周期定时器 fmt.Println(\n 周期定时器 ) ticker : time.NewTicker(500 * time.Millisecond) count : 0 for range ticker.C { count fmt.Printf(Tick %d\n, count) if count 5 { ticker.Stop() fmt.Println(定时器停止) break } } }五、strings包字符串操作利器strings包提供了丰富的字符串处理函数是日常开发中使用频率最高的包之一。5.1 基础查询操作package main import ( fmt strings ) func main() { s : Hello, Go Language! Go is great. // Contains 检查是否包含子串 fmt.Println( Contains 系列 ) fmt.Printf(包含 Go: %v\n, strings.Contains(s, Go)) fmt.Printf(包含 Python: %v\n, strings.Contains(s, Python)) fmt.Printf(包含任意字符 aeiou: %v\n, strings.ContainsAny(s, aeiou)) fmt.Printf(包含 Rune: %v\n, strings.ContainsRune(s, G)) // Count 统计出现次数 fmt.Printf(Go 出现次数: %d\n, strings.Count(s, Go)) // HasPrefix/HasSuffix 前缀后缀检查 fmt.Printf(以 Hello 开头: %v\n, strings.HasPrefix(s, Hello)) fmt.Printf(以 ! 结尾: %v\n, strings.HasSuffix(s, !)) // Index 查找位置 fmt.Printf(Go 首次出现位置: %d\n, strings.Index(s, Go)) fmt.Printf(Go 最后出现位置: %d\n, strings.LastIndex(s, Go)) fmt.Printf(任意字符 aeiou 首次出现: %d\n, strings.IndexAny(s, aeiou)) }5.2 字符串修改操作package main import ( fmt strings ) func main() { // 重复和连接 fmt.Println( 重复和连接 ) repeated : strings.Repeat(Go, 5) fmt.Println(Repeat:, repeated) // GoGoGoGoGo joined : strings.Join([]string{Hello, Go, World}, -) fmt.Println(Join:, joined) // Hello-Go-World // 大小写转换 fmt.Println(\n 大小写转换 ) s : Hello, Go! fmt.Println(ToLower:, strings.ToLower(s)) fmt.Println(ToUpper:, strings.ToUpper(s)) fmt.Println(ToTitle:, strings.ToTitle(s)) // 标题格式每个单词首字母大写 title : go language is great fmt.Println(Title:, strings.Title(title)) // 修整操作 fmt.Println(\n 修整操作 ) spaces : Hello, Go! fmt.Printf(Trim: %s\n, strings.Trim(spaces, )) fmt.Printf(TrimLeft: %s\n, strings.TrimLeft(spaces, )) fmt.Printf(TrimRight: %s\n, strings.TrimRight(spaces, )) fmt.Printf(TrimSpace: %s\n, strings.TrimSpace(spaces)) // 按指定字符修整 quoted : !!Hello!! fmt.Printf(Trim: %s\n, strings.Trim(quoted, !)) fmt.Printf(TrimPrefix: %s\n, strings.TrimPrefix(quoted, !)) fmt.Printf(TrimSuffix: %s\n, strings.TrimSuffix(quoted, !)) }5.3 字符串分割和替换package main import ( fmt strings ) func main() { // 分割 fmt.Println( 分割操作 ) csv : a,b,c,d,e fields : strings.Split(csv, ,) fmt.Printf(Split: %v\n, fields) fieldsAny : strings.SplitAfter(csv, ,) fmt.Printf(SplitAfter: %v\n, fieldsAny) fieldsN : strings.SplitN(csv, ,, 3) fmt.Printf(SplitN (n3): %v\n, fieldsN) // Fields 按空白字符分割 sentence : Go is simple words : strings.Fields(sentence) fmt.Printf(Fields: %v\n, words) // 替换 fmt.Println(\n 替换操作 ) text : Hello, World! World! fmt.Printf(Replace: %s\n, strings.Replace(text, World, Go, 1)) // 替换1次 fmt.Printf(ReplaceAll: %s\n, strings.ReplaceAll(text, World, Go)) // 替换所有 // Map 字符映射 mapping : strings.NewReplacer(Hello, Hi, World, Gopher) fmt.Printf(Replacer: %s\n, mapping.Replace(text)) }5.4 Builder 和 Readerpackage main import ( fmt strings ) func main() { // strings.Builder 高效拼接 fmt.Println( strings.Builder ) var builder strings.Builder builder.Grow(100) // 预分配容量 for i : 0; i 5; i { fmt.Fprintf(builder, Item %d, , i) } result : builder.String() fmt.Println(Builder 结果:, result) fmt.Printf(长度: %d, 容量: %d\n, builder.Len(), builder.Cap()) // strings.Reader 读取操作 fmt.Println(\n strings.Reader ) reader : strings.NewReader(Hello, Go Reader!) fmt.Printf(长度: %d\n, reader.Len()) fmt.Printf(剩余: %d\n, reader.Size()) // 读取前5个字节 b : make([]byte, 5) n, _ : reader.Read(b) fmt.Printf(Read %d bytes: %s\n, n, string(b)) // 读取后续内容 rest, _ : io.ReadAll(reader) fmt.Println(剩余内容:, string(rest)) // Reader 支持 Seek reader.Seek(0, 0) // 重置到开头 all, _ : io.ReadAll(reader) fmt.Println(全部内容:, string(all)) } // 引入 io 包用于 io.ReadAll import io六、encoding包数据编码处理Go的encoding包家族提供了JSON、XML、Base64、二进制等多种编码格式的支持是网络通信和数据存储的基础。6.1 JSON编解码package main import ( encoding/json fmt ) // 定义结构体 type User struct { ID int json:id Name string json:name Email string json:email,omitempty // 空值时忽略 Age int json:age Private string json:- // 永远忽略 } func main() { // 编码为 JSON fmt.Println( JSON 编码 ) user : User{ ID: 1, Name: 张三, Email: zhangsanexample.com, Age: 28, Private: 敏感信息, } // Marshal 编码为字节切片 data, err : json.Marshal(user) if err ! nil { fmt.Println(编码失败:, err) return } fmt.Printf(JSON: %s\n, string(data)) // MarshalIndent 格式化输出 indentData, err : json.MarshalIndent(user, , ) if err ! nil { fmt.Println(格式化编码失败:, err) return } fmt.Printf(格式化 JSON:\n%s\n, string(indentData)) // 解码 JSON fmt.Println(\n JSON 解码 ) jsonStr : {id: 2, name: 李四, email: lisiexample.com, age: 30} var user2 User err json.Unmarshal([]byte(jsonStr), user2) if err ! nil { fmt.Println(解码失败:, err) return } fmt.Printf(解码结果: ID%d, Name%s, Email%s, Age%d\n, user2.ID, user2.Name, user2.Email, user2.Age) // 解码到 map fmt.Println(\n 解码到 Map ) var result map[string]interface{} json.Unmarshal([]byte(jsonStr), result) fmt.Printf(Map 类型: %T\n, result) for k, v : range result { fmt.Printf( %s: %v (%T)\n, k, v, v) } // Encoder 直接输出到 writer fmt.Println(\n Encoder 示例 ) encoder : json.NewEncoder(os.Stdout) encoder.SetIndent(, ) encoder.Encode(user) } // 导入 os 包用于 Stdout import os // 修正后的完整 import import ( encoding/json fmt os )6.2 其他编码格式package main import ( encoding/base64 encoding/binary encoding/hex fmt os ) func main() { // Base64 编码 fmt.Println( Base64 编解码 ) original : []byte(Hello, Go!) encoded : base64.StdEncoding.EncodeToString(original) fmt.Println(Base64 编码:, encoded) decoded, err : base64.StdEncoding.DecodeString(encoded) if err ! nil { fmt.Println(解码错误:, err) return } fmt.Println(Base64 解码:, string(decoded)) // URL 安全的 Base64 urlEncoded : base64.URLEncoding.EncodeToString(original) fmt.Println(URL Base64:, urlEncoded) // Hex 编码 fmt.Println(\n Hex 编解码 ) hexStr : hex.EncodeToString(original) fmt.Println(Hex 编码:, hexStr) decodedHex, _ : hex.DecodeString(hexStr) fmt.Println(Hex 解码:, string(decodedHex)) // 二进制编码 fmt.Println(\n Binary 编码 ) buf : make([]byte, 8) binary.LittleEndian.PutUint64(buf, 123456789) fmt.Printf(二进制 (小端): %08x\n, buf) value : binary.BigEndian.Uint64(buf) fmt.Printf(大端读取: %d\n, value) } // 再次修正后的完整代码七、flag包命令行参数解析flag包提供了命令行参数和选项的解析功能是编写命令行工具的基础。7.1 基础参数解析package main import ( flag fmt ) func main() { // 定义不同类型的参数 name : flag.String(name, World, 打招呼的名字) age : flag.Int(age, 0, 年龄) married : flag.Bool(married, false, 是否已婚) // 使用指针方式定义参数 var addr string flag.StringVar(addr, addr, , 地址) // 解析命令行参数 flag.Parse() // 输出解析结果 fmt.Printf(姓名: %s\n, *name) fmt.Printf(年龄: %d\n, *age) fmt.Printf(已婚: %v\n, *married) fmt.Printf(地址: %s\n, addr) // 获取非选项参数 fmt.Println(\n非选项参数:) for i, arg : range flag.Args() { fmt.Printf( [%d]: %s\n, i, arg) } // 使用说明 fmt.Println(\n使用方式:) flag.PrintDefaults() }7.2 子命令和参数组package main import ( flag fmt ) func main() { // 创建全局参数组 globalFlag : flag.NewFlagSet(app, flag.ExitOnError) verbose : globalFlag.Bool(verbose, false, 详细输出) // 创建子命令参数组 serverFlag : flag.NewFlagSet(server, flag.ExitOnError) host : serverFlag.String(host, localhost, 服务器地址) port : serverFlag.Int(port, 8080, 端口号) clientFlag : flag.NewFlagSet(client, flag.ExitOnError) timeout : clientFlag.Int(timeout, 30, 超时时间(秒)) url : clientFlag.String(url, , 请求URL) if len(flag.Args()) 1 { fmt.Println(请指定子命令: server 或 client) return } globalFlag.Parse(flag.Args()) switch flag.Args()[0] { case server: serverFlag.Parse(flag.Args()[1:]) if *verbose { fmt.Printf(启动服务器: %s:%d\n, *host, *port) } fmt.Printf(服务器配置 - Host: %s, Port: %d\n, *host, *port) case client: clientFlag.Parse(flag.Args()[1:]) fmt.Printf(客户端配置 - Timeout: %d, URL: %s\n, *timeout, *url) if *verbose { fmt.Println(详细模式已启用) } default: fmt.Println(未知子命令) } }总结Go语言的标准库是其最宝贵的资产之一。本文详细讲解了最常用的几个核心包fmt包提供了完善的格式化I/O功能从基础打印到复杂格式化、从标准输入到自定义类型输出是日常开发不可或缺的工具。os包封装了操作系统功能提供跨平台的文件操作、目录管理、环境变量、进程控制等能力是编写系统工具的基础。io包通过抽象接口实现了高度解耦的I/O处理Reader/Writer接口和各种组合器让数据处理变得灵活高效。time包提供了完整的时间处理方案包括时间获取、格式化解析、时区转换、定时器等满足各种时间相关需求。strings包是字符串处理的利器提供查询、修改、分割、替换等丰富功能配合strings.Builder可实现高效字符串拼接。encoding包家族支持JSON、XML、Base64等多种编码格式是数据序列化和网络通信的基础。flag包提供了命令行参数解析的标准方案支持多种参数类型和子命令是构建CLI工具的首选。最佳实践建议优先使用标准库只有在标准库无法满足需求时才考虑第三方库熟悉接口而非具体实现如io.Reader/io.Writer等核心接口注意错误处理Go语言中错误是返回值需要认真对待使用sync.Pool等池化技术优化频繁的对象分配关注接口文档中的并发安全说明学习资源推荐官方文档https://pkg.go.dev/stdGo语言标准库源码https://github.com/golang/go/tree/master/src《The Go Programming Language》标准库章节Go语言中文网https://studygolang.com熟练掌握标准库不仅能提高开发效率还能帮助理解Go语言的设计哲学为学习第三方库和阅读源码打下坚实基础。