Golang编程完全指南
一、Go语言概述
1.1 语言简介
Go(又称Golang)是由Google的Robert Griesemer、Rob Pike和Ken Thompson于2007年开始设计,并于2009年正式发布的开源编程语言。
设计目标:
- 解决C++和Java等语言在大型项目开发中的编译速度慢、依赖管理复杂等问题
- 提供一种兼具开发效率和执行性能的现代化语言
- 天生为多核处理器和网络编程而设计
核心特性:
| 特性 |
说明 |
| 简洁性 |
语法精炼,关键字仅25个,无继承、无泛型(Go 1.18前)、无异常 |
| 并发原生支持 |
Goroutine(轻量级协程)和Channel,基于CSP模型 |
| 静态类型 |
编译时类型检查,类型安全 |
| 编译型 |
直接编译为机器码,无需虚拟机,启动快 |
| 垃圾回收 |
自动内存管理,降低内存泄漏风险 |
| 标准库丰富 |
内置HTTP、JSON、加密、数据库等常用功能 |
1.2 安装与配置
Linux 安装:
wget https://go.dev/dl/go1.22.0.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.22.0.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin
export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin
go version
macOS 安装:
Windows 安装:
下载 .msi 安装包,双击安装,自动配置环境变量
1.3 开发环境与IDE
| IDE/编辑器 |
特点 |
| VS Code + Go插件 |
最流行,免费,功能完善 |
| GoLand |
JetBrains出品,功能最强大,商业软件 |
| Vim/Neovim + vim-go |
轻量高效,适合服务器环境 |
VS Code Go插件常用功能:
- 代码自动补全(gopls)
- 代码格式化(gofmt)
- 静态分析(go vet)
- 调试支持(delve)
- 测试运行
1.4 Go项目结构
myproject/
├── go.mod # 模块定义文件
├── go.sum # 依赖校验文件
├── main.go # 程序入口
├── cmd/ # 可执行程序入口
│ └── myapp/
│ └── main.go
├── internal/ # 私有包(不可被外部导入)
│ └── config/
│ └── config.go
├── pkg/ # 可被外部导入的公共库
│ └── utils/
│ └── helper.go
├── api/ # API定义(如protobuf)
├── configs/ # 配置文件
├── scripts/ # 构建脚本
├── test/ # 额外的测试数据
└── docs/ # 文档
1.5 第一个Go程序
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
编译与运行:
go run main.go
go build -o hello main.go
./hello
GOOS=windows GOARCH=amd64 go build -o hello.exe main.go
1.6 版本历史
| 版本 |
发布时间 |
主要特性 |
| Go 1.0 |
2012年3月 |
首个稳定版,兼容性承诺 |
| Go 1.5 |
2015年8月 |
自举编译器(Go编译Go),并发GC |
| Go 1.11 |
2018年8月 |
Go Modules(依赖管理) |
| Go 1.13 |
2019年9月 |
错误包装(Error Wrapping) |
| Go 1.16 |
2021年2月 |
嵌入静态文件(embed) |
| Go 1.18 |
2022年3月 |
泛型(Generics)、模糊测试(Fuzzing) |
| Go 1.21 |
2023年8月 |
新的slices/maps包、结构化日志slog |
| Go 1.22 |
2024年2月 |
for循环变量语义改变、增强路由 |
二、基础语法详解
2.1 变量声明与初始化
Go语言提供多种变量声明方式,每种方式有其适用的场景。
package main
import "fmt"
var globalVar string = "全局变量"
var (
name string = "Go"
version int = 22
debug bool = false
)
func main() {
var a int = 10
var b string = "hello"
var c = 3.14
var d = true
e := 42
f := "world"
var g int
var h string
var i bool
var j float64
x, y := 1, 2
var m, n int = 3, 4
fmt.Println(a, b, c, d, e, f, g, h, i, j, x, y, m, n)
}
零值(Zero Value)对照表:
| 类型 |
零值 |
| int, int8, int16, int32, int64 |
0 |
| uint, uint8, uint16, uint32, uint64 |
0 |
| float32, float64 |
0.0 |
| bool |
false |
| string |
“” |
| pointer, slice, map, channel, interface, function |
nil |
| struct |
所有字段均为零值 |
2.2 常量
package main
import "fmt"
const PI = 3.1415926
const (
StatusOK = 200
StatusNotFound = 404
StatusError = 500
)
const (
Sunday = iota
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
)
const (
FlagRead = 1 << iota
FlagWrite
FlagExecute
)
const (
_ = iota
KB = 1 << (10 * iota)
MB
GB
TB
)
func main() {
fmt.Println("PI:", PI)
fmt.Println("Sunday:", Sunday, "Saturday:", Saturday)
fmt.Println("FlagRead:", FlagRead, "FlagWrite:", FlagWrite)
fmt.Printf("KB=%d, MB=%d, GB=%d\n", KB, MB, GB)
}
2.3 基本数据类型
Go语言的数据类型体系完整,每种类型都有明确的取值范围和内存占用。
package main
import (
"fmt"
"unsafe"
)
func main() {
var i8 int8 = 127
var i16 int16 = 32767
var i32 int32 = 2147483647
var i64 int64 = 9223372036854775807
var ui8 uint8 = 255
var ui16 uint16 = 65535
var n int = 100
var b byte = 'A'
var r rune = '中'
fmt.Printf("int8: 值=%d, 大小=%d字节\n", i8, unsafe.Sizeof(i8))
fmt.Printf("uint8: 值=%d, 大小=%d字节\n", ui8, unsafe.Sizeof(ui8))
fmt.Printf("byte: 值=%d(字符%c), 大小=%d字节\n", b, b, unsafe.Sizeof(b))
fmt.Printf("rune: 值=%d(字符%c), 大小=%d字节\n", r, r, unsafe.Sizeof(r))
fmt.Printf("int: 值=%d, 大小=%d字节\n", n, unsafe.Sizeof(n))
var f32 float32 = 3.141592653589793
var f64 float64 = 3.141592653589793
fmt.Printf("float32: %f, float64: %.15f\n", f32, f64)
var nan = float64(0) / float64(0)
var inf = float64(1) / float64(0)
fmt.Printf("NaN: %v, +Inf: %v\n", nan, inf)
var c64 complex64 = 1 + 2i
var c128 complex128 = 3 + 4i
fmt.Printf("complex64: %v, 实部=%f, 虚部=%f\n",
c64, real(c64), imag(c64))
fmt.Printf("complex128: %v\n", c128)
var flag bool = true
fmt.Println("bool:", flag)
var s1 string = "Hello, Go!"
var s2 string = `多行字符串
可以包含"引号"
和换行符`
fmt.Println("string1:", s1)
fmt.Println("string2:", s2)
fmt.Printf("s1长度: %d字节\n", len(s1))
chinese := "你好Go"
fmt.Println("按字节遍历:")
for i := 0; i < len(chinese); i++ {
fmt.Printf("%x ", chinese[i])
}
fmt.Println()
fmt.Println("按Unicode字符遍历:")
for i, ch := range chinese {
fmt.Printf("索引%d: %c ", i, ch)
}
fmt.Println()
}
2.4 类型转换
Go语言不支持隐式类型转换,所有类型转换必须显式进行。
package main
import (
"fmt"
"strconv"
)
func main() {
var a int = 100
var b int64 = int64(a)
var c float64 = float64(a)
var d uint = uint(a)
fmt.Println(a, b, c, d)
var big int16 = 300
var small int8 = int8(big)
fmt.Printf("big=%d, small=%d(溢出)\n", big, small)
s1 := strconv.Itoa(42)
s2 := strconv.FormatFloat(3.14159, 'f', 2, 64)
s3 := strconv.FormatBool(true)
fmt.Println(s1, s2, s3)
n1, err1 := strconv.Atoi("42")
n2, err2 := strconv.ParseFloat("3.14", 64)
n3, err3 := strconv.ParseBool("true")
fmt.Println(n1, err1, n2, err2, n3, err3)
str := "Hello"
bytes := []byte(str)
str2 := string(bytes)
fmt.Println(bytes, str2)
var val interface{} = "hello"
s, ok := val.(string)
if ok {
fmt.Println("字符串值:", s)
}
result := fmt.Sprintf("%d-%s-%.2f", 2024, "Jan", 3.14159)
fmt.Println(result)
}
2.5 运算符
package main
import "fmt"
func main() {
a, b := 10, 3
fmt.Printf("a+b=%d, a-b=%d, a*b=%d, a/b=%d, a%%b=%d\n",
a+b, a-b, a*b, a/b, a%b)
fmt.Printf("a==b: %v, a!=b: %v, a>b: %v, a<b: %v\n",
a == b, a != b, a > b, a < b)
x, y := true, false
fmt.Printf("x&&y=%v, x||y=%v, !x=%v\n", x && y, x || y, !x)
var m uint = 0b1100
var n uint = 0b1010
fmt.Printf("m&n=%b(%d)\n", m&n, m&n)
fmt.Printf("m|n=%b(%d)\n", m|n, m|n)
fmt.Printf("m^n=%b(%d)\n", m^n, m^n)
fmt.Printf("m<<1=%b(%d)\n", m<<1, m<<1)
fmt.Printf("m>>1=%b(%d)\n", m>>1, m>>1)
num := 10
num += 5
num -= 3
num *= 2
num /= 4
num %= 4
fmt.Println("num:", num)
value := 42
ptr := &value
fmt.Printf("value=%d, ptr=%p, *ptr=%d\n", value, ptr, *ptr)
*ptr = 100
fmt.Printf("修改后 value=%d\n", value)
result := 10 + 5*2
fmt.Println("10+5*2 =", result)
}
2.6 控制流
package main
import "fmt"
func main() {
score := 85
if score >= 90 {
fmt.Println("优秀")
} else if score >= 80 {
fmt.Println("良好")
} else if score >= 60 {
fmt.Println("及格")
} else {
fmt.Println("不及格")
}
if password := "secret123"; len(password) < 8 {
fmt.Println("密码太短")
} else {
fmt.Println("密码长度符合要求")
}
day := 3
switch day {
case 1:
fmt.Println("星期一")
case 2:
fmt.Println("星期二")
case 3:
fmt.Println("星期三")
default:
fmt.Println("其他")
}
switch day {
case 1, 2, 3, 4, 5:
fmt.Println("工作日")
case 6, 7:
fmt.Println("周末")
}
age := 25
switch {
case age < 18:
fmt.Println("未成年")
case age >= 18 && age < 60:
fmt.Println("成年人")
default:
fmt.Println("老年人")
}
n := 1
switch n {
case 1:
fmt.Println("one")
fallthrough
case 2:
fmt.Println("two")
default:
fmt.Println("default")
}
var val interface{} = "hello"
switch v := val.(type) {
case int:
fmt.Printf("整数: %d\n", v)
case string:
fmt.Printf("字符串: %s\n", v)
case bool:
fmt.Printf("布尔值: %v\n", v)
default:
fmt.Printf("未知类型: %T\n", v)
}
for i := 0; i < 5; i++ {
fmt.Print(i, " ")
}
fmt.Println()
j := 0
for ; j < 5; j++ {
fmt.Print(j, " ")
}
fmt.Println()
k := 0
for k < 5 {
fmt.Print(k, " ")
k++
}
fmt.Println()
fruits := []string{"apple", "banana", "cherry"}
for index, fruit := range fruits {
fmt.Printf("索引: %d, 水果: %s\n", index, fruit)
}
for _, fruit := range fruits {
fmt.Println(fruit)
}
for index := range fruits {
fmt.Println(index)
}
scores := map[string]int{"Alice": 90, "Bob": 85}
for name, score := range scores {
fmt.Printf("%s: %d分\n", name, score)
}
str := "你好Go"
for i, ch := range str {
fmt.Printf("索引%d: %c(%U)\n", i, ch, ch)
}
for i := 0; i < 10; i++ {
if i == 5 {
break
}
if i%2 == 0 {
continue
}
fmt.Print(i, " ")
}
fmt.Println()
outer:
for i := 0; i < 3; i++ {
for j := 0; j < 3; j++ {
if i == 1 && j == 1 {
break outer
}
fmt.Printf("(%d,%d) ", i, j)
}
}
fmt.Println()
n := 0
loop:
if n < 3 {
fmt.Print(n, " ")
n++
goto loop
}
fmt.Println()
}
2.7 函数定义
package main
import (
"errors"
"fmt"
)
func add(a int, b int) int {
return a + b
}
func multiply(a, b int) int {
return a * b
}
func divide(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New("除数不能为零")
}
return a / b, nil
}
func split(sum int) (x, y int) {
x = sum * 4 / 9
y = sum - x
return
}
func sum(nums ...int) int {
total := 0
for _, num := range nums {
total += num
}
return total
}
func apply(nums []int, fn func(int) int) []int {
result := make([]int, len(nums))
for i, v := range nums {
result[i] = fn(v)
}
return result
}
func makeAdder(base int) func(int) int {
return func(n int) int {
return base + n
}
}
var greet = func(name string) string {
return "Hello, " + name
}
func main() {
fmt.Println("add(3,5):", add(3, 5))
fmt.Println("multiply(4,6):", multiply(4, 6))
result, err := divide(10, 3)
if err != nil {
fmt.Println("错误:", err)
} else {
fmt.Printf("divide(10,3): %.2f\n", result)
}
x, y := split(17)
fmt.Printf("split(17): x=%d, y=%d\n", x, y)
fmt.Println("sum(1,2,3,4,5):", sum(1, 2, 3, 4, 5))
doubled := apply([]int{1, 2, 3, 4}, func(n int) int {
return n * 2
})
fmt.Println("doubled:", doubled)
add5 := makeAdder(5)
fmt.Println("add5(10):", add5(10))
fmt.Println("add5(20):", add5(20))
fmt.Println(greet("Go"))
func(msg string) {
fmt.Println("匿名函数:", msg)
}("Hello!")
}
2.8 defer、panic、recover
package main
import "fmt"
func main() {
fmt.Println("开始")
defer fmt.Println("defer 1(最先注册,最后执行)")
defer fmt.Println("defer 2(其次注册,其次执行)")
defer fmt.Println("defer 3(最后注册,最先执行)")
fmt.Println("结束")
x := 1
defer fmt.Println("defer 捕获的 x =", x)
x = 100
safeDivide()
fmt.Println("程序继续执行...")
}
func safeDivide() {
defer func() {
if r := recover(); r != nil {
fmt.Printf("捕获到 panic: %v\n", r)
}
}()
fmt.Println("即将触发 panic...")
panic("手动触发 panic")
fmt.Println("这行不会被执行")
}
三、复合类型
3.1 数组(Array)
数组是固定长度、相同类型元素的集合。
package main
import "fmt"
func main() {
var arr1 [5]int
arr2 := [3]string{"Go", "Python", "JS"}
arr3 := [...]int{1, 2, 3, 4}
arr4 := [5]int{0: 10, 4: 50}
fmt.Println("arr1:", arr1)
fmt.Println("arr2:", arr2)
fmt.Println("arr3:", arr3, "长度:", len(arr3))
fmt.Println("arr4:", arr4)
arr1[0] = 100
arr1[4] = 200
fmt.Println("修改后 arr1:", arr1)
for i := 0; i < len(arr2); i++ {
fmt.Printf("arr2[%d] = %s\n", i, arr2[i])
}
original := [3]int{1, 2, 3}
copyArr := original
copyArr[0] = 999
fmt.Println("original:", original)
fmt.Println("copyArr:", copyArr)
modifyArray(&original)
fmt.Println("传递指针后 original:", original)
matrix := [3][4]int{
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12},
}
fmt.Println("matrix:", matrix)
fmt.Println("matrix[1][2]:", matrix[1][2])
}
func modifyArray(arr *[3]int) {
arr[0] = 100
}
3.2 切片(Slice)
切片是Go中最常用的数据结构,是对数组的动态视图。
package main
import "fmt"
func main() {
s1 := []int{1, 2, 3, 4, 5}
s2 := make([]int, 5)
s3 := make([]int, 3, 10)
arr := [5]int{10, 20, 30, 40, 50}
s4 := arr[1:4]
s5 := arr[:3]
s6 := arr[2:]
fmt.Println("s1:", s1)
fmt.Println("s2:", s2)
fmt.Println("s3:", s3, "len:", len(s3), "cap:", cap(s3))
fmt.Println("s4:", s4)
fmt.Println("s5:", s5)
fmt.Println("s6:", s6)
s := []int{1, 2, 3, 4, 5}
s = append(s, 6)
s = append(s, 7, 8, 9)
fmt.Println("append后:", s)
s1 := []int{1, 2}
s2 := []int{3, 4}
s1 = append(s1, s2...)
fmt.Println("合并后:", s1)
src := []int{1, 2, 3, 4, 5}
dst := make([]int, 3)
n := copy(dst, src)
fmt.Println("copy后 dst:", dst, "复制了:", n, "个")
s = []int{1, 2, 3, 4, 5}
index := 2
s = append(s[:index], s[index+1:]...)
fmt.Println("删除索引2后:", s)
s = []int{1, 2, 3, 4, 5}
index = 2
value := 99
s = append(s[:index], append([]int{value}, s[index:]...)...)
fmt.Println("插入99后:", s)
base := []int{1, 2, 3, 4, 5}
sub := base[1:4]
sub[0] = 999
fmt.Println("base:", base)
fmt.Println("sub:", sub)
fmt.Println("容量演示:")
capSlice := make([]int, 0)
for i := 0; i < 10; i++ {
capSlice = append(capSlice, i)
fmt.Printf("len=%d, cap=%d\n", len(capSlice), cap(capSlice))
}
}
3.3 Map
package main
import "fmt"
func main() {
m1 := make(map[string]int)
m2 := map[string]int{
"apple": 5,
"banana": 3,
"cherry": 7,
}
m3 := make(map[string]int, 100)
fmt.Println("m1:", m1)
fmt.Println("m2:", m2)
fmt.Println("m3:", m3)
m2["date"] = 10
m2["apple"] = 99
fmt.Println("添加/修改后:", m2)
fmt.Println("apple:", m2["apple"])
value, exists := m2["orange"]
if exists {
fmt.Println("orange存在,值:", value)
} else {
fmt.Println("orange不存在,零值:", value)
}
delete(m2, "banana")
fmt.Println("删除banana后:", m2)
fmt.Println("元素个数:", len(m2))
for key, value := range m2 {
fmt.Printf(" %s -> %d\n", key, value)
}
var nilMap map[string]int
fmt.Println("nilMap[\"key\"] =", nilMap["key"])
}
3.4 结构体(Struct)
package main
import (
"encoding/json"
"fmt"
)
type Person struct {
Name string
Age int
Email string
private string
}
func (p Person) Greet() string {
return fmt.Sprintf("你好,我是%s,今年%d岁", p.Name, p.Age)
}
func (p *Person) Birthday() {
p.Age++
}
func (p *Person) SetEmail(email string) {
p.Email = email
}
type User struct {
ID int `json:"id"`
Username string `json:"username"`
Password string `json:"-"`
Age int `json:"age,omitempty"`
}
func main() {
p1 := Person{
Name: "张三",
Age: 30,
Email: "zhangsan@example.com",
}
p2 := Person{"李四", 25, "lisi@example.com", "secret"}
var p3 Person
p3.Name = "王五"
p3.Age = 35
fmt.Println("p1:", p1)
fmt.Println("p2:", p2)
fmt.Println("p3:", p3)
fmt.Println("p1.Name:", p1.Name)
ptr := &p1
fmt.Println("ptr.Name:", ptr.Name)
fmt.Println(p1.Greet())
p1.Birthday()
fmt.Println("生日后年龄:", p1.Age)
user := User{ID: 1, Username: "gopher", Age: 0}
data, _ := json.Marshal(user)
fmt.Println("JSON:", string(data))
user2 := User{ID: 2, Username: "golang", Age: 25}
data2, _ := json.Marshal(user2)
fmt.Println("JSON:", string(data2))
jsonStr := `{"id":3,"username":"dev","age":30}`
var user3 User
json.Unmarshal([]byte(jsonStr), &user3)
fmt.Printf("反序列化: %+v\n", user3)
temp := struct {
X int
Y int
}{10, 20}
fmt.Println("匿名结构体:", temp)
var empty struct{}
fmt.Printf("空结构体大小: %d字节\n", unsafe.Sizeof(empty))
set := make(map[string]struct{})
set["apple"] = struct{}{}
set["banana"] = struct{}{}
if _, exists := set["apple"]; exists {
fmt.Println("apple在集合中")
}
}
四、面向对象编程
4.1 接口(Interface)
接口是Go语言实现多态的核心机制,定义了一组方法签名。
package main
import (
"fmt"
"math"
)
type Shape interface {
Area() float64
Perimeter() float64
}
type Circle struct {
Radius float64
}
func (c Circle) Area() float64 {
return math.Pi * c.Radius * c.Radius
}
func (c Circle) Perimeter() float64 {
return 2 * math.Pi * c.Radius
}
type Rectangle struct {
Width, Height float64
}
func (r Rectangle) Area() float64 {
return r.Width * r.Height
}
func (r Rectangle) Perimeter() float64 {
return 2 * (r.Width + r.Height)
}
type Object interface {
Shape
Name() string
}
func printAny(v interface{}) {
fmt.Printf("类型: %T, 值: %v\n", v, v)
}
func main() {
var s Shape
s = Circle{Radius: 5}
fmt.Printf("圆形: 面积=%.2f, 周长=%.2f\n", s.Area(), s.Perimeter())
s = Rectangle{Width: 4, Height: 6}
fmt.Printf("矩形: 面积=%.2f, 周长=%.2f\n", s.Area(), s.Perimeter())
printShapeInfo(Circle{Radius: 3})
printShapeInfo(Rectangle{Width: 5, Height: 8})
var i interface{} = "hello"
str, ok := i.(string)
if ok {
fmt.Println("字符串:", str)
}
describeShape(Circle{Radius: 2})
describeShape(Rectangle{Width: 3, Height: 4})
var ptr *Circle = nil
var s2 Shape = ptr
fmt.Printf("s2 == nil? %v\n", s2 == nil)
}
func printShapeInfo(s Shape) {
fmt.Printf("形状信息: 面积=%.2f, 周长=%.2f\n", s.Area(), s.Perimeter())
}
func describeShape(s Shape) {
switch v := s.(type) {
case Circle:
fmt.Printf("这是圆形,半径: %.2f\n", v.Radius)
case Rectangle:
fmt.Printf("这是矩形,宽: %.2f, 高: %.2f\n", v.Width, v.Height)
default:
fmt.Println("未知形状")
}
}
4.2 嵌入类型(组合代替继承)
Go语言通过类型嵌入(组合)实现代码复用,代替传统面向对象的继承。
package main
import (
"fmt"
)
type Animal struct {
Name string
Age int
}
func (a Animal) Eat() {
fmt.Printf("%s 正在吃东西\n", a.Name)
}
func (a Animal) Sleep() {
fmt.Printf("%s 正在睡觉\n", a.Name)
}
type Dog struct {
Animal
Breed string
}
func (d Dog) Eat() {
fmt.Printf("%s(%s) 正在吃狗粮\n", d.Name, d.Breed)
}
func (d Dog) Bark() {
fmt.Printf("%s 在汪汪叫\n", d.Name)
}
type PetDog struct {
Dog
Owner string
}
func (p PetDog) Play() {
fmt.Printf("%s 和主人 %s 一起玩耍\n", p.Name, p.Owner)
}
type Walker interface {
Walk()
}
type Swimmer interface {
Swim()
}
type WalkerSwimmer interface {
Walker
Swimmer
}
type Person struct {
Name string
}
func (p Person) Walk() {
fmt.Printf("%s 在走路\n", p.Name)
}
func (p Person) Swim() {
fmt.Printf("%s 在游泳\n", p.Name)
}
func main() {
dog := Dog{
Animal: Animal{Name: "旺财", Age: 3},
Breed: "金毛",
}
fmt.Println("名字:", dog.Name)
fmt.Println("品种:", dog.Breed)
dog.Sleep()
dog.Eat()
dog.Bark()
dog.Animal.Eat()
pet := PetDog{
Dog: Dog{Animal: Animal{Name: "小黄", Age: 2}, Breed: "泰迪"},
Owner: "小明",
}
pet.Eat()
pet.Bark()
pet.Play()
var ws WalkerSwimmer
ws = Person{Name: "张三"}
ws.Walk()
ws.Swim()
}
4.3 泛型(Go 1.18+)
package main
import (
"fmt"
"golang.org/x/exp/constraints"
)
func Print[T any](s []T) {
for _, v := range s {
fmt.Print(v, " ")
}
fmt.Println()
}
func IndexOf[T comparable](s []T, x T) int {
for i, v := range s {
if v == x {
return i
}
}
return -1
}
func Sum[T int | float64](s []T) T {
var total T
for _, v := range s {
total += v
}
return total
}
func Min[T constraints.Ordered](a, b T) T {
if a < b {
return a
}
return b
}
type Slice[T any] []T
func (s Slice[T]) First() T {
return s[0]
}
func (s Slice[T]) Last() T {
return s[len(s)-1]
}
type MyMap[K comparable, V any] map[K]V
func (m MyMap[K, V]) Keys() []K {
keys := make([]K, 0, len(m))
for k := range m {
keys = append(keys, k)
}
return keys
}
type Result[T any] struct {
Value T
Err error
}
type Number interface {
int | int64 | float64
}
func Max[T Number](a, b T) T {
if a > b {
return a
}
return b
}
func main() {
Print([]int{1, 2, 3, 4, 5})
Print([]string{"Go", "Python", "Java"})
fmt.Println("IndexOf 5:", IndexOf([]int{1, 3, 5, 7, 9}, 5))
fmt.Println("IndexOf 'a':", IndexOf([]string{"a", "b", "c"}, "a"))
fmt.Println("Sum int:", Sum([]int{1, 2, 3, 4, 5}))
fmt.Println("Sum float64:", Sum([]float64{1.1, 2.2, 3.3}))
fmt.Println("Min(10, 20):", Min(10, 20))
fmt.Println("Min(1.5, 0.8):", Min(1.5, 0.8))
s := Slice[int]{1, 2, 3, 4, 5}
fmt.Println("First:", s.First(), "Last:", s.Last())
m := MyMap[string, int]{"a": 1, "b": 2, "c": 3}
fmt.Println("Keys:", m.Keys())
fmt.Println("Max(10, 20):", Max(10, 20))
fmt.Println("Max(1.5, 0.8):", Max(1.5, 0.8))
_ = Max[int](100, 200)
}
五、并发编程
5.1 Goroutine(协程)
Goroutine是Go语言的核心并发原语,是轻量级线程。
package main
import (
"fmt"
"runtime"
"sync"
"time"
)
func main() {
go sayHello("World")
go func(name string) {
fmt.Printf("匿名goroutine: Hello, %s!\n", name)
}("Go")
time.Sleep(100 * time.Millisecond)
fmt.Printf("逻辑CPU数: %d\n", runtime.NumCPU())
runtime.GOMAXPROCS(runtime.NumCPU())
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
wg.Add(1)
go worker(i, &wg)
}
wg.Wait()
fmt.Println("所有worker执行完成")
}
func sayHello(name string) {
for i := 0; i < 3; i++ {
fmt.Printf("Hello, %s! (%d)\n", name, i)
time.Sleep(50 * time.Millisecond)
}
}
func worker(id int, wg *sync.WaitGroup) {
defer wg.Done()
fmt.Printf("Worker %d 开始工作\n", id)
time.Sleep(100 * time.Millisecond)
fmt.Printf("Worker %d 完成工作\n", id)
}
5.2 Channel(通道)
Channel是Go中goroutine之间通信的主要方式,基于CSP(Communicating Sequential Processes)模型。
package main
import (
"fmt"
"time"
)
func main() {
unbuffered := make(chan int)
buffered := make(chan string, 3)
_ = unbuffered
_ = buffered
ch := make(chan int, 2)
ch <- 1
ch <- 2
value := <-ch
fmt.Println("接收:", value)
value = <-ch
fmt.Println("接收:", value)
ch2 := make(chan int, 3)
ch2 <- 10
ch2 <- 20
ch2 <- 30
close(ch2)
for v := range ch2 {
fmt.Println("读取:", v)
}
ch3 := make(chan int, 1)
ch3 <- 42
close(ch3)
v, ok := <-ch3
fmt.Printf("值=%d, 状态=%v\n", v, ok)
v, ok = <-ch3
fmt.Printf("值=%d, 状态=%v\n", v, ok)
numbers := make(chan int, 10)
go producer(numbers)
consumer(numbers)
done := make(chan struct{})
go func() {
time.Sleep(200 * time.Millisecond)
fmt.Println("任务完成")
close(done)
}()
<-done
semaphore := make(chan struct{}, 3)
for i := 0; i < 10; i++ {
semaphore <- struct{}{}
go func(id int) {
defer func() { <-semaphore }()
fmt.Printf("任务 %d 执行中...\n", id)
time.Sleep(100 * time.Millisecond)
}(i)
}
time.Sleep(time.Second)
}
func producer(ch chan<- int) {
for i := 0; i < 5; i++ {
ch <- i
fmt.Println("生产:", i)
}
close(ch)
}
func consumer(ch <-chan int) {
for v := range ch {
fmt.Println("消费:", v)
}
}
5.3 Select语句
select 用于同时等待多个channel操作。
package main
import (
"fmt"
"time"
)
func main() {
ch1 := make(chan string)
ch2 := make(chan string)
go func() {
time.Sleep(100 * time.Millisecond)
ch1 <- "来自通道1"
}()
go func() {
time.Sleep(200 * time.Millisecond)
ch2 <- "来自通道2"
}()
for i := 0; i < 2; i++ {
select {
case msg := <-ch1:
fmt.Println("收到:", msg)
case msg := <-ch2:
fmt.Println("收到:", msg)
}
}
ch3 := make(chan int, 1)
ch3 <- 42
select {
case v := <-ch3:
fmt.Println("读取到:", v)
default:
fmt.Println("channel为空,不阻塞")
}
ch4 := make(chan string)
go func() {
time.Sleep(500 * time.Millisecond)
ch4 <- "延迟数据"
}()
select {
case msg := <-ch4:
fmt.Println("收到:", msg)
case <-time.After(200 * time.Millisecond):
fmt.Println("超时!2秒内未收到数据")
}
ticker := time.NewTicker(100 * time.Millisecond)
done := make(chan bool)
go func() {
time.Sleep(500 * time.Millisecond)
done <- true
}()
loop:
for {
select {
case t := <-ticker.C:
fmt.Println("心跳:", t.Format("15:04:05.000"))
case <-done:
fmt.Println("任务完成,停止心跳")
ticker.Stop()
break loop
}
}
}
5.4 同步原语(sync包)
package main
import (
"fmt"
"sync"
"sync/atomic"
"time"
)
func main() {
var mu sync.Mutex
counter := 0
for i := 0; i < 1000; i++ {
go func() {
mu.Lock()
counter++
mu.Unlock()
}()
}
time.Sleep(100 * time.Millisecond)
fmt.Println("Mutex counter:", counter)
var rwmu sync.RWMutex
data := make(map[string]int)
go func() {
rwmu.Lock()
data["key"] = 42
rwmu.Unlock()
}()
for i := 0; i < 5; i++ {
go func(id int) {
rwmu.RLock()
fmt.Printf("Reader %d 读取: %d\n", id, data["key"])
rwmu.RUnlock()
}(i)
}
time.Sleep(100 * time.Millisecond)
var once sync.Once
initFunc := func() {
fmt.Println("初始化操作(只执行一次)")
}
for i := 0; i < 5; i++ {
go func() {
once.Do(initFunc)
}()
}
time.Sleep(100 * time.Millisecond)
var sm sync.Map
sm.Store("key1", "value1")
sm.Store("key2", "value2")
value, ok := sm.Load("key1")
if ok {
fmt.Println("Load key1:", value)
}
sm.Range(func(key, value interface{}) bool {
fmt.Printf(" %v -> %v\n", key, value)
return true
})
sm.Delete("key1")
actual, loaded := sm.LoadOrStore("key3", "value3")
fmt.Printf("LoadOrStore: value=%v, loaded=%v\n", actual, loaded)
var pool = sync.Pool{
New: func() interface{} {
return make([]byte, 1024)
},
}
buf := pool.Get().([]byte)
pool.Put(buf)
var atomicCounter int64
for i := 0; i < 1000; i++ {
go func() {
atomic.AddInt64(&atomicCounter, 1)
}()
}
time.Sleep(100 * time.Millisecond)
fmt.Println("Atomic counter:", atomic.LoadInt64(&atomicCounter))
var value int64 = 0
swapped := atomic.CompareAndSwapInt64(&value, 0, 100)
fmt.Printf("CAS swapped=%v, value=%d\n", swapped, value)
var condMu sync.Mutex
cond := sync.NewCond(&condMu)
ready := false
go func() {
condMu.Lock()
for !ready {
cond.Wait()
}
fmt.Println("条件满足,继续执行")
condMu.Unlock()
}()
time.Sleep(100 * time.Millisecond)
condMu.Lock()
ready = true
condMu.Unlock()
cond.Signal()
time.Sleep(100 * time.Millisecond)
}
六、错误处理
6.1 error 接口与基本错误处理
package main
import (
"errors"
"fmt"
"os"
)
func demoErrors() {
err1 := errors.New("这是一个错误")
name := "文件"
err2 := fmt.Errorf("打开%s失败: %w", name, err1)
err3 := os.ErrNotExist
err4 := os.ErrPermission
fmt.Println(err1)
fmt.Println(err2)
fmt.Println(err3)
fmt.Println(err4)
}
func readFile(filename string) ([]byte, error) {
data, err := os.ReadFile(filename)
if err != nil {
return nil, fmt.Errorf("读取文件%s失败: %w", filename, err)
}
return data, nil
}
func main() {
demoErrors()
data, err := readFile("nonexistent.txt")
if err != nil {
fmt.Println("错误:", err)
} else {
fmt.Println("文件内容:", string(data))
}
}
6.2 自定义错误类型
package main
import (
"fmt"
)
type ValidationError struct {
Field string
Value interface{}
Msg string
}
func (e *ValidationError) Error() string {
return fmt.Sprintf("验证失败: 字段=%s, 值=%v, 原因=%s", e.Field, e.Value, e.Msg)
}
type AppError struct {
Code int
Message string
Cause error
}
func (e *AppError) Error() string {
if e.Cause != nil {
return fmt.Sprintf("[%d] %s: %v", e.Code, e.Message, e.Cause)
}
return fmt.Sprintf("[%d] %s", e.Code, e.Message)
}
func (e *AppError) Unwrap() error {
return e.Cause
}
func validateAge(age int) error {
if age < 0 {
return &ValidationError{
Field: "age",
Value: age,
Msg: "年龄不能为负数",
}
}
if age > 150 {
return &ValidationError{
Field: "age",
Value: age,
Msg: "年龄超出合理范围",
}
}
return nil
}
func main() {
err := validateAge(-5)
if err != nil {
if ve, ok := err.(*ValidationError); ok {
fmt.Printf("字段%s验证失败\n", ve.Field)
}
fmt.Println(err)
}
appErr := &AppError{Code: 404, Message: "资源未找到"}
fmt.Println(appErr)
}
6.3 错误包装与解包(Go 1.13+)
package main
import (
"errors"
"fmt"
"os"
)
func openConfig() error {
_, err := os.Open("config.yaml")
if err != nil {
return fmt.Errorf("打开配置文件失败: %w", err)
}
return nil
}
func loadApp() error {
err := openConfig()
if err != nil {
return fmt.Errorf("加载应用失败: %w", err)
}
return nil
}
func main() {
err := loadApp()
if err != nil {
fmt.Println("完整错误链:", err)
unwrapped := errors.Unwrap(err)
fmt.Println("解包一层:", unwrapped)
if errors.Is(err, os.ErrNotExist) {
fmt.Println("根本原因是文件不存在")
}
var pathErr *os.PathError
if errors.As(err, &pathErr) {
fmt.Printf("路径错误: path=%s, op=%s\n", pathErr.Path, pathErr.Op)
}
}
}
6.4 panic 与 recover 深入
package main
import (
"fmt"
)
func safeCall(fn func()) (recovered interface{}) {
defer func() {
recovered = recover()
}()
fn()
return nil
}
func riskyOperation(shouldPanic bool) {
if shouldPanic {
panic("发生了严重错误")
}
fmt.Println("操作成功")
}
func main() {
result := safeCall(func() {
riskyOperation(true)
})
if result != nil {
fmt.Println("捕获到 panic:", result)
}
safeCall(func() {
riskyOperation(false)
})
fmt.Println("程序正常结束")
defer func() {
if r := recover(); r != nil {
fmt.Println("第一次recover:", r)
}
}()
panic("原始panic")
}
七、包与模块
7.1 包的定义与导入
package main
import (
"fmt"
str "strings"
_ "database/sql/driver"
)
func main() {
fmt.Println(str.ToUpper("hello"))
}
7.2 可见性规则
package user
import "fmt"
var PublicVar = "public"
var privateVar = "private"
type User struct {
Name string
age int
}
func (u *User) GetAge() int {
return u.age
}
func NewUser(name string, age int) *User {
return &User{Name: name, age: age}
}
func init() {
fmt.Println("user 包初始化")
}
7.3 Go Modules 详解
go mod init example.com/myproject
go get github.com/gin-gonic/gin
go get github.com/gin-gonic/gin@v1.9.0
go get github.com/gin-gonic/gin@latest
go get github.com/gin-gonic/gin@none
go list -m all
go list -m -u all
go mod graph
go mod tidy
go mod download
go mod verify
go mod edit -replace example.com/original=../local/path
go mod edit -replace example.com/original=github.com/fork/version@v1.0.0
go.mod 文件结构示例:
module example.com/myproject
go 1.22
require (
github.com/gin-gonic/gin v1.9.1
github.com/go-sql-driver/mysql v1.7.0
)
require (
// 间接依赖
github.com/bytedance/sonic v1.9.1 // indirect
github.com/goccy/go-json v0.10.2 // indirect
)
replace example.com/local => ./local
exclude example.com/broken v1.0.0
retract v1.0.0 // 撤回有问题的版本
7.4 内部包(internal)
八、标准库详解
8.1 fmt 包 —— 格式化输入输出
核心功能: 提供格式化I/O功能,包括打印到标准输出/文件、从输入读取数据、格式化字符串。
8.1.1 输出函数
| 函数 |
签名 |
说明 |
| Print |
func Print(a ...any) (n int, err error) |
打印到标准输出,不换行 |
| Println |
func Println(a ...any) (n int, err error) |
打印后加换行,参数间加空格 |
| Printf |
func Printf(format string, a ...any) (n int, err error) |
格式化打印 |
| Fprint |
func Fprint(w io.Writer, a ...any) (n int, err error) |
写入到 Writer |
| Fprintf |
func Fprintf(w io.Writer, format string, a ...any) (n int, err error) |
格式化写入到 Writer |
| Fprintln |
func Fprintln(w io.Writer, a ...any) (n int, err error) |
写入后加换行 |
| Sprint |
func Sprint(a ...any) string |
返回字符串 |
| Sprintf |
func Sprintf(format string, a ...any) string |
格式化后返回字符串 |
| Sprintln |
func Sprintln(a ...any) string |
返回带换行和空格的字符串 |
8.1.2 输入函数
| 函数 |
签名 |
说明 |
| Scan |
func Scan(a ...any) (n int, err error) |
从标准输入读取,空格分隔 |
| Scanln |
func Scanln(a ...any) (n int, err error) |
从标准输入读取一行 |
| Scanf |
func Scanf(format string, a ...any) (n int, err error) |
格式化读取 |
| Fscan |
func Fscan(r io.Reader, a ...any) (n int, err error) |
从 Reader 读取 |
| Sscan |
func Sscan(str string, a ...any) (n int, err error) |
从字符串读取 |
8.1.3 格式化动词(Verbs)
| 动词 |
说明 |
示例 |
输出 |
%v |
默认格式 |
fmt.Sprintf("%v", "hello") |
hello |
%+v |
结构体添加字段名 |
fmt.Sprintf("%+v", User{Name:"Tom"}) |
{Name:Tom} |
%#v |
Go语法表示 |
fmt.Sprintf("%#v", User{Name:"Tom"}) |
main.User{Name:”Tom”} |
%T |
类型 |
fmt.Sprintf("%T", 42) |
int |
%t |
布尔值 |
fmt.Sprintf("%t", true) |
true |
%d |
十进制整数 |
fmt.Sprintf("%d", 42) |
42 |
%b |
二进制 |
fmt.Sprintf("%b", 42) |
101010 |
%o |
八进制 |
fmt.Sprintf("%o", 42) |
52 |
%x |
十六进制(小写) |
fmt.Sprintf("%x", 255) |
ff |
%X |
十六进制(大写) |
fmt.Sprintf("%X", 255) |
FF |
%f |
浮点数 |
fmt.Sprintf("%f", 3.14) |
3.140000 |
%.2f |
浮点数(2位小数) |
fmt.Sprintf("%.2f", 3.14159) |
3.14 |
%e |
科学计数法 |
fmt.Sprintf("%e", 314159.0) |
3.141590e+05 |
%s |
字符串 |
fmt.Sprintf("%s", "hello") |
hello |
%q |
带引号的字符串 |
fmt.Sprintf("%q", "hello") |
“hello” |
%p |
指针地址 |
fmt.Sprintf("%p", &value) |
0xc00001a0a0 |
%c |
Unicode字符 |
fmt.Sprintf("%c", 20013) |
中 |
%% |
百分号 |
fmt.Sprintf("%d%%", 80) |
80% |
8.1.4 使用示例
package main
import (
"bytes"
"fmt"
"os"
)
func main() {
fmt.Print("不带换行")
fmt.Println("带换行")
name := "Alice"
age := 30
fmt.Printf("姓名: %s, 年龄: %d\n", name, age)
f, _ := os.Create("output.txt")
defer f.Close()
fmt.Fprintln(f, "写入文件的内容")
var buf bytes.Buffer
fmt.Fprintf(&buf, "缓冲区: %d", 100)
fmt.Println(buf.String())
result := fmt.Sprintf("计算结果: %.2f", 3.14159)
fmt.Println(result)
type User struct {
Name string
Age int
}
u := User{"Bob", 25}
fmt.Printf("默认: %v\n", u)
fmt.Printf("详细: %+v\n", u)
fmt.Printf("完整: %#v\n", u)
fmt.Printf("类型: %T\n", u)
fmt.Printf("|%10s|%10d|\n", "右对齐", 42)
fmt.Printf("|%-10s|%-10d|\n", "左对齐", 42)
fmt.Printf("|%010d|\n", 42)
fmt.Print("请输入你的名字: ")
var input string
fmt.Scanln(&input)
fmt.Println("你好,", input)
err := fmt.Errorf("在第%d行发生错误: %s", 42, "未定义变量")
fmt.Println(err)
}
8.2 os 包 —— 操作系统接口
核心功能: 提供操作系统功能,包括文件操作、进程管理、环境变量、命令行参数等。
8.2.1 主要函数
| 函数 |
签名 |
说明 |
| Open |
func Open(name string) (*File, error) |
只读方式打开文件 |
| Create |
func Create(name string) (*File, error) |
创建/截断文件 |
| OpenFile |
func OpenFile(name string, flag int, perm FileMode) (*File, error) |
指定方式打开文件 |
| ReadFile |
func ReadFile(name string) ([]byte, error) |
读取整个文件 |
| WriteFile |
func WriteFile(name string, data []byte, perm FileMode) error |
写入整个文件 |
| Mkdir |
func Mkdir(name string, perm FileMode) error |
创建单层目录 |
| MkdirAll |
func MkdirAll(path string, perm FileMode) error |
递归创建目录 |
| Remove |
func Remove(name string) error |
删除文件或空目录 |
| RemoveAll |
func RemoveAll(path string) error |
递归删除 |
| Rename |
func Rename(oldpath, newpath string) error |
重命名/移动 |
| Stat |
func Stat(name string) (FileInfo, error) |
获取文件信息 |
| Getenv |
func Getenv(key string) string |
获取环境变量 |
| Setenv |
func Setenv(key, value string) error |
设置环境变量 |
| LookupEnv |
func LookupEnv(key string) (string, bool) |
检查环境变量是否存在 |
| Environ |
func Environ() []string |
所有环境变量 |
| Exit |
func Exit(code int) |
退出程序 |
| Getwd |
func Getwd() (dir string, err error) |
获取当前工作目录 |
| Chdir |
func Chdir(dir string) error |
改变工作目录 |
| TempDir |
func TempDir() string |
临时目录路径 |
| UserHomeDir |
func UserHomeDir() (string, error) |
用户主目录 |
| UserCacheDir |
func UserCacheDir() (string, error) |
用户缓存目录 |
| UserConfigDir |
func UserConfigDir() (string, error) |
用户配置目录 |
| Executable |
func Executable() (string, error) |
可执行文件路径 |
8.2.2 文件打开标志
| 常量 |
值 |
说明 |
| O_RDONLY |
0 |
只读 |
| O_WRONLY |
1 |
只写 |
| O_RDWR |
2 |
读写 |
| O_APPEND |
1024 |
追加 |
| O_CREATE |
256 |
不存在则创建 |
| O_EXCL |
512 |
与O_CREATE配合,文件存在则失败 |
| O_TRUNC |
512 |
打开时截断文件 |
| O_SYNC |
4096 |
同步写入 |
8.2.3 使用示例
package main
import (
"fmt"
"os"
"path/filepath"
)
func main() {
path := os.Getenv("PATH")
fmt.Println("PATH:", path)
home, _ := os.UserHomeDir()
fmt.Println("主目录:", home)
exe, _ := os.Executable()
fmt.Println("可执行文件:", exe)
dir, _ := os.Getwd()
fmt.Println("工作目录:", dir)
fmt.Println("程序名:", os.Args[0])
for i, arg := range os.Args[1:] {
fmt.Printf("参数%d: %s\n", i+1, arg)
}
data, err := os.ReadFile("example.txt")
if err != nil {
fmt.Println("读取失败:", err)
} else {
fmt.Println("文件内容:", string(data))
}
f, err := os.Open("example.txt")
if err != nil {
fmt.Println("打开失败:", err)
} else {
defer f.Close()
buf := make([]byte, 1024)
n, err := f.Read(buf)
if err == nil {
fmt.Printf("读取了%d字节\n", n)
}
}
content := []byte("Hello, Go!\n这是写入的内容\n")
err = os.WriteFile("output.txt", content, 0644)
if err != nil {
fmt.Println("写入失败:", err)
}
f2, err := os.OpenFile("output.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
fmt.Println("打开失败:", err)
} else {
defer f2.Close()
f2.WriteString("追加的内容\n")
}
err = os.MkdirAll(filepath.Join("data", "subdir"), 0755)
if err != nil {
fmt.Println("创建目录失败:", err)
}
entries, err := os.ReadDir(".")
if err != nil {
fmt.Println("读取目录失败:", err)
} else {
for _, entry := range entries {
fmt.Printf(" %s (目录:%v)\n", entry.Name(), entry.IsDir())
}
}
info, err := os.Stat("output.txt")
if err != nil {
fmt.Println("获取文件信息失败:", err)
} else {
fmt.Printf("文件名: %s\n", info.Name())
fmt.Printf("大小: %d 字节\n", info.Size())
fmt.Printf("权限: %s\n", info.Mode())
fmt.Printf("修改时间: %s\n", info.ModTime())
fmt.Printf("是否为目录: %v\n", info.IsDir())
}
tmpFile, err := os.CreateTemp("", "example-*.txt")
if err != nil {
fmt.Println("创建临时文件失败:", err)
} else {
defer os.Remove(tmpFile.Name())
tmpFile.WriteString("临时内容")
fmt.Println("临时文件:", tmpFile.Name())
tmpFile.Close()
}
fmt.Println("进程ID:", os.Getpid())
fmt.Println("父进程ID:", os.Getppid())
}
8.3 io 包 —— 基础I/O接口
核心功能: 定义基本的I/O接口(Reader、Writer等),提供通用的I/O工具函数。
8.3.1 核心接口
8.3.2 函数列表
| 函数 |
签名 |
说明 |
| Copy |
func Copy(dst Writer, src Reader) (written int64, err error) |
复制数据(从Reader到Writer) |
| CopyN |
func CopyN(dst Writer, src Reader, n int64) (written int64, err error) |
复制最多n字节 |
| CopyBuffer |
func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) |
带缓冲区的复制 |
| ReadAll |
func ReadAll(r Reader) ([]byte, error) |
读取所有数据 |
| ReadAtLeast |
func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error) |
至少读取min字节 |
| ReadFull |
func ReadFull(r Reader, buf []byte) (n int, err error) |
精确读取 len(buf) 字节 |
| WriteString |
func WriteString(w Writer, s string) (n int, err error) |
写入字符串 |
| LimitReader |
func LimitReader(r Reader, n int64) Reader |
限制读取字节数的Reader |
| MultiReader |
func MultiReader(readers ...Reader) Reader |
将多个Reader串联 |
| MultiWriter |
func MultiWriter(writers ...Writer) Writer |
将数据同时写入多个Writer |
| TeeReader |
func TeeReader(r Reader, w Writer) Reader |
读取的同时写入到另一个Writer |
| NopCloser |
func NopCloser(r Reader) ReadCloser |
将Reader包装为ReadCloser |
| Pipe |
func Pipe() (*PipeReader, *PipeWriter) |
创建内存管道 |
8.3.3 使用示例
package main
import (
"bytes"
"fmt"
"io"
"os"
"strings"
)
func main() {
src := strings.NewReader("Hello, io.Copy!")
var dst bytes.Buffer
written, _ := io.Copy(&dst, src)
fmt.Printf("复制了%d字节: %s\n", written, dst.String())
reader := strings.NewReader("读取所有内容")
data, _ := io.ReadAll(reader)
fmt.Println("ReadAll:", string(data))
var buf bytes.Buffer
io.WriteString(&buf, "写入字符串到Buffer\n")
io.WriteString(&buf, "第二行内容")
fmt.Println(buf.String())
bigReader := strings.NewReader("1234567890ABCDEFGHIJ")
limited := io.LimitReader(bigReader, 10)
limitedData, _ := io.ReadAll(limited)
fmt.Println("限制10字节:", string(limitedData))
r1 := strings.NewReader("第一部分 ")
r2 := strings.NewReader("第二部分 ")
r3 := strings.NewReader("第三部分")
multi := io.MultiReader(r1, r2, r3)
combined, _ := io.ReadAll(multi)
fmt.Println("合并:", string(combined))
var buf1, buf2 bytes.Buffer
mw := io.MultiWriter(&buf1, &buf2)
mw.Write([]byte("同时写入两个Buffer"))
fmt.Println("buf1:", buf1.String())
fmt.Println("buf2:", buf2.String())
teeReader := strings.NewReader("TeeReader示例")
var teeBuf bytes.Buffer
tee := io.TeeReader(teeReader, &teeBuf)
teeData, _ := io.ReadAll(tee)
fmt.Println("Tee读取:", string(teeData))
fmt.Println("Tee旁路:", teeBuf.String())
pipeReader, pipeWriter := io.Pipe()
go func() {
defer pipeWriter.Close()
pipeWriter.Write([]byte("通过管道传输的数据"))
}()
pipeData, _ := io.ReadAll(pipeReader)
fmt.Println("Pipe读取:", string(pipeData))
reader2 := strings.NewReader("Hello, Go!")
buf := make([]byte, 5)
n, _ := io.ReadFull(reader2, buf)
fmt.Printf("精确读取%d字节: %s\n", n, buf)
}
8.4 path/filepath 包 —— 文件路径操作
核心功能: 跨平台的文件路径操作,处理路径分隔符、路径清理、通配符匹配等。
| 函数 |
签名 |
说明 |
| Base |
func Base(path string) string |
路径最后元素 |
| Dir |
func Dir(path string) string |
路径目录部分 |
| Ext |
func Ext(path string) string |
文件扩展名 |
| Clean |
func Clean(path string) string |
清理路径 |
| Join |
func Join(elem ...string) string |
拼接路径 |
| Split |
func Split(path string) (dir, file string) |
分割路径 |
| Abs |
func Abs(path string) (string, error) |
绝对路径 |
| Rel |
func Rel(basepath, targpath string) (string, error) |
相对路径 |
| Walk |
func Walk(root string, fn WalkFunc) error |
遍历目录树 |
| WalkDir |
func WalkDir(root string, fn WalkDirFunc) error |
遍历目录树(Go 1.16+更高效) |
| Glob |
func Glob(pattern string) (matches []string, err error) |
通配符匹配 |
| Match |
func Match(pattern, name string) (matched bool, err error) |
路径匹配 |
| FromSlash |
func FromSlash(path string) string |
/ 转为系统分隔符 |
| ToSlash |
func ToSlash(path string) string |
系统分隔符转为 / |
| IsAbs |
func IsAbs(path string) bool |
判断是否为绝对路径 |
package main
import (
"fmt"
"path/filepath"
)
func main() {
path := "/home/user/docs/report.pdf"
fmt.Println("Base:", filepath.Base(path))
fmt.Println("Dir:", filepath.Dir(path))
fmt.Println("Ext:", filepath.Ext(path))
fmt.Println("Clean:", filepath.Clean("a//b/../c"))
dir, file := filepath.Split(path)
fmt.Println("Split:", dir, "|", file)
joined := filepath.Join("/home", "user", "docs", "file.txt")
fmt.Println("Join:", joined)
abs, _ := filepath.Abs(".")
fmt.Println("绝对路径:", abs)
rel, _ := filepath.Rel("/home/user", "/home/user/docs/report.pdf")
fmt.Println("相对路径:", rel)
matches, _ := filepath.Glob("*.go")
fmt.Println("匹配的Go文件:", matches)
matched, _ := filepath.Match("*.txt", "readme.txt")
fmt.Println("匹配结果:", matched)
fmt.Println("遍历当前目录:")
filepath.Walk(".", func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if !info.IsDir() {
fmt.Printf(" %s (%d字节)\n", path, info.Size())
}
return nil
})
}
8.5 strings 包 —— 字符串操作
核心功能: 提供字符串操作函数,包括查找、替换、分割、拼接、修剪等。
| 函数 |
签名 |
说明 |
| Contains |
func Contains(s, substr string) bool |
是否包含子串 |
| ContainsAny |
func ContainsAny(s, chars string) bool |
是否包含任意字符 |
| Count |
func Count(s, substr string) int |
子串出现次数 |
| HasPrefix |
func HasPrefix(s, prefix string) bool |
是否以prefix开头 |
| HasSuffix |
func HasSuffix(s, suffix string) bool |
是否以suffix结尾 |
| Index |
func Index(s, substr string) int |
子串首次出现位置 |
| LastIndex |
func LastIndex(s, substr string) int |
子串最后出现位置 |
| Join |
func Join(elems []string, sep string) string |
连接字符串 |
| Split |
func Split(s, sep string) []string |
分割字符串 |
| SplitN |
func SplitN(s, sep string, n int) []string |
分割为n段 |
| SplitAfter |
func SplitAfter(s, sep string) []string |
分割后保留分隔符 |
| Fields |
func Fields(s string) []string |
按空白字符分割 |
| FieldsFunc |
func FieldsFunc(s string, f func(rune) bool) []string |
自定义分割函数 |
| Replace |
func Replace(s, old, new string, n int) string |
替换子串(n次) |
| ReplaceAll |
func ReplaceAll(s, old, new string) string |
替换所有子串 |
| ToLower |
func ToLower(s string) string |
转小写 |
| ToUpper |
func ToUpper(s string) string |
转大写 |
| ToTitle |
func ToTitle(s string) string |
转标题大小写 |
| Trim |
func Trim(s, cutset string) string |
修剪前后字符 |
| TrimSpace |
func TrimSpace(s string) string |
修剪前后空白 |
| TrimPrefix |
func TrimPrefix(s, prefix string) string |
修剪前缀 |
| TrimSuffix |
func TrimSuffix(s, suffix string) string |
修剪后缀 |
| Repeat |
func Repeat(s string, count int) string |
重复字符串 |
| Compare |
func Compare(a, b string) int |
比较字符串 |
| EqualFold |
func EqualFold(s, t string) bool |
忽略大小写比较 |
| Builder |
type Builder struct{...} |
高效字符串构建器 |
| Reader |
type Reader struct{...} |
字符串Reader |
package main
import (
"fmt"
"strings"
)
func main() {
s := " Hello, Go Programming Language! "
fmt.Println("Contains Go:", strings.Contains(s, "Go"))
fmt.Println("HasPrefix Hello:", strings.HasPrefix(strings.TrimSpace(s), "Hello"))
fmt.Println("HasSuffix !:", strings.HasSuffix(s, "! "))
fmt.Println("Index Go:", strings.Index(s, "Go"))
fmt.Println("Count o:", strings.Count(s, "o"))
words := strings.Fields(s)
fmt.Println("Fields:", words)
parts := strings.Split("a,b,c,d", ",")
fmt.Println("Split:", parts)
joined := strings.Join(parts, "-")
fmt.Println("Join:", joined)
replaced := strings.Replace(s, "o", "0", 2)
fmt.Println("Replace前2个o:", replaced)
replacedAll := strings.ReplaceAll(s, "o", "0")
fmt.Println("ReplaceAll:", replacedAll)
fmt.Println("ToUpper:", strings.ToUpper(s))
fmt.Println("ToLower:", strings.ToLower(s))
fmt.Println("TrimSpace:", strings.TrimSpace(s))
fmt.Println("TrimPrefix:", strings.TrimPrefix("file.txt", "file"))
fmt.Println("TrimSuffix:", strings.TrimSuffix("file.txt", ".txt"))
fmt.Println("Trim:", strings.Trim("!!Hello!!", "!"))
fmt.Println("Repeat:", strings.Repeat("Go ", 3))
fmt.Println("EqualFold:", strings.EqualFold("Go", "go"))
var builder strings.Builder
builder.WriteString("Hello")
builder.WriteString(", ")
builder.WriteString("World!")
fmt.Println("Builder:", builder.String())
builder.Reset()
builder.Grow(100)
for i := 0; i < 5; i++ {
fmt.Fprintf(&builder, "Item %d, ", i)
}
result := builder.String()
fmt.Println("Builder result:", result)
reader := strings.NewReader("Hello, Go Reader!")
buf := make([]byte, 5)
n, _ := reader.Read(buf)
fmt.Printf("读取%d字节: %s\n", n, buf)
fmt.Printf("剩余未读: %d字节\n", reader.Len())
csv := "apple,banana;cherry,date"
fields := strings.FieldsFunc(csv, func(r rune) bool {
return r == ',' || r == ';'
})
fmt.Println("FieldsFunc:", fields)
}
8.6 strconv 包 —— 字符串与基本类型转换
核心功能: 字符串与基本数据类型之间的转换。
| 函数 |
签名 |
说明 |
| Itoa |
func Itoa(i int) string |
int → string |
| Atoi |
func Atoi(s string) (int, error) |
string → int |
| FormatBool |
func FormatBool(b bool) string |
bool → string |
| ParseBool |
func ParseBool(str string) (bool, error) |
string → bool |
| FormatFloat |
func FormatFloat(f float64, fmt byte, prec, bitSize int) string |
float64 → string |
| ParseFloat |
func ParseFloat(s string, bitSize int) (float64, error) |
string → float64 |
| FormatInt |
func FormatInt(i int64, base int) string |
int64 → string(按进制) |
| ParseInt |
func ParseInt(s string, base int, bitSize int) (int64, error) |
string → int64(按进制) |
| FormatUint |
func FormatUint(i uint64, base int) string |
uint64 → string |
| ParseUint |
func ParseUint(s string, base int, bitSize int) (uint64, error) |
string → uint64 |
| Quote |
func Quote(s string) string |
添加Go语法引号 |
| Unquote |
func Unquote(s string) (string, error) |
去除Go语法引号 |
| AppendBool |
func AppendBool(dst []byte, b bool) []byte |
追加转换后的bool |
| AppendFloat |
func AppendFloat(dst []byte, f float64, fmt byte, prec, bitSize int) []byte |
追加转换后的float |
| AppendInt |
func AppendInt(dst []byte, i int64, base int) []byte |
追加转换后的int |
| fmt |
说明 |
示例(3.14159, prec=2) |
| ‘f’ |
十进制(无指数) |
“3.14” |
| ‘e’ |
科学计数法(e) |
“3.14e+00” |
| ‘E’ |
科学计数法(E) |
“3.14E+00” |
| ‘g’ |
自动选择最紧凑格式 |
“3.1” |
| ‘G’ |
同’g’,用大写E |
“3.1” |
| ‘b’ |
二进制指数 |
“7074237752028440p-51” |
package main
import (
"fmt"
"strconv"
)
func main() {
s1 := strconv.Itoa(42)
fmt.Println("Itoa:", s1, "类型:", fmt.Sprintf("%T", s1))
n1, err := strconv.Atoi("42")
fmt.Println("Atoi:", n1, err)
n2, err := strconv.Atoi("42abc")
fmt.Println("Atoi错误:", n2, err)
fmt.Println("FormatInt(255, 2):", strconv.FormatInt(255, 2))
fmt.Println("FormatInt(255, 8):", strconv.FormatInt(255, 8))
fmt.Println("FormatInt(255, 16):", strconv.FormatInt(255, 16))
parsed, _ := strconv.ParseInt("11111111", 2, 64)
fmt.Println("ParseInt二进制:", parsed)
parsed, _ = strconv.ParseInt("ff", 16, 64)
fmt.Println("ParseInt十六进制:", parsed)
fStr1 := strconv.FormatFloat(3.14159, 'f', 2, 64)
fStr2 := strconv.FormatFloat(3.14159, 'e', 3, 64)
fStr3 := strconv.FormatFloat(3.14159, 'g', 4, 64)
fmt.Printf("FormatFloat: %s, %s, %s\n", fStr1, fStr2, fStr3)
f, _ := strconv.ParseFloat("3.14159", 64)
fmt.Printf("ParseFloat: %.5f\n", f)
bStr := strconv.FormatBool(true)
fmt.Println("FormatBool:", bStr)
b, _ := strconv.ParseBool("true")
fmt.Println("ParseBool:", b)
quoted := strconv.Quote("Hello, \"World\"!\n")
fmt.Println("Quote:", quoted)
unquoted, _ := strconv.Unquote(quoted)
fmt.Println("Unquote:", unquoted)
buf := []byte("Count: ")
buf = strconv.AppendInt(buf, 42, 10)
buf = append(buf, ", Value: "...)
buf = strconv.AppendFloat(buf, 3.14, 'f', 2, 64)
fmt.Println("Append结果:", string(buf))
}
8.7 bytes 包 —— 字节切片操作
核心功能: 类似于 strings 包,但操作对象是 []byte 而不是 string。
bytes 包提供了与 strings 包几乎完全对应的函数集,主要区别在于操作的数据类型:
| strings 函数 |
bytes 对应函数 |
| strings.Contains |
bytes.Contains |
| strings.Count |
bytes.Count |
| strings.Index |
bytes.Index |
| strings.Join |
bytes.Join |
| strings.Split |
bytes.Split |
| strings.Replace |
bytes.Replace |
| strings.ToLower |
bytes.ToLower |
| strings.Trim |
bytes.Trim |
| strings.Builder |
bytes.Buffer |
| strings.Reader |
bytes.Reader |
package main
import (
"bytes"
"fmt"
)
func main() {
var buf bytes.Buffer
buf.Write([]byte("Hello"))
buf.WriteByte(' ')
buf.WriteString("World!")
buf.WriteRune('🚀')
fmt.Println("Buffer内容:", buf.String())
fmt.Println("Buffer长度:", buf.Len())
fmt.Println("Buffer容量:", buf.Cap())
data := make([]byte, 5)
n, _ := buf.Read(data)
fmt.Printf("读取%d字节: %s\n", n, data)
line, _ := buf.ReadString('!')
fmt.Println("读到分隔符:", line)
buf.Reset()
fmt.Println("重置后长度:", buf.Len())
buf.Grow(1024)
buf.WriteString("Go语言编程")
remaining := buf.Bytes()
fmt.Println("剩余字节:", string(remaining))
}
8.8 bufio 包 —— 带缓冲的I/O
核心功能: 提供带缓冲的I/O操作,通过减少系统调用次数来提升读写性能。
主要类型和函数
| 类型/函数 |
签名/说明 |
NewReader |
func NewReader(rd io.Reader) *Reader —— 创建带缓冲的Reader(默认4096字节) |
NewReaderSize |
func NewReaderSize(rd io.Reader, size int) *Reader —— 指定缓冲区大小 |
NewWriter |
func NewWriter(w io.Writer) *Writer —— 创建带缓冲的Writer |
NewWriterSize |
func NewWriterSize(w io.Writer, size int) *Writer —— 指定缓冲区大小 |
NewScanner |
func NewScanner(r io.Reader) *Scanner —— 创建扫描器(按行/单词扫描) |
Reader 主要方法
| 方法 |
说明 |
Read(p []byte) (n int, err error) |
读取数据到p |
ReadByte() (byte, error) |
读取一个字节 |
ReadRune() (r rune, size int, err error) |
读取一个Unicode字符 |
ReadBytes(delim byte) ([]byte, error) |
读取到分隔符(包含分隔符) |
ReadString(delim byte) (string, error) |
读取到分隔符返回字符串 |
ReadLine() (line []byte, isPrefix bool, err error) |
读取一行(低级别) |
Peek(n int) ([]byte, error) |
预读n字节,不移动读取位置 |
Writer 主要方法
| 方法 |
说明 |
Write(p []byte) (nn int, err error) |
写入数据 |
WriteByte(c byte) error |
写入一个字节 |
WriteRune(r rune) (size int, err error) |
写入Unicode字符 |
WriteString(s string) (int, error) |
写入字符串 |
Flush() error |
刷新缓冲区到下层Writer |
Scanner 主要方法
| 方法 |
说明 |
Scan() bool |
扫描下一个token |
Text() string |
返回当前token的字符串 |
Bytes() []byte |
返回当前token的字节切片 |
Split(split SplitFunc) |
设置分割函数 |
Scanner 预定义分割函数
| 函数 |
说明 |
ScanLines |
按行分割(默认) |
ScanWords |
按单词分割 |
ScanRunes |
按Unicode字符分割 |
ScanBytes |
按字节分割 |
package main
import (
"bufio"
"fmt"
"os"
"strings"
)
func main() {
f, _ := os.Create("bufio_test.txt")
defer f.Close()
writer := bufio.NewWriter(f)
writer.WriteString("Hello, bufio!\n")
writer.WriteString("这是第二行\n")
writer.WriteString("这是第三行\n")
writer.Flush()
reader := strings.NewReader("Hello, Go!\n这是bufio读取的数据")
bufReader := bufio.NewReader(reader)
line, _ := bufReader.ReadString('\n')
fmt.Println("第一行:", line)
peek, _ := bufReader.Peek(4)
fmt.Println("预读4字节:", string(peek))
remaining, _ := bufReader.ReadString('\n')
fmt.Println("剩余:", remaining)
input := "第一行\n第二行\n第三行\n"
scanner := bufio.NewScanner(strings.NewReader(input))
fmt.Println("逐行扫描:")
lineNum := 1
for scanner.Scan() {
fmt.Printf(" 行%d: %s\n", lineNum, scanner.Text())
lineNum++
}
if err := scanner.Err(); err != nil {
fmt.Println("扫描错误:", err)
}
text := "Hello World Go Language"
wordScanner := bufio.NewScanner(strings.NewReader(text))
wordScanner.Split(bufio.ScanWords)
fmt.Println("按单词扫描:")
for wordScanner.Scan() {
fmt.Println(" ", wordScanner.Text())
}
}
8.9 encoding/json 包 —— JSON编解码
核心功能: 提供JSON数据的编码(序列化)和解码(反序列化)功能。
主要函数
| 函数 |
签名 |
说明 |
| Marshal |
func Marshal(v any) ([]byte, error) |
将Go值序列化为JSON字节切片 |
| MarshalIndent |
func MarshalIndent(v any, prefix, indent string) ([]byte, error) |
带缩进的序列化 |
| Unmarshal |
func Unmarshal(data []byte, v any) error |
将JSON反序列化为Go值 |
| NewEncoder |
func NewEncoder(w io.Writer) *Encoder |
创建JSON编码器(流式) |
| NewDecoder |
func NewDecoder(r io.Reader) *Decoder |
创建JSON解码器(流式) |
Encoder/Decoder 方法
| 方法 |
说明 |
Encoder.Encode(v any) error |
编码并写入 |
Encoder.SetIndent(prefix, indent string) |
设置缩进 |
Decoder.Decode(v any) error |
从流中解码 |
Decoder.DisallowUnknownFields() |
禁止未知字段 |
JSON Tag 常用选项
| 选项 |
说明 |
示例 |
json:"fieldname" |
指定JSON字段名 |
json:"user_name" |
json:"-" |
忽略该字段 |
json:"-" |
json:",omitempty" |
零值时忽略 |
json:"age,omitempty" |
json:",string" |
转为字符串类型 |
json:"id,string" |
package main
import (
"bytes"
"encoding/json"
"fmt"
"os"
)
type Person struct {
Name string `json:"name"`
Age int `json:"age,omitempty"`
Email string `json:"email,omitempty"`
Tags []string `json:"tags,omitempty"`
secret string `json:"-"`
}
func main() {
p := Person{
Name: "张三",
Age: 30,
Email: "zhangsan@example.com",
Tags: []string{"go", "programming"},
}
data, _ := json.Marshal(p)
fmt.Println("Marshal:", string(data))
prettyData, _ := json.MarshalIndent(p, "", " ")
fmt.Println("MarshalIndent:\n", string(prettyData))
jsonStr := `{"name":"李四","age":25,"email":"lisi@example.com","tags":["java","spring"]}`
var p2 Person
err := json.Unmarshal([]byte(jsonStr), &p2)
if err != nil {
fmt.Println("解析错误:", err)
} else {
fmt.Printf("Unmarshal: %+v\n", p2)
}
var result map[string]interface{}
json.Unmarshal([]byte(jsonStr), &result)
fmt.Println("解析为map:", result)
fmt.Println("name:", result["name"])
complexJSON := `{
"users": [
{"id": 1, "name": "Alice"},
{"id": 2, "name": "Bob"}
],
"total": 2,
"page": 1
}`
var data2 struct {
Users []struct {
ID int `json:"id"`
Name string `json:"name"`
} `json:"users"`
Total int `json:"total"`
}
json.Unmarshal([]byte(complexJSON), &data2)
fmt.Printf("解析嵌套JSON: %+v\n", data2)
f, _ := os.Create("person.json")
defer f.Close()
encoder := json.NewEncoder(f)
encoder.SetIndent("", " ")
encoder.Encode(p)
jsonData := []byte(`{"name":"王五","age":35}`)
decoder := json.NewDecoder(bytes.NewReader(jsonData))
var p3 Person
decoder.Decode(&p3)
fmt.Printf("Decoder: %+v\n", p3)
type Event struct {
Type string `json:"type"`
Data json.RawMessage `json:"data"`
}
eventJSON := `{"type":"login","data":{"username":"admin","ip":"127.0.0.1"}}`
var event Event
json.Unmarshal([]byte(eventJSON), &event)
fmt.Printf("Event类型: %s, 原始数据: %s\n", event.Type, event.Data)
numberJSON := `{"price": 123.456, "count": 999999999999999999}`
dec := json.NewDecoder(bytes.NewReader([]byte(numberJSON)))
dec.UseNumber()
var numData map[string]interface{}
dec.Decode(&numData)
fmt.Printf("类型: price=%T, count=%T\n", numData["price"], numData["count"])
}
8.10 time 包 —— 时间处理
核心功能: 时间测量和显示,包括时间点的表示、时间间隔的计算、定时器等。
主要类型
| 类型 |
说明 |
Time |
时间点,精确到纳秒,包含时区信息 |
Duration |
时间段,以纳秒为单位的 int64 类型 |
Location |
时区 |
Timer |
一次性定时器(触发后失效) |
Ticker |
周期性定时器(每隔一段时间触发) |
常用函数
| 函数 |
签名 |
说明 |
| Now |
func Now() Time |
当前时间 |
| Date |
func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time |
创建指定时间 |
| Parse |
func Parse(layout, value string) (Time, error) |
解析时间字符串 |
| ParseInLocation |
func ParseInLocation(layout, value string, loc *Location) (Time, error) |
指定时区解析 |
| Unix |
func Unix(sec int64, nsec int64) Time |
从Unix时间戳创建 |
| Since |
func Since(t Time) Duration |
从t到现在的时长 |
| Until |
func Until(t Time) Duration |
从现在到t的时长 |
| Sleep |
func Sleep(d Duration) |
暂停当前goroutine |
| After |
func After(d Duration) <-chan Time |
返回一个channel,d时间后发送信号 |
| Tick |
func Tick(d Duration) <-chan Time |
返回周期性发送信号的channel |
| NewTimer |
func NewTimer(d Duration) *Timer |
创建一次性定时器 |
| NewTicker |
func NewTicker(d Duration) *Ticker |
创建周期性定时器 |
| FixedZone |
func FixedZone(name string, offset int) *Location |
创建固定偏移时区 |
| LoadLocation |
func LoadLocation(name string) (*Location, error) |
加载时区 |
Time 方法
| 方法 |
返回值 |
说明 |
| Year() |
int |
年份 |
| Month() |
Month |
月份 |
| Day() |
int |
日 |
| Hour() |
int |
小时 |
| Minute() |
int |
分钟 |
| Second() |
int |
秒 |
| Nanosecond() |
int |
纳秒 |
| Weekday() |
Weekday |
星期几 |
| Unix() |
int64 |
Unix时间戳(秒) |
| UnixMilli() |
int64 |
Unix时间戳(毫秒) |
| UnixNano() |
int64 |
Unix时间戳(纳秒) |
| Format(layout) |
string |
格式化时间 |
| Add(d Duration) |
Time |
加上时间段 |
| Sub(t Time) |
Duration |
时间差 |
| Before(t Time) |
bool |
是否在t之前 |
| After(t Time) |
bool |
是否在t之后 |
| Equal(t Time) |
bool |
是否相等 |
| In(loc *Location) |
Time |
转换时区 |
| Local() |
Time |
转为本地时间 |
| UTC() |
Time |
转为UTC时间 |
| IsZero() |
bool |
是否为零值 |
时间格式化参考时间
Mon Jan 2 15:04:05 MST 2006(2006-01-02 15:04:05,1 2 3 4 5 6 7记忆法)
package main
import (
"fmt"
"time"
)
func main() {
now := time.Now()
fmt.Println("当前时间:", now)
fmt.Printf("年=%d, 月=%d, 日=%d, 时=%d, 分=%d, 秒=%d\n",
now.Year(), now.Month(), now.Day(),
now.Hour(), now.Minute(), now.Second())
fmt.Println("星期:", now.Weekday())
fmt.Println("Unix秒:", now.Unix())
fmt.Println("Unix毫秒:", now.UnixMilli())
fmt.Println("标准格式:", now.Format("2006-01-02 15:04:05"))
fmt.Println("RFC3339:", now.Format(time.RFC3339))
fmt.Println("日期:", now.Format("2006-01-02"))
fmt.Println("时间:", now.Format("15:04:05"))
fmt.Println("12小时制:", now.Format("2006-01-02 03:04:05 PM"))
fmt.Println("中文格式:", now.Format("2006年01月02日 15时04分05秒"))
t1, _ := time.Parse("2006-01-02 15:04:05", "2024-06-15 14:30:00")
fmt.Println("解析时间:", t1)
t2 := time.Unix(1718438400, 0)
fmt.Println("从时间戳创建:", t2)
t3 := time.UnixMilli(1718438400000)
fmt.Println("从毫秒时间戳创建:", t3)
now = time.Now()
oneHourLater := now.Add(time.Hour)
tenMinutesAgo := now.Add(-10 * time.Minute)
twoDaysLater := now.AddDate(0, 0, 2)
oneMonthAgo := now.AddDate(0, -1, 0)
fmt.Println("一小时后:", oneHourLater)
fmt.Println("十分钟前:", tenMinutesAgo)
fmt.Println("两天后:", twoDaysLater)
fmt.Println("一个月前:", oneMonthAgo)
duration := oneHourLater.Sub(now)
fmt.Printf("时间差: %.0f分钟\n", duration.Minutes())
fmt.Println("now before oneHourLater:", now.Before(oneHourLater))
fmt.Println("now after tenMinutesAgo:", now.After(tenMinutesAgo))
var d time.Duration = 2*time.Hour + 30*time.Minute + 15*time.Second
fmt.Printf("自定义Duration: %s\n", d)
fmt.Printf(" 小时: %.2f\n", d.Hours())
fmt.Printf(" 分钟: %.0f\n", d.Minutes())
fmt.Printf(" 秒: %.0f\n", d.Seconds())
fmt.Printf(" 毫秒: %d\n", d.Milliseconds())
timer := time.NewTimer(2 * time.Second)
fmt.Println("等待Timer...")
<-timer.C
fmt.Println("Timer触发!")
<-time.After(500 * time.Millisecond)
timer2 := time.NewTimer(time.Second)
go func() {
<-timer2.C
fmt.Println("这条不会打印,因为timer被停止了")
}()
stopped := timer2.Stop()
if stopped {
fmt.Println("Timer被成功停止")
}
ticker := time.NewTicker(500 * time.Millisecond)
done := make(chan bool)
go func() {
count := 0
for {
select {
case t := <-ticker.C:
fmt.Println("Ticker触发:", t.Format("15:04:05.000"))
count++
if count >= 3 {
ticker.Stop()
done <- true
return
}
}
}
}()
<-done
fmt.Println("Ticker已停止")
loc, _ := time.LoadLocation("Asia/Shanghai")
shanghaiTime := time.Now().In(loc)
fmt.Println("上海时间:", shanghaiTime)
utcTime := now.UTC()
fmt.Println("UTC时间:", utcTime)
east8 := time.FixedZone("UTC+8", 8*3600)
t4 := time.Date(2024, 6, 15, 14, 30, 0, 0, east8)
fmt.Println("指定时区时间:", t4)
start := time.Now()
time.Sleep(100 * time.Millisecond)
elapsed := time.Since(start)
fmt.Printf("操作耗时: %s (%d毫秒)\n", elapsed, elapsed.Milliseconds())
}
8.11 net/http 包 —— HTTP客户端与服务器
核心功能: 提供HTTP客户端和HTTP服务器实现。
HTTP 客户端函数
| 函数/类型 |
说明 |
http.Get(url) |
发送GET请求,返回 (*Response, error) |
http.Post(url, contentType, body) |
发送POST请求 |
http.PostForm(url, data) |
发送POST表单请求 |
http.Head(url) |
发送HEAD请求 |
http.NewRequest(method, url, body) |
创建自定义请求 |
http.DefaultClient |
默认HTTP客户端 |
&http.Client{...} |
自定义HTTP客户端(可设置超时等) |
HTTP 服务器函数
| 函数/类型 |
说明 |
http.HandleFunc(pattern, handler) |
注册路由处理函数 |
http.Handle(pattern, handler) |
注册路由处理器 |
http.ListenAndServe(addr, handler) |
启动HTTP服务器 |
http.ServeMux |
HTTP请求多路复用器(路由器) |
http.FileServer(root) |
静态文件服务器 |
http.StripPrefix(prefix, handler) |
去除URL前缀 |
http.Redirect(w, r, url, code) |
重定向 |
http.Error(w, msg, code) |
发送HTTP错误响应 |
http.NotFound(w, r) |
发送404响应 |
Request 结构体主要字段
| 字段 |
类型 |
说明 |
| Method |
string |
请求方法(GET/POST等) |
| URL |
*url.URL |
请求URL |
| Header |
Header |
请求头 |
| Body |
io.ReadCloser |
请求体 |
| Form |
url.Values |
解析后的表单数据 |
| PostForm |
url.Values |
仅POST表单数据 |
| RemoteAddr |
string |
客户端地址 |
| Context |
context.Context |
请求上下文 |
Response 结构体主要字段
| 字段 |
类型 |
说明 |
| Status |
string |
状态文本(如”200 OK”) |
| StatusCode |
int |
状态码 |
| Header |
Header |
响应头 |
| Body |
io.ReadCloser |
响应体 |
package main
import (
"encoding/json"
"fmt"
"io"
"net/http"
"time"
)
func main() {
http.HandleFunc("/", homeHandler)
http.HandleFunc("/hello", helloHandler)
http.HandleFunc("/user/", userHandler)
http.HandleFunc("/api/json", jsonHandler)
http.HandleFunc("/form", formHandler)
server := &http.Server{
Addr: ":8080",
Handler: nil,
ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second,
IdleTimeout: 30 * time.Second,
}
fmt.Println("服务器启动在 http://localhost:8080")
server.ListenAndServe()
}
func homeHandler(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/" {
http.NotFound(w, r)
return
}
fmt.Fprintf(w, "欢迎来到Go HTTP服务器!\n")
fmt.Fprintf(w, "方法: %s\n", r.Method)
fmt.Fprintf(w, "路径: %s\n", r.URL.Path)
}
func helloHandler(w http.ResponseWriter, r *http.Request) {
name := r.URL.Query().Get("name")
if name == "" {
name = "World"
}
fmt.Fprintf(w, "Hello, %s!\n", name)
}
func userHandler(w http.ResponseWriter, r *http.Request) {
id := r.URL.Path[len("/user/"):]
fmt.Fprintf(w, "用户ID: %s\n", id)
fmt.Fprintf(w, "查询参数: %v\n", r.URL.Query())
}
func jsonHandler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
data := map[string]interface{}{
"status": "ok",
"time": time.Now().Format(time.RFC3339),
"method": r.Method,
}
json.NewEncoder(w).Encode(data)
}
func formHandler(w http.ResponseWriter, r *http.Request) {
if r.Method == "POST" {
r.ParseForm()
username := r.FormValue("username")
password := r.FormValue("password")
fmt.Fprintf(w, "用户名: %s\n", username)
fmt.Fprintf(w, "密码: %s\n", password)
fmt.Fprintf(w, "原始Form: %v\n", r.Form)
} else {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
fmt.Fprintf(w, `
<form method="POST" action="/form">
<input name="username" placeholder="用户名">
<input name="password" type="password" placeholder="密码">
<button type="submit">提交</button>
</form>`)
}
}
HTTP 客户端使用示例
package main
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
"strings"
"time"
)
func main() {
resp, err := http.Get("https://jsonplaceholder.typicode.com/posts/1")
if err != nil {
fmt.Println("GET请求失败:", err)
return
}
defer resp.Body.Close()
fmt.Printf("状态: %s\n", resp.Status)
fmt.Printf("状态码: %d\n", resp.StatusCode)
body, _ := io.ReadAll(resp.Body)
fmt.Println("响应体:", string(body[:100]), "...")
params := url.Values{}
params.Add("userId", "1")
fullURL := "https://jsonplaceholder.typicode.com/posts?" + params.Encode()
fmt.Println("带参数URL:", fullURL)
jsonData := map[string]interface{}{
"title": "Go Tutorial",
"body": "Learning Go is fun",
"userId": 1,
}
jsonBytes, _ := json.Marshal(jsonData)
resp2, err := http.Post(
"https://jsonplaceholder.typicode.com/posts",
"application/json",
bytes.NewBuffer(jsonBytes),
)
if err != nil {
fmt.Println("POST请求失败:", err)
return
}
defer resp2.Body.Close()
fmt.Println("POST状态:", resp2.Status)
formData := url.Values{
"username": {"gopher"},
"password": {"secret123"},
}
resp3, err := http.PostForm(
"https://httpbin.org/post",
formData,
)
if err != nil {
fmt.Println("POST表单失败:", err)
return
}
defer resp3.Body.Close()
fmt.Println("POST表单状态:", resp3.Status)
req, _ := http.NewRequest("GET", "https://jsonplaceholder.typicode.com/posts/1", nil)
req.Header.Set("User-Agent", "Go-HTTP-Client/1.0")
req.Header.Set("Accept", "application/json")
client := &http.Client{}
resp4, err := client.Do(req)
if err != nil {
fmt.Println("自定义请求失败:", err)
return
}
defer resp4.Body.Close()
fmt.Println("自定义请求状态:", resp4.Status)
timeoutClient := &http.Client{
Timeout: 5 * time.Second,
Transport: &http.Transport{
MaxIdleConns: 10,
IdleConnTimeout: 30 * time.Second,
DisableCompression: false,
},
}
req2, _ := http.NewRequest("GET", "https://jsonplaceholder.typicode.com/posts", nil)
resp5, err := timeoutClient.Do(req2)
if err != nil {
fmt.Println("超时客户端请求失败:", err)
return
}
defer resp5.Body.Close()
fmt.Println("超时客户端状态:", resp5.Status)
contentType := resp5.Header.Get("Content-Type")
fmt.Println("Content-Type:", contentType)
if strings.Contains(contentType, "application/json") {
var result []map[string]interface{}
body, _ := io.ReadAll(resp5.Body)
json.Unmarshal(body, &result)
fmt.Printf("JSON数组长度: %d\n", len(result))
}
}
8.12 context 包 —— 上下文管理
核心功能: 在goroutine之间传递请求范围的值、取消信号和超时控制。
主要函数
| 函数 |
签名 |
说明 |
| Background |
func Background() Context |
根Context(通常用于main函数) |
| TODO |
func TODO() Context |
不确定用哪个Context时的占位符 |
| WithCancel |
func WithCancel(parent Context) (ctx Context, cancel CancelFunc) |
可取消的Context |
| WithDeadline |
func WithDeadline(parent Context, d time.Time) (Context, CancelFunc) |
截止时间的Context |
| WithTimeout |
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) |
超时时间的Context |
| WithValue |
func WithValue(parent Context, key, val any) Context |
携带键值对的Context |
Context 接口方法
| 方法 |
说明 |
Deadline() (deadline time.Time, ok bool) |
返回截止时间 |
Done() <-chan struct{} |
返回取消信号channel |
Err() error |
返回取消原因 |
Value(key any) any |
返回关联的值 |
package main
import (
"context"
"fmt"
"time"
)
func main() {
ctx, cancel := context.WithCancel(context.Background())
go func() {
select {
case <-ctx.Done():
fmt.Println("goroutine 被取消:", ctx.Err())
}
}()
time.Sleep(100 * time.Millisecond)
cancel()
time.Sleep(50 * time.Millisecond)
ctx2, cancel2 := context.WithTimeout(context.Background(), 200*time.Millisecond)
defer cancel2()
select {
case <-time.After(500 * time.Millisecond):
fmt.Println("操作完成")
case <-ctx2.Done():
fmt.Println("超时:", ctx2.Err())
}
deadline := time.Now().Add(300 * time.Millisecond)
ctx3, cancel3 := context.WithDeadline(context.Background(), deadline)
defer cancel3()
select {
case <-time.After(time.Second):
fmt.Println("操作完成")
case <-ctx3.Done():
fmt.Println("到达截止时间:", ctx3.Err())
}
type contextKey string
ctx4 := context.WithValue(context.Background(), contextKey("userID"), 12345)
ctx4 = context.WithValue(ctx4, contextKey("traceID"), "abc-def-123")
processRequest(ctx4)
parentCtx := context.Background()
valCtx := context.WithValue(parentCtx, contextKey("app"), "myapp")
timeoutCtx, cancel5 := context.WithTimeout(valCtx, time.Second)
defer cancel5()
fmt.Println("链式Context值:", timeoutCtx.Value(contextKey("app")))
}
func processRequest(ctx context.Context) {
userID := ctx.Value(contextKey("userID"))
traceID := ctx.Value(contextKey("traceID"))
fmt.Printf("处理请求: userID=%v, traceID=%v\n", userID, traceID)
}
func handleRequest(ctx context.Context) {
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
resultCh := make(chan string, 1)
go func() {
time.Sleep(2 * time.Second)
resultCh <- "操作结果"
}()
select {
case result := <-resultCh:
fmt.Println("成功:", result)
case <-ctx.Done():
fmt.Println("请求被取消或超时:", ctx.Err())
}
}
8.13 log 包 —— 日志记录
核心功能: 提供简单的日志记录功能,包括日志级别设置、输出格式定制、输出目标设置等。
主要函数和类型
| 函数/类型 |
说明 |
log.Print(v ...any) |
打印日志 |
log.Printf(format string, v ...any) |
格式化打印日志 |
log.Println(v ...any) |
打印日志并换行 |
log.Fatal(v ...any) |
打印日志后调用 os.Exit(1) |
log.Fatalf(format string, v ...any) |
格式化Fatal |
log.Panic(v ...any) |
打印日志后调用 panic |
log.Panicf(format string, v ...any) |
格式化Panic |
log.SetOutput(w io.Writer) |
设置日志输出目标 |
log.SetFlags(flag int) |
设置日志前缀标志 |
log.SetPrefix(prefix string) |
设置日志前缀 |
log.New(out io.Writer, prefix string, flag int) *Logger |
创建自定义Logger |
日志标志(Flags)
| 常量 |
说明 |
示例输出 |
| Ldate |
日期 |
2024/06/15 |
| Ltime |
时间 |
14:30:00 |
| Lmicroseconds |
微秒 |
14:30:00.123456 |
| Llongfile |
完整文件路径和行号 |
/path/to/file.go:42 |
| Lshortfile |
文件名和行号 |
file.go:42 |
| LUTC |
使用UTC时间 |
|
| LstdFlags |
默认标志(Ldate |
Ltime) |
package main
import (
"fmt"
"io"
"log"
"os"
)
func main() {
log.Print("这是一条普通日志")
log.Printf("格式化日志: 用户=%s, 操作=%s", "张三", "登录")
log.Println("带换行的日志")
log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
log.Println("设置了日期+时间+短文件名标志")
log.SetPrefix("[MyApp] ")
log.Println("带前缀的日志")
f, _ := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
defer f.Close()
logger := log.New(f, "[INFO] ", log.Ldate|log.Ltime|log.Lshortfile)
logger.Println("写入到文件的日志")
multiWriter := io.MultiWriter(os.Stdout, f)
multiLogger := log.New(multiWriter, "[APP] ", log.LstdFlags)
multiLogger.Println("同时输出到控制台和文件")
infoLogger := log.New(os.Stdout, "[INFO] ", log.LstdFlags)
warnLogger := log.New(os.Stdout, "[WARN] ", log.LstdFlags)
errLogger := log.New(os.Stderr, "[ERROR] ", log.LstdFlags|log.Lshortfile)
infoLogger.Println("应用启动成功")
warnLogger.Println("磁盘使用率达到80%")
errLogger.Println("数据库连接失败")
defer func() {
if r := recover(); r != nil {
fmt.Println("捕获到log.Panic:", r)
}
}()
log.Panicln("Panic错误信息")
}
8.14 sort 包 —— 排序
核心功能: 提供切片排序和搜索功能。
排序函数
| 函数 |
说明 |
sort.Ints(x []int) |
对int切片排序 |
sort.Float64s(x []float64) |
对float64切片排序 |
sort.Strings(x []string) |
对string切片排序 |
sort.IntsAreSorted(x []int) bool |
检查int切片是否已排序 |
sort.Sort(data Interface) |
对自定义类型排序 |
sort.Stable(data Interface) |
稳定排序 |
sort.Slice(x any, less func(i, j int) bool) |
对任意切片排序 |
sort.SliceStable(x any, less func(i, j int) bool) |
稳定排序任意切片 |
sort.Reverse(data Interface) Interface |
反转排序顺序 |
sort.Search(n int, f func(int) bool) int |
二分搜索 |
sort.SearchInts(a []int, x int) int |
在int切片中搜索 |
sort.SearchFloat64s(a []float64, x float64) int |
在float64切片中搜索 |
sort.SearchStrings(a []string, x string) int |
在string切片中搜索 |
sort.Interface 接口
type Interface interface {
Len() int
Less(i, j int) bool
Swap(i, j int)
}
package main
import (
"fmt"
"sort"
)
func main() {
ints := []int{64, 2, 128, 32, 16, 8, 4}
sort.Ints(ints)
fmt.Println("排序后:", ints)
strings := []string{"banana", "apple", "cherry", "date"}
sort.Strings(strings)
fmt.Println("排序后:", strings)
sort.Sort(sort.Reverse(sort.IntSlice(ints)))
fmt.Println("降序:", ints)
people := []struct {
Name string
Age int
}{
{"Alice", 30},
{"Bob", 25},
{"Charlie", 35},
{"David", 20},
}
sort.Slice(people, func(i, j int) bool {
return people[i].Age < people[j].Age
})
fmt.Println("按年龄排序:", people)
sort.Slice(people, func(i, j int) bool {
return people[i].Name < people[j].Name
})
fmt.Println("按名字排序:", people)
type Book struct {
Title string
Author string
Pages int
}
type ByPages []Book
func (b ByPages) Len() int { return len(b) }
func (b ByPages) Less(i, j int) bool { return b[i].Pages < b[j].Pages }
func (b ByPages) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
books := []Book{
{"Go入门", "张三", 300},
{"Python教程", "李四", 450},
{"Java编程", "王五", 200},
}
sort.Sort(ByPages(books))
fmt.Println("按页数排序:", books)
sortedInts := []int{1, 3, 5, 7, 9, 11, 13}
index := sort.SearchInts(sortedInts, 7)
fmt.Printf("7在索引%d的位置(已找到: %v)\n", index, sortedInts[index] == 7)
index2 := sort.SearchInts(sortedInts, 6)
fmt.Printf("6应该插入在索引%d的位置\n", index2)
index3 := sort.Search(len(sortedInts), func(i int) bool {
return sortedInts[i] >= 10
})
fmt.Printf("第一个>=10的值在索引%d: %d\n", index3, sortedInts[index3])
fmt.Println("ints已排序:", sort.IntsAreSorted(ints))
fmt.Println("strings已排序:", sort.StringsAreSorted(strings))
}
8.15 math 包 —— 数学函数
核心功能: 提供基本的数学常量和函数。
数学常量
math.E
math.Pi
math.Phi
math.Sqrt2
math.SqrtE
math.SqrtPi
math.Ln2
math.Log2E
math.Ln10
math.MaxFloat64
math.SmallestNonzeroFloat64
常用函数
| 函数 |
说明 |
函数 |
说明 |
Abs(x) |
绝对值 |
Ceil(x) |
向上取整 |
Floor(x) |
向下取整 |
Round(x) |
四舍五入 |
Trunc(x) |
截断小数 |
Mod(x, y) |
取模 |
Pow(x, y) |
x的y次方 |
Sqrt(x) |
平方根 |
Cbrt(x) |
立方根 |
Exp(x) |
e的x次方 |
Log(x) |
自然对数 |
Log10(x) |
10为底对数 |
Log2(x) |
2为底对数 |
Hypot(x, y) |
sqrt(x²+y²) |
Sin(x) |
正弦 |
Cos(x) |
余弦 |
Tan(x) |
正切 |
Asin(x) |
反正弦 |
Max(x, y) |
最大值 |
Min(x, y) |
最小值 |
Dim(x, y) |
max(x-y, 0) |
Inf(sign) |
无穷大 |
NaN() |
非数字 |
IsNaN(x) |
判断NaN |
IsInf(x, sign) |
判断无穷 |
Signbit(x) |
判断负号 |
FMA(x, y, z) |
x*y+z(精确) |
Erf(x) |
误差函数 |
package main
import (
"fmt"
"math"
"math/rand"
)
func main() {
fmt.Printf("Abs(-3.14): %.2f\n", math.Abs(-3.14))
fmt.Printf("Ceil(3.14): %.0f, Floor(3.14): %.0f\n", math.Ceil(3.14), math.Floor(3.14))
fmt.Printf("Round(3.5): %.0f, Trunc(3.9): %.0f\n", math.Round(3.5), math.Trunc(3.9))
fmt.Printf("Mod(10, 3): %.0f\n", math.Mod(10, 3))
fmt.Printf("Pow(2, 10): %.0f\n", math.Pow(2, 10))
fmt.Printf("Sqrt(16): %.0f\n", math.Sqrt(16))
angle := math.Pi / 4
fmt.Printf("Sin(45°): %.4f\n", math.Sin(angle))
fmt.Printf("Cos(45°): %.4f\n", math.Cos(angle))
fmt.Printf("Tan(45°): %.4f\n", math.Tan(angle))
fmt.Printf("Max(10, 20): %v\n", math.Max(10, 20))
fmt.Printf("Min(10, 20): %v\n", math.Min(10, 20))
fmt.Println("NaN:", math.NaN())
fmt.Println("IsNaN(NaN):", math.IsNaN(math.NaN()))
fmt.Println("Inf(1):", math.Inf(1))
fmt.Println("随机整数:", rand.Intn(100))
fmt.Println("随机浮点数:", rand.Float64())
fmt.Println("随机Int31:", rand.Int31())
src := rand.NewSource(42)
rng := rand.New(src)
fmt.Println("种子随机:", rng.Intn(100), rng.Intn(100))
buf := make([]byte, 4)
rand.Read(buf)
fmt.Printf("随机字节: %x\n", buf)
items := []int{1, 2, 3, 4, 5}
rand.Shuffle(len(items), func(i, j int) {
items[i], items[j] = items[j], items[i]
})
fmt.Println("打乱后:", items)
}
8.16 crypto 包 —— 加密
核心功能: 提供常用加密算法的实现,包括哈希、对称加密、非对称加密等。
主要子包
| 子包 |
功能 |
| crypto/md5 |
MD5哈希(不安全,仅用于兼容) |
| crypto/sha1 |
SHA1哈希 |
| crypto/sha256 |
SHA256哈希 |
| crypto/sha512 |
SHA512哈希 |
| crypto/hmac |
HMAC消息认证 |
| crypto/aes |
AES对称加密 |
| crypto/rand |
加密安全的随机数生成器 |
| crypto/rsa |
RSA非对称加密 |
| crypto/ecdsa |
ECDSA椭圆曲线数字签名 |
| crypto/ed25519 |
Ed25519签名 |
| crypto/tls |
TLS/SSL协议实现 |
| crypto/x509 |
X.509证书解析 |
package main
import (
"crypto/aes"
"crypto/cipher"
"crypto/hmac"
"crypto/md5"
"crypto/rand"
"crypto/sha256"
"encoding/hex"
"fmt"
"io"
)
func main() {
data := "Hello, Go!"
md5Hash := md5.Sum([]byte(data))
fmt.Printf("MD5: %x\n", md5Hash)
sha256Hash := sha256.Sum256([]byte(data))
fmt.Printf("SHA256: %x\n", sha256Hash)
h := sha256.New()
h.Write([]byte("Hello, "))
h.Write([]byte("Go!"))
fmt.Printf("SHA256(流式): %x\n", h.Sum(nil))
secret := []byte("my-secret-key")
mac := hmac.New(sha256.New, secret)
mac.Write([]byte(data))
expectedMAC := mac.Sum(nil)
fmt.Printf("HMAC-SHA256: %x\n", expectedMAC)
mac2 := hmac.New(sha256.New, secret)
mac2.Write([]byte(data))
if hmac.Equal(expectedMAC, mac2.Sum(nil)) {
fmt.Println("HMAC验证成功")
}
randomBytes := make([]byte, 16)
_, err := io.ReadFull(rand.Reader, randomBytes)
if err == nil {
fmt.Printf("安全随机字节: %x\n", randomBytes)
}
var n [1]byte
rand.Read(n[:])
fmt.Printf("安全随机数: %d\n", int(n[0])%100)
key := sha256.Sum256([]byte("my-secret-password"))
plaintext := []byte("这是一段需要加密的敏感数据")
ciphertext, err := aesEncrypt(plaintext, key[:])
if err != nil {
fmt.Println("加密失败:", err)
return
}
fmt.Printf("密文: %x\n", ciphertext)
decrypted, err := aesDecrypt(ciphertext, key[:])
if err != nil {
fmt.Println("解密失败:", err)
return
}
fmt.Printf("解密: %s\n", decrypted)
str := "password123"
hash := sha256Hex(str)
fmt.Printf("SHA256(%s) = %s\n", str, hash)
}
func aesEncrypt(plaintext, key []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
gcm, err := cipher.NewGCM(block)
if err != nil {
return nil, err
}
nonce := make([]byte, gcm.NonceSize())
if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
return nil, err
}
ciphertext := gcm.Seal(nonce, nonce, plaintext, nil)
return ciphertext, nil
}
func aesDecrypt(ciphertext, key []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
gcm, err := cipher.NewGCM(block)
if err != nil {
return nil, err
}
nonceSize := gcm.NonceSize()
if len(ciphertext) < nonceSize {
return nil, fmt.Errorf("密文太短")
}
nonce, ciphertext := ciphertext[:nonceSize], ciphertext[nonceSize:]
plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
if err != nil {
return nil, err
}
return plaintext, nil
}
func sha256Hex(s string) string {
hash := sha256.Sum256([]byte(s))
return hex.EncodeToString(hash[:])
}
8.17 reflect 包 —— 反射
核心功能: 运行时类型检查和操作,允许程序检查、修改自身的结构和行为。
主要类型
| 类型 |
说明 |
Type |
表示Go类型的接口 |
Value |
表示Go值的结构体 |
Kind |
类型的种类(如Int、String、Struct等) |
StructField |
结构体字段信息 |
StructTag |
结构体标签 |
常用函数
| 函数 |
说明 |
reflect.TypeOf(i any) Type |
获取值的类型 |
reflect.ValueOf(i any) Value |
获取值的反射Value |
reflect.New(typ Type) Value |
创建类型的新指针 |
reflect.DeepEqual(a, b any) bool |
深度比较 |
Value 方法
| 方法 |
说明 |
Kind() Kind |
返回类型的种类 |
Type() Type |
返回类型 |
Interface() interface{} |
还原为interface{} |
Int() int64 |
返回值(int类型) |
Float() float64 |
返回值(float类型) |
String() string |
返回值(string类型) |
Bool() bool |
返回值(bool类型) |
NumField() int |
结构体字段数 |
Field(i int) Value |
获取第i个字段 |
FieldByName(name string) Value |
按名称获取字段 |
NumMethod() int |
方法数 |
Method(i int) Value |
获取第i个方法 |
MethodByName(name string) Value |
按名称获取方法 |
Call(in []Value) []Value |
调用方法 |
CanSet() bool |
是否可设置 |
SetInt(x int64) |
设置int值 |
SetString(s string) |
设置string值 |
Elem() Value |
指针指向的值 |
IsNil() bool |
是否为nil |
IsValid() bool |
是否有效 |
IsZero() bool |
是否为零值 |
package main
import (
"fmt"
"reflect"
)
type User struct {
ID int `json:"id" validate:"required"`
Name string `json:"name" validate:"required,min=2,max=50"`
Email string `json:"email,omitempty"`
age int
}
func (u User) Greet() string {
return "Hello, " + u.Name
}
func (u *User) SetName(name string) {
u.Name = name
}
func main() {
u := User{ID: 1, Name: "张三", Email: "zhangsan@example.com", age: 30}
t := reflect.TypeOf(u)
v := reflect.ValueOf(u)
fmt.Println("类型:", t)
fmt.Println("类型名称:", t.Name())
fmt.Println("类型种类:", t.Kind())
fmt.Println("值:", v)
fmt.Println("\n遍历结构体字段:")
for i := 0; i < t.NumField(); i++ {
field := t.Field(i)
value := v.Field(i)
fmt.Printf(" 字段%d: %s", i+1, field.Name)
fmt.Printf(" 类型: %s", field.Type)
fmt.Printf(" 值: %v", value.Interface())
fmt.Printf(" 标签: %s", field.Tag)
fmt.Printf(" 是否导出: %v", field.IsExported())
fmt.Println()
if jsonTag := field.Tag.Get("json"); jsonTag != "" {
fmt.Printf(" json标签: %s\n", jsonTag)
}
if validateTag := field.Tag.Get("validate"); validateTag != "" {
fmt.Printf(" validate标签: %s\n", validateTag)
}
}
fmt.Println("\n遍历方法:")
for i := 0; i < t.NumMethod(); i++ {
method := t.Method(i)
fmt.Printf(" 方法%d: %s, 类型: %s\n", i+1, method.Name, method.Type)
}
uPtr := &User{Name: "李四"}
v2 := reflect.ValueOf(uPtr).Elem()
if nameField := v2.FieldByName("Name"); nameField.IsValid() && nameField.CanSet() {
nameField.SetString("王五")
}
fmt.Println("修改后:", uPtr.Name)
method := v.MethodByName("Greet")
if method.IsValid() {
results := method.Call(nil)
fmt.Println("调用Greet:", results[0].String())
}
method2 := reflect.ValueOf(uPtr).MethodByName("SetName")
if method2.IsValid() {
method2.Call([]reflect.Value{reflect.ValueOf("赵六")})
fmt.Println("SetName后:", uPtr.Name)
}
func inspectKind(x interface{}) {
switch reflect.TypeOf(x).Kind() {
case reflect.Int, reflect.Int64:
fmt.Println("整数类型")
case reflect.String:
fmt.Println("字符串类型")
case reflect.Slice:
fmt.Println("切片类型")
case reflect.Struct:
fmt.Println("结构体类型")
case reflect.Ptr:
fmt.Println("指针类型")
default:
fmt.Println("其他类型")
}
}
inspectKind(42)
inspectKind("hello")
inspectKind([]int{1, 2, 3})
inspectKind(User{})
newStruct := reflect.New(t).Elem()
newStruct.FieldByName("Name").SetString("反射创建")
newStruct.FieldByName("ID").SetInt(100)
newUser := newStruct.Interface().(User)
fmt.Printf("动态创建的用户: %+v\n", newUser)
type Greeter interface {
Greet() string
}
greeterType := reflect.TypeOf((*Greeter)(nil)).Elem()
fmt.Printf("User 是否实现了 Greeter: %v\n", t.Implements(greeterType))
}
九、测试与性能分析
9.1 单元测试
Go语言内置了轻量级的测试框架。
测试文件规范
- 测试文件以
_test.go 结尾
- 测试函数以
Test 开头,接收 *testing.T 参数
- 示例函数以
Example 开头
- 基准测试以
Benchmark 开头,接收 *testing.B 参数
package calculator
func Add(a, b int) int {
return a + b
}
func Divide(a, b float64) (float64, error) {
if b == 0 {
return 0, fmt.Errorf("除数不能为零")
}
return a / b, nil
}
package calculator
import (
"testing"
)
func TestAdd(t *testing.T) {
tests := []struct {
name string
a, b int
expected int
}{
{"正数相加", 2, 3, 5},
{"负数相加", -1, -1, -2},
{"正负数相加", -1, 1, 0},
{"零相加", 0, 0, 0},
{"大数相加", 1000000, 2000000, 3000000},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := Add(tt.a, tt.b)
if result != tt.expected {
t.Errorf("Add(%d, %d) = %d, 期望 %d",
tt.a, tt.b, result, tt.expected)
}
})
}
}
func TestDivide(t *testing.T) {
t.Run("正常除法", func(t *testing.T) {
result, err := Divide(10, 2)
if err != nil {
t.Fatalf("不应出错: %v", err)
}
if result != 5.0 {
t.Errorf("期望 5.0, 得到 %f", result)
}
})
t.Run("除零", func(t *testing.T) {
_, err := Divide(10, 0)
if err == nil {
t.Error("除零应该返回错误")
}
})
}
func TestMath(t *testing.T) {
t.Run("Add", func(t *testing.T) {
if Add(1, 1) != 2 {
t.Fatal("1+1 != 2")
}
})
}
func assertEqual(t *testing.T, got, want int) {
t.Helper()
if got != want {
t.Errorf("得到 %d, 期望 %d", got, want)
}
}
func TestAddWithHelper(t *testing.T) {
assertEqual(t, Add(2, 3), 5)
assertEqual(t, Add(-1, 1), 0)
}
func TestMain(m *testing.M) {
code := m.Run()
}
9.2 基准测试(Benchmark)
package calculator
import "testing"
func BenchmarkAdd(b *testing.B) {
for i := 0; i < b.N; i++ {
Add(100, 200)
}
}
func BenchmarkAddLarge(b *testing.B) {
for i := 0; i < b.N; i++ {
Add(99999999, 88888888)
}
}
func BenchmarkComplexOperation(b *testing.B) {
data := make([]int, 10000)
for i := range data {
data[i] = i
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
_ = Add(data[0], data[9999])
}
}
运行测试和基准测试:
go test
go test -v
go test -cover
go test -coverprofile=coverage.out
go tool cover -html=coverage.out
go test -run TestAdd
go test -run TestAdd/正数相加
go test -bench=.
go test -bench=Add
go test -bench=. -benchmem
go test -bench=. -benchtime=5s
go test -bench=. -count=3
go test -parallel 4
go test -json
9.3 示例函数(Example)
package calculator
import "fmt"
func ExampleAdd() {
result := Add(2, 3)
fmt.Println(result)
}
func ExampleAdd_negative() {
result := Add(-1, -2)
fmt.Println(result)
}
9.4 Fuzzing 模糊测试(Go 1.18+)
package calculator
import "testing"
func FuzzAdd(f *testing.F) {
f.Add(1, 2)
f.Add(0, 0)
f.Add(-1, 1)
f.Fuzz(func(t *testing.T, a, b int) {
result := Add(a, b)
if result != a+b {
t.Errorf("Add(%d, %d) = %d, 期望 %d", a, b, result, a+b)
}
})
}
go test -fuzz=FuzzAdd -fuzztime=30s
十、项目实战与最佳实践
10.1 项目组织与分层架构
myproject/
├── cmd/
│ └── server/
│ └── main.go # 程序入口
├── internal/
│ ├── handler/ # HTTP处理器层
│ │ └── user_handler.go
│ ├── service/ # 业务逻辑层
│ │ └── user_service.go
│ ├── repository/ # 数据访问层
│ │ └── user_repo.go
│ ├── model/ # 数据模型
│ │ └── user.go
│ └── config/ # 配置管理
│ └── config.go
├── pkg/ # 可复用的公共库
│ └── middleware/
│ └── auth.go
├── api/ # API定义
│ └── openapi.yaml
├── configs/ # 配置文件
│ └── config.yaml
├── scripts/ # 脚本
├── migrations/ # 数据库迁移
├── Dockerfile
├── docker-compose.yaml
├── Makefile
├── go.mod
└── go.sum
10.2 代码规范
package userservice
type Reader interface {
Read(p []byte) (n int, err error)
}
var maxRetryCount = 3
var userID int64
const DefaultTimeout = 30 * time.Second
var ErrNotFound = errors.New("资源未找到")
var ErrTimeout = errors.New("操作超时")
result, err := someOperation()
if err != nil {
return fmt.Errorf("操作失败: %w", err)
}
f, err := os.Open("file.txt")
if err != nil {
return err
}
defer f.Close()
if errors.Is(err, ErrNotFound) {
}
func NewReader(filename string) (*os.File, error) {
return os.Open(filename)
}
func process(data []byte) ([]byte, error) {
if len(data) == 0 {
return nil, errors.New("空数据")
}
return data, nil
}
func ProcessUser(ctx context.Context, userID int64) error {
select {
case <-ctx.Done():
return ctx.Err()
default:
}
return nil
}
type Service struct {
repo Repository
config *Config
}
func NewService(repo Repository, config *Config) *Service {
return &Service{repo: repo, config: config}
}
10.3 性能优化要点
s := make([]int, 0, 1000)
var builder strings.Builder
for i := 0; i < 1000; i++ {
builder.WriteString("hello")
}
result := builder.String()
var bufferPool = sync.Pool{
New: func() interface{} {
return make([]byte, 4096)
},
}
func (u *User) Process() {}
writer := bufio.NewWriter(file)
reader := bufio.NewReader(file)
sem := make(chan struct{}, 10)
for _, item := range items {
sem <- struct{}{}
go func(item Item) {
defer func() { <-sem }()
process(item)
}(item)
}
10.4 常见陷阱与注意事项
| 陷阱 |
说明 |
正确做法 |
| nil 接口判断 |
接口值为(type=nil, value=nil) != nil |
确保返回具体nil而非接口nil |
| 切片共享底层数组 |
截取切片共享底层数据 |
使用copy或full slice expression |
| for range 变量捕获 |
旧版本(Go<1.22)循环变量复用 |
使用局部变量或传参 |
| map 并发读写 |
非并发安全的map并发操作会panic |
使用sync.Mutex或sync.Map |
| defer 参数求值 |
defer语句的参数在声明时求值 |
使用闭包延迟求值 |
| goroutine 泄漏 |
未正确退出的goroutine |
使用context或channel通知退出 |
| 时间比较 |
使用 == 比较Time值 |
使用t.Equal(other) |
for _, v := range []int{1, 2, 3} {
go func() {
fmt.Println(v)
}()
}
for _, v := range []int{1, 2, 3} {
v := v
go func() {
fmt.Println(v)
}()
}
func getError() error {
var err *MyError = nil
return err
}
func getError() error {
return nil
}
base := []int{1, 2, 3, 4, 5}
sub := base[1:3]
sub = append(sub, 99)
fmt.Println(base)
sub2 := base[1:3:3]
sub2 = append(sub2, 99)
十一、工具与命令参考
11.1 go 常用命令
go build
go build -o output main.go
go run main.go
go install
go mod init module-name
go mod tidy
go mod download
go mod verify
go mod vendor
go test ./...
go test -v
go test -cover
go test -bench=.
go test -race
go vet ./...
go fmt ./...
go mod tidy
golint ./...
go version
go env
go doc fmt.Println
go doc -http=:6060
十二、总结
12.1 Go语言核心优势
| 优势 |
说明 |
| 并发原生 |
Goroutine轻量且高效,Channel通信简洁安全 |
| 编译快速 |
大型项目编译仅需数秒 |
| 部署简单 |
编译为单个二进制文件,无运行时依赖 |
| 静态类型 |
编译时发现错误,代码可维护性高 |
| 垃圾回收 |
自动内存管理,极低STW时间 |
| 标准库丰富 |
覆盖网络、加密、测试等常用场景 |
12.2 学习路径
基础语法 → 复合类型 → 方法接口 → 并发编程 → 标准库 → 项目实践
↓ ↓ ↓ ↓ ↓ ↓
变量控制 数组切片 嵌入泛型 Goroutine fmt/os Web服务
函数defer Map映射 接口多态 Channel net/http CLI工具
包管理 结构体 类型断言 Select 加密 微服务
错误处理 组合继承 同步原语 time API开发
12.3 推荐学习资源
12.4 本书涵盖的标准库总览
| 包名 |
核心功能 |
| fmt |
格式化输入输出 |
| os |
操作系统接口、文件I/O |
| io |
基础I/O接口 |
| bufio |
缓冲I/O |
| path/filepath |
文件路径操作 |
| strings |
字符串操作 |
| strconv |
字符串类型转换 |
| bytes |
字节切片操作 |
| encoding/json |
JSON编解码 |
| time |
时间处理 |
| net/http |
HTTP客户端/服务器 |
| sync |
同步原语(锁、WaitGroup等) |
| sync/atomic |
原子操作 |
| context |
上下文管理 |
| log |
日志记录 |
| errors |
错误处理工具 |
| sort |
排序和搜索 |
| math |
数学函数 |
| math/rand |
随机数 |
| crypto |
加密算法 |
| reflect |
反射机制 |
| testing |
测试框架 |
| net |
网络编程基础 |
| flag |
命令行参数解析 |
| embed |
嵌入静态文件(Go 1.16+) |
| database/sql |
数据库操作 |
| encoding/xml |
XML编解码 |
| encoding/base64 |
Base64编解码 |
| regexp |
正则表达式 |
| runtime |
运行时信息 |
| runtime/pprof |
性能分析 |
| text/template |
文本模板 |
| html/template |
HTML安全模板 |
祝你通过本书掌握Golang语言,成为一名优秀的Go开发者!