← 运算符 | for 循环 →

if 条件 - Go 流程控制

if 语句是 Go 最基本的条件控制语句。Go 的 if 语句简洁灵活，支持初始化语句，是错误处理的核心工具。

📌 核心概念

❓

条件判断

布尔表达式

if condition
🔀

else 分支

条件不满足

else
📝

初始化语句

if 前初始化

if x := f();
✅

错误处理

if err != nil

错误检查

基础用法

📝 if 语句基本形式

package main

import "fmt"

func main() {
    // 基本 if
    x := 10
    if x > 5 {
        fmt.Println("x is greater than 5")
    }
    
    // if-else
    if x%2 == 0 {
        fmt.Println("x is even")
    } else {
        fmt.Println("x is odd")
    }
    
    // if-else if-else
    if x < 5 {
        fmt.Println("x is small")
    } else if x < 15 {
        fmt.Println("x is medium")
    } else {
        fmt.Println("x is large")
    }
}

💡 if 语句要点

  • 括号可选: 条件不需要括号
  • 花括号必需: 即使只有一行代码
  • 布尔表达式: 条件必须是 bool 类型
  • 作用域: 初始化语句的变量只在 if 块内有效

初始化语句

📝 if 前初始化

package main

import "fmt"

func main() {
    // 带初始化语句的 if
    if x := getValue(); x > 5 {
        fmt.Println("x is greater than 5")
    }
    // x 在这里不可用
    
    // 常见模式：函数调用 + 错误检查
    if result, err := doSomething(); err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
    
    // 多个初始化
    if a := 1; a > 0 {
        if b := 2; b > 0 {
            fmt.Println(a + b)
        }
    }
}

func getValue() int {
    return 10
}

func doSomething() (int, error) {
    return 42, nil
}

错误处理

📝 if 错误检查模式

package main

import (
    "fmt"
    "os"
)

func main() {
    // 标准错误检查模式
    file, err := os.Open("file.txt")
    if err != nil {
        fmt.Println("Failed to open file:", err)
        return
    }
    defer file.Close()
    
    // 多个错误检查
    data, err := os.ReadFile("config.json")
    if err != nil {
        if os.IsNotExist(err) {
            fmt.Println("File does not exist")
        } else if os.IsPermission(err) {
            fmt.Println("Permission denied")
        } else {
            fmt.Println("Error:", err)
        }
        return
    }
    
    fmt.Println(string(data))
}

// 早期返回模式
func processFile(path string) error {
    file, err := os.Open(path)
    if err != nil {
        return err // 早期返回
    }
    defer file.Close()
    
    // 正常处理逻辑...
    return nil
}

实用模式

1. 守卫子句

📝 提前返回模式

// ❌ 不推荐：嵌套过深
func process(data []int) error {
    if data != nil {
        if len(data) > 0 {
            if data[0] > 0 {
                // 处理逻辑
            }
        }
    }
    return nil
}

// ✅ 推荐：守卫子句
func process(data []int) error {
    if data == nil {
        return fmt.Errorf("data is nil")
    }
    if len(data) == 0 {
        return fmt.Errorf("data is empty")
    }
    if data[0] <= 0 {
        return fmt.Errorf("first element must be positive")
    }
    
    // 正常处理逻辑
    return nil
}

2. 类型断言检查

📝 类型检查

func processValue(v interface{}) {
    // 类型断言检查
    if num, ok := v.(int); ok {
        fmt.Println("Integer:", num)
    } else if str, ok := v.(string); ok {
        fmt.Println("String:", str)
    } else {
        fmt.Println("Unknown type")
    }
}

最佳实践

✅ if 语句使用建议

  • 早期返回: 使用守卫子句减少嵌套
  • 错误检查: 始终检查 error != nil
  • 初始化语句: 利用 if 前初始化限制作用域
  • 避免深层嵌套: 超过 3 层考虑重构

📖 延伸阅读