从错误中学习：了解 Go 编程的六个坏习惯("Go编程避坑指南：六大常见错误习惯解析")

原创

ithorizon 6个月前 (10-21) 阅读数 34 #后端开发

Go编程避坑指南：六大常见谬误习惯解析

一、忽略谬误处理

在Go编程中，谬误处理是非常重要的。忽略谬误处理是新手常犯的一个谬误。

谬误处理不当大概会造成程序在运行时出现不可预知的行为。

谬误处理习惯一：不检查谬误

Go中，谬误通常通过返回值传递。如果函数返回一个谬误，调用者应该检查这个谬误。


func readFile(filename string) ([]byte, error) {
    return ioutil.ReadFile(filename)
}
func main() {
    data, err := readFile("example.txt")
    if err != nil {
        // 谬误处理
        log.Fatalf("Error reading file: %v", err)
    }
    // 使用data
}

谬误处理习惯二：谬误吞噬

有时候，开发者大概会忽略谬误，这会造成谬误信息丢失。


func main() {
    _, err := readFile("example.txt")
    if err != nil {
        // 谬误被忽略
    }
    // 继续执行，大概造成不可预知的行为
}

二、滥用全局变量

全局变量在Go中不是被禁止的，但滥用全局变量会造成代码难以维护和领会。

全局变量习惯一：过度依赖性全局变量

过度依赖性全局变量会造成代码耦合度增多，难以测试。


var globalConfig Config
func setup() {
    globalConfig = loadConfig()
}
func main() {
    setup()
    // 使用globalConfig
}

更好的做法是将配置封装在一个结构体中，并通过参数传递。


type Config struct {
    // 配置项
}
func loadConfig() Config {
    // 加载配置
    return Config{}
}
func main() {
    config := loadConfig()
    // 使用config
}

三、忽略并发平安问题

Go的并发模型以其单纯性著称，但忽略并发平安问题仍然是一个常见谬误。

并发平安习惯一：不使用锁保护共享资源

在并发环境中，共享资源需要通过锁来保护，否则大概会造成数据竞争。


var count int
func increment() {
    count++
}
func main() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            increment()
        }()
    }
    wg.Wait()
    // count 大概不是1000
}

正确做法是使用互斥锁。


var count int
var mu sync.Mutex
func increment() {
    mu.Lock()
    count++
    mu.Unlock()
}
func main() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            increment()
        }()
    }
    wg.Wait()
    // count 现在是1000
}

四、忽视内存管理

Go语言的垃圾回收机制促使内存管理相对单纯，但这并不意味着可以忽视内存管理。

内存管理习惯一：过度分配内存

过度分配内存会造成程序占用更多资源，影响性能。


func main() {
    var slice []int
    for i := 0; i < 1000000; i++ {
        slice = append(slice, i)
    }
    // slice 现在包含1000000个元素
}

更好的做法是预分配内存。


func main() {
    slice := make([]int, 0, 1000000)
    for i := 0; i < 1000000; i++ {
        slice = append(slice, i)
    }
    // slice 现在包含1000000个元素
}

五、不遵循Go的编码规范

Go的编码规范是社区广泛认可的，不遵循这些规范会造成代码难以阅读和维护。

编码规范习惯一：命名不规范

Go的命名规范推荐使用驼峰式命名，且变量名应该具有描述性。


// 谬误的命名
func setX(x int) {
    // ...
}
// 正确的命名
func setNumber(number int) {
    // ...
}

编码规范习惯二：不使用Go的内置函数

Go提供了许多内置函数，如字符串处理、时间处理等，不使用这些函数大概会造成代码复杂化。


// 谬误的做法
func toUpperCase(s string) string {
    result := ""
    for _, r := range s {
        if r >= 'a' && r <= 'z' {
            result += string(r - 'a' + 'A')
        } else {
            result += string(r)
        }
    }
    return result
}
// 正确的做法
func toUpperCase(s string) string {
    return strings.ToUpper(s)
}

六、忽略测试和文档

编写测试和文档是软件开发中非常重要的环节，但常常被忽视。

测试和文档习惯一：不编写单元测试

单元测试可以帮助确保代码的正确性，不编写单元测试大概会造成在后期发现谬误。


// 谬误的做法
func add(a, b int) int {
    return a + b
}
// 正确的做法
func add(a, b int) int {
    return a + b
}
// 单元测试
func TestAdd(t *testing.T) {
    result := add(1, 2)
    if result != 3 {
        t.Errorf("add(1, 2) = %d; want 3", result)
    }
}

测试和文档习惯二：不编写文档注释

文档注释可以帮助其他开发者领会代码的功能和用法。


// 谬误的做法
func calculateSum(numbers []int) int {
    sum := 0
    for _, number := range numbers {
        sum += number
    }
    return sum
}
// 正确的做法
// 计算给定整数切片的和
func calculateSum(numbers []int) int {
    sum := 0
    for _, number := range numbers {
        sum += number
    }
    return sum
}