Go语言控制流与错误处理：条件语句、循环与错误处理技巧

天天向上

发布： 2025-02-08 23:49:06

原创

750 人浏览过

在这一部分，我们将详细探讨Go语言的控制流和错误处理机制。控制流包括条件语句、循环语句和多种分支语句，它们是程序执行的基础，决定了代码的执行路径。而错误处理是Go语言的核心特性之一，Go语言通过一种独特的错误处理方式来保证代码的鲁棒性。此外，Go语言的延迟机制（defer）和函数返回错误的模式，也是Go程序开发中不可或缺的部分。

3.1 条件语句与循环

Go语言中的条件语句和循环与其他常见的编程语言相似，但Go有一些独特的简洁性和特性。

3.1.1 if语句

if语句用于在条件为true时执行某个代码块。Go语言中的if语句可以在条件部分声明变量，这使得语法更加简洁。

package main

import "fmt"

func main() {
    age := 18
    if age >= 18 {
        fmt.Println("You are an adult.")
    } else {
        fmt.Println("You are a minor.")
    }
}

带初始化语句的if：

在Go语言中，if语句不仅可以检查条件，还可以在判断条件前初始化变量。这种方式可以避免不必要的变量声明，减少代码冗余。

package main

import "fmt"

func main() {
    if age := 18; age >= 18 {
        fmt.Println("You are an adult.")
    } else {
        fmt.Println("You are a minor.")
    }
    // 不能在if语句外部访问age
}

3.1.2 for语句

Go语言中的for是唯一的循环语句，既可以像传统的for语句那样使用，也可以模拟while循环，甚至还可以使用range来迭代数组、切片和映射。

基本的for循环：

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

for作为while使用：

i := 0
for i < 5 {
    fmt.Println(i)
    i++
}

使用range迭代切片：

range用于遍历切片、数组、字符串、映射等数据结构。

nums := []int{1, 2, 3, 4}
for index, value := range nums {
    fmt.Println(index, value)
}

3.1.3 switch语句

switch语句用于在多个可能的值之间选择一个执行。Go语言的switch语句不需要break语句来避免贯穿行为，且每个case语句之间是独立的。

基本的switch语句：

day := 3
switch day {
case 1:
    fmt.Println("Monday")
case 2:
    fmt.Println("Tuesday")
case 3:
    fmt.Println("Wednesday")
default:
    fmt.Println("Other day")
}

switch与fallthrough：

如果你希望在某个case语句执行后继续执行下一个case，可以使用fallthrough关键字。

switch day {
case 1:
    fmt.Println("Monday")
    fallthrough
case 2:
    fmt.Println("Tuesday")
}

3.2 错误处理（error 类型，panic 和 recover）

Go语言的错误处理机制是其独特之处，Go不使用异常机制（try-catch），而是通过返回error类型来处理错误。panic和recover则是用于处理程序中的严重错误或非预期情况。

3.2.1 error 类型

Go中的error类型是一个接口类型，它只有一个Error()方法，用于返回错误的描述信息。

定义一个自定义的错误类型：

package main

import "fmt"

type MyError struct {
    Code    int
    Message string
}

func (e *MyError) Error() string {
    return fmt.Sprintf("Error %d: %s", e.Code, e.Message)
}

func someFunction() error {
    return &MyError{Code: 404, Message: "Not Found"}
}

func main() {
    err := someFunction()
    if err != nil {
        fmt.Println("Error occurred:", err)
    }
}

3.2.2 panic 和 recover

panic用于触发程序的异常，通常用于非可恢复的错误，导致程序崩溃。而recover用于从panic中恢复程序的执行，通常在defer中使用。

使用panic：

package main

import "fmt"

func riskyFunction() {
    panic("Something went wrong!")
}

func main() {
    riskyFunction()
    fmt.Println("This will never be reached.")
}

使用recover恢复：

recover可以在defer语句中被调用，从panic中恢复程序的执行。只有在defer函数内调用recover，才能捕获到panic。

package main

import "fmt"

func recoverFromPanic() {
    if r := recover(); r != nil {
        fmt.Println("Recovered from panic:", r)
    }
}

func riskyFunction() {
    defer recoverFromPanic()  // 捕获panic
    panic("Something went wrong!")
}

func main() {
    riskyFunction()
    fmt.Println("Program continues.")
}

在这个例子中，recover捕获到了panic，使得程序能够恢复并继续执行。

3.3 延迟（defer）

defer语句用于在函数执行结束时执行某个操作，它常常用于资源清理，如文件关闭、解锁互斥锁等。defer的调用是先进后出（LIFO）的顺序，即最后一个被defer的函数会最先执行。

3.3.1 `defer`的基本使用

package main

import "fmt"

func first() {
    fmt.Println("First function executed")
}

func second() {
    fmt.Println("Second function executed")
}

func main() {
    defer second()  // 第二个被调用
    defer first()   // 第一个被调用
    fmt.Println("Main function executed")
}

输出结果：

Main function executed
First function executed
Second function executed

3.3.2 `defer`的常见用途

defer通常用于资源清理，如文件操作、数据库连接、互斥锁解锁等。

package main

import "fmt"
import "os"

func main() {
    file, err := os.Open("somefile.txt")
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close()  // 在main函数结束时自动关闭文件

    // 进行文件读取操作...
}

3.4 函数返回错误模式

Go语言中的函数通常通过返回一个error类型来报告错误。这种模式使得函数调用者必须显式地检查错误，从而保证程序的健壮性。

3.4.1 函数返回错误：

package main

import "fmt"

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("cannot divide by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
}