Go语言(Golang)是由Google于2007年设计、2009年开源的静态类型、编译型系统语言。其设计目标是提升开发效率与运行性能的平衡,特别适用于高并发分布式系统开发。
变量声明方式多样,常见有:
注意:短变量声明不能用于全局作用域;所有变量必须被使用(编译器强制),否则报错;未初始化的变量有零值(int为0,string为空字符串,bool为false,指针为nil)。
Go内置基础类型包括:
结构体是Go中构建复杂数据的核心机制:
type Person struct {
Name string
Age int
Emails []string
}
p := Person{Name: "Alice", Age: 30}
fmt.Println(p.Name) // Alice
结构体字段可匿名嵌入(类似“继承”),但Go无类继承体系,仅支持组合:
type Employee struct {
Person
Salary int
}
e := Employee{Person{Name:"Bob", Age:28}, 8000}
fmt.Println(e.Name) // 自动提升字段访问
数组是固定长度的有序集合,声明为[n]T,例如:var arr [5]int。长度是类型的一部分,[3]int与[5]int是不同类型。
切片(slice)是对数组的封装,是动态数组,声明为[]T:
s[i:j]示例:
s := []int{1,2,3}
s = append(s, 4,5)
fmt.Println(len(s), cap(s)) // 5 6(可能)
s2 := s[1:3] // [2,3],cap(s2)=5
⚠️注意:多个切片共享同一底层数组,修改可能相互影响。如需隔离,应使用copy创建新切片。
Go的map是哈希表实现,非线程安全。多goroutine并发读写会触发panic。
常见解决方案:
示例(带锁):
type SafeMap struct {
mu sync.RWMutex
m map[string]int
}
func (sm *SafeMap) Get(k string) (int, bool) {
sm.mu.RLock()
defer sm.mu.RUnlock()
v, ok := sm.m[k]
return v, ok
}
func (sm *SafeMap) Set(k string, v int) {
sm.mu.Lock()
defer sm.mu.Unlock()
sm.m[k] = v
}
注意:map不能直接比较(不能用==),不能作为map的key;推荐使用string或struct作为key。
Go支持一等公民函数,可赋值、作为参数/返回值:
func apply(f func(int) int, x int) int {
return f(x)
}
double := func(n int) int { return n * 2 }
result := apply(double, 5) // 10
闭包是函数与其引用环境的组合:
func counter() func() int {
n := 0
return func() int {
n++
return n
}
}
c := counter()
fmt.Println(c(), c(), c()) // 1 2 3
⚠️陷阱:循环中创建闭包时,变量捕获是引用而非值拷贝:
for i := 0; i < 3; i++ {
defer fmt.Println(i) // 输出:2 2 2(非0 1 2)
}
修正方式:在循环体内创建新变量或传参:
for i := 0; i < 3; i++ {
i := i // 新变量遮蔽
defer fmt.Println(i) // 2 1 0(注意defer逆序)
}
Go的if语句支持初始化语句:
if err := os.Open("file.txt"); err != nil {
return err
}
switch无需break,自动终止;支持类型switch:
func identify(x interface{}) {
switch v := x.(type) {
case int: fmt.Println("int:", v)
case string: fmt.Println("string:", v)
default: fmt.Println("unknown")
}
}
Go采用“错误是值”的哲学,error是内置接口:
type error interface {
Error() string
}
推荐使用errors.New、fmt.Errorf创建错误,Go1.13+支持unwrap:
err := fmt.Errorf("failed to parse: %w", parseErr)
errors.Is(err, parseErr) // true
errors.As(err, &target) // 类型断言
Go并发核心是CSP模型(通信顺序进程),通过goroutine与channel实现轻量级并发:
示例:生产者-消费者模型:
func producer(ch chan<- int, n int) {
for i := 0; i < n; i++ {
ch <- i
}
close(ch)
}
func consumer(ch <-chan int) {
for v := range ch {
fmt.Println("consume:", v)
}
}
ch := make(chan int, 2)
go producer(ch, 5)
go consumer(ch)
time.Sleep(time.Second)
注意:channel必须确保有接收者,否则阻塞;无缓冲channel是同步的;close仅用于发送端通知结束。
sync.WaitGroup用于等待一组goroutine结束:
典型用法:
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
fmt.Println("goroutine", id)
}(i)
}
wg.Wait()
fmt.Println("all done")
⚠️关键点:必须在启动goroutine前Add,或确保Add在Done前执行,否则可能提前退出。
sync.Mutex保护共享资源,避免数据竞争:
var (
mu sync.Mutex
count int
)
func increment() {
mu.Lock()
defer mu.Unlock()
count++
}
sync.RWMutex支持多读单写:
适用场景:读多写少(如缓存系统)
type Cache struct {
mu sync.RWMutex
data map[string]string
}
func (c *Cache) Get(k string) string {
c.mu.RLock()
defer c.mu.RUnlock()
return c.data[k]
}
func (c *Cache) Set(k, v string) {
c.mu.Lock()
defer c.mu.Unlock()
c.data[k] = v
}
sync.Once确保函数仅执行一次,常用于单例初始化:
var (
instance *Singleton
once sync.Once
)
func GetInstance() *Singleton {
once.Do(func() {
instance = &Singleton{}
})
return instance
}
底层通过atomic + mutex实现,保证线程安全与性能平衡。
context用于跨goroutine传递截止时间、取消信号、请求范围值:
示例:HTTP请求超时控制:
func fetch(ctx context.Context, url string) ([]byte, error) {
req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
resp, err := http.DefaultClient.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
return io.ReadAll(resp.Body)
}
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
data, err := fetch(ctx, "https://example.com")
if err != nil {
if errors.Is(err, context.DeadlineExceeded) {
fmt.Println("timeout")
}
}
最佳实践:避免在context中传递敏感信息;never store context in struct;函数链中逐层传递。
Go采用TPT(Three-Color Precise Tracing)并发垃圾回收器,具有低延迟特性(STW时间通常<10ms)。
内存分配流程:
逃逸分析(Escape Analysis)决定变量分配在栈还是堆:
示例逃逸:
func escape() *int {
x := 10
return &x // 逃逸到堆
}
func noEscape() int {
x := 10
return x // 保留栈上
}
验证逃逸:使用go build -gcflags="-m"查看分析结果。
常见优化方向:
sync.Pool示例(对象复用):
var bufferPool = sync.Pool{
New: func() interface{} {
return make([]byte, 1024)
},
}
func process() {
buf := bufferPool.Get().([]byte)
defer bufferPool.Put(buf)
// 使用buf...
}
⚠️注意:sync.Pool对象可能被GC回收,仅用于临时缓存;不适用于需要持久状态的场景。
使用testing包进行基准测试:
func BenchmarkConcat(b *testing.B) {
for i := 0; i < b.N; i++ {
s := ""
for j := 0; j < 100; j++ {
s += "a"
}
}
}
运行:go test -bench=. -benchmem
性能分析工具:
示例:启用CPU分析:
func TestMain(m *testing.M) {
f, _ := os.Create("cpu.prof")
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
os.Exit(m.Run())
}
可视化:go tool pprof -http=:8080 cpu.prof
1. 字符串拼接:避免+,改用strings.Builder或fmt.Sprintf(大量拼接时)
2. map预分配:make(map[string]int, 1000)避免扩容开销
3. 避免不必要的copy:切片传递用指针或直接传slice(本身是struct)
4. 使用atomic而非锁:简单计数器用atomic.AddInt64
5. 内联优化:小函数用//go:noinline禁止内联,测试性能差异
6. 避免反射:反射比直接调用慢5-10倍,仅用于通用框架
Go modules(Go1.11+)是官方依赖管理方案:
go mod init example.com/mymodgo get github.com/gin-gonic/gin@v1.7.0go mod tidy(自动清理未使用依赖)go.mod关键字段:
module example.com/mymod
go 1.21
require (
github.com/gin-gonic/gin v1.7.0
github.com/stretchr/testify v1.7.0
)
使用replace可本地调试:
replace github.com/myorg/mylib => ./local/mylib
Go内置测试框架,支持单元测试、基准测试、子测试:
func TestAdd(t *testing.T) {
tests := []struct {
name string
a, b int
want int
}{
{"positive", 2, 3, 5},
{"negative", -1, -2, -3},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := Add(tt.a, tt.b)
if got != tt.want {
t.Errorf("Add(%d,%d) = %d; want %d", tt.a, tt.b, got, tt.want)
}
})
}
}
子测试支持并行执行:
func TestParallel(t *testing.T) {
t.Run("A", func(t *testing.T) {
t.Parallel()
// ...
})
t.Run("B", func(t *testing.T) {
t.Parallel()
// ...
})
}
mock测试:使用接口+假实现,或第三方库(如testify/mock)
标准库log包功能有限,推荐使用结构化日志:
示例(zerolog):
logger := zerolog.New(os.Stdout).With().Timestamp().Logger()
logger.Info().Str("user", "alice").Int("id", 123).Msg("user logged in")
监控指标:集成Prometheus,暴露/metrics端点
http.Handle("/metrics", promhttp.Handler())
http.ListenAndServe(":8080", nil)
Go Web框架生态丰富,核心选择如下:
| 框架 | 特点 | 适用场景 |
|---|---|---|
| Gin | 轻量、中间件丰富、性能高 | 中小型API服务 |
| Echo | 极致性能、零分配、内置路由 | 高性能网关 |
| Fiber | 类似Express、协程安全、WebAssembly支持 | 全栈开发 |
| Echo | 极致性能、零分配、内置路由 | 高性能网关 |
注意:Fiber底层基于fasthttp,非net/http,兼容性需评估。
Go主流数据库驱动:
GORM示例:
type User struct {
ID uint
Name string
CreatedAt time.Time
}
db.Create(&User{Name: "Alice"})
db.Where("name = ?", "Alice").First(&user)
⚠️注意:ORM可能引发N+1查询问题;生产环境建议手写SQL或使用query builder。