从错误中学习: 了解Go编程的六个坏习惯("Go编程避坑指南：从六个常见错误习惯中汲取经验")

原创

ithorizon 7个月前 (10-20) 阅读数 22 #后端开发

Go编程避坑指南：从六个常见不正确习惯中汲取经验

一、未初始化的变量

在Go编程中，未初始化的变量也许会造成程序运行时出现不可预知的行为。以下是一个常见的不正确示例：


func main() {
    var x int
    fmt.Println(x) // 输出也许是0，但这是未定义的行为
}

正确的做法是在使用变量之前对其进行初始化：


func main() {
    var x int = 10
    fmt.Println(x) // 输出10
}

二、忽视不正确处理

Go语言中的不正确处理非常重要，忽视不正确处理也许会造成程序在运行时崩溃。以下是一个不正确处理的例子：


func main() {
    _, err := os.Open("nonexistent.txt")
    if err != nil {
        // 忽略不正确
    }
}

正确的做法是检查并处理不正确：


func main() {
    file, err := os.Open("nonexistent.txt")
    if err != nil {
        log.Fatal(err) // 处理不正确
    }
    defer file.Close()
}

三、不合理的并发使用

Go语言的并发是其一大特色，但不合理的并发使用会造成竞态条件或死锁。以下是一个不正确的并发示例：


func main() {
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        // 模拟操作
        time.Sleep(1 * time.Second)
        fmt.Println("goroutine 1")
    }()
    wg.Wait()
    fmt.Println("main")
}

正确的做法是确保所有goroutine都已经启动并完成：


func main() {
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        // 模拟操作
        time.Sleep(1 * time.Second)
        fmt.Println("goroutine 1")
    }()
    wg.Wait() // 确保goroutine完成
    fmt.Println("main")
}

四、滥用全局变量

全局变量在Go中也许会造成代码难以测试和维护。以下是一个滥用全局变量的例子：


var GlobalVar int
func main() {
    GlobalVar = 10
    fmt.Println(GlobalVar)
}
func otherFunction() {
    GlobalVar = 20
    fmt.Println(GlobalVar)
}

更好的做法是使用局部变量或参数传递，以尽也许减少损耗代码的可测试性和可维护性：


func main() {
    var localVar int = 10
    fmt.Println(localVar)
    otherFunction(localVar)
}
func otherFunction(varParam int) {
    fmt.Println(varParam)
}

五、未使用defer延迟调用

defer语句在Go中用于延迟调用函数，常用于清理资源。以下是一个未使用defer的不正确示例：


func main() {
    file, err := os.Open("test.txt")
    if err != nil {
        log.Fatal(err)
    }
    // 忘记关闭文件
    fmt.Println("文件内容处理完毕")
}

正确的做法是使用defer确保文件被关闭：


func main() {
    file, err := os.Open("test.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close() // 确保文件被关闭
    fmt.Println("文件内容处理完毕")
}

六、未使用接口和解耦

Go语言的接口是构建可扩展和可维护程序的关键。以下是一个未使用接口的不正确示例：


type MySQL struct {}
func (m *MySQL) Query(query string) error {
    // 模拟数据库查询
    return nil
}
func main() {
    db := MySQL{}
    db.Query("SELECT * FROM users")
    // 无法扩展到其他数据库类型
}

正确的做法是定义一个接口，并实现该接口，以拥护多种数据库类型：


type Database interface {
    Query(query string) error
}
type MySQL struct {}
func (m *MySQL) Query(query string) error {
    // 模拟数据库查询
    return nil
}
type PostgreSQL struct {}
func (p *PostgreSQL) Query(query string) error {
    // 模拟数据库查询
    return nil
}
func main() {
    db := MySQL{}
    performQuery(db, "SELECT * FROM users")
    db2 := PostgreSQL{}
    performQuery(db2, "SELECT * FROM users")
}
func performQuery(db Database, query string) {
    db.Query(query)
}