golang-基础-Go语言条件判断

Go语言的条件判断主要包括 if 语句和 switch 语句。它们是控制程序流程的核心工具，适用于从简单到复杂的条件逻辑处理。以下是详细的语法、适用场景和代码示例。

1. if 语句

1.1 基础语法

Go语言的 if 语句语法简洁，具有以下特点：

• 条件表达式无需括号（推荐省略）。
• 大括号 {} 必须存在，即使只有一行代码。
• 支持初始化语句，用于在条件判断前定义局部变量。

语法结构：

if 初始化语句; 条件表达式 {
    // 条件为真时执行
} else if 另一个条件表达式 {
    // 另一个条件为真时执行
} else {
    // 所有条件为假时执行
}

1.2 适用场景

• 单条件判断：例如判断数值范围、布尔值。
• 多条件分支：通过 else if 实现多个条件的嵌套。
• 局部变量作用域优化：在 if 语句中定义临时变量，仅在当前块中有效。

1.3 代码示例

示例 1：基础条件判断

package main
import "fmt"

func main() {
    age := 18
    if age >= 18 {
        fmt.Println("你已成年")
    } else {
        fmt.Println("你未成年")
    }
}

示例 2：带初始化语句的 if

package main
import "fmt"

func main() {
    if score := 95; score > 90 {
        fmt.Println("成绩优秀")
    } else if score > 80 {
        fmt.Println("成绩良好")
    } else {
        fmt.Println("成绩需要改进")
    }
}

示例 3：判断 Map 中的 Key 是否存在

package main
import "fmt"

func main() {
    intMap := map[int]string{
        1: "一",
        2: "二",
        3: "三",
    }

    key := 2
    if value, ok := intMap[key]; ok {
        fmt.Printf("Key %d 的值是 %s\n", key, value) //Key 2 的值是 二
    } else {
        fmt.Printf("Key %d 不存在\n", key)
    }
}

1.4 注意事项

• 类型安全：条件表达式必须是布尔值，避免隐式转换（例如 C 语言中用 0 或非 0 表示真假）。
• 错误处理：显式检查错误（如 if err != nil），这是 Go 的常见实践。
• 避免误写赋值：Go 编译器会捕获 if x = 5 这类错误，强制使用 == 判断相等。

2. switch 语句

2.1 基础语法

Go 的 switch 语句比其他语言更灵活，支持多种形式：

1. 基于变量匹配：

   switch 变量 {
   case 值1:
       // 匹配值1时执行
   case 值2, 值3:
       // 匹配值2或值3时执行
   default:
       // 默认情况
   }
   

2. 无变量匹配（基于表达式）：

   switch {
   case 表达式1:
       // 表达式1为真时执行
   case 表达式2:
       // 表达式2为真时执行
   default:
       // 默认情况
   }
   

2.2 适用场景

• 多条件分支：当需要根据变量值或表达式结果选择多个分支时。
• 替代多个 if-else：提高代码可读性和可维护性。
• 类型匹配：结合 type switch 判断接口变量的类型（后续扩展）。

2.3 代码示例

示例 1：基本 switch 用法

package main
import "fmt"

func main() {
    grade := "B"
    switch grade {
    case "A":
        fmt.Println("优秀")
    case "B", "C":
        fmt.Println("良好") //良好
    case "D":
        fmt.Println("及格")
    default:
        fmt.Println("不及格")
    }
}

示例 2：无变量匹配的 switch

package main
import "fmt"

func main() {
    day := 3
    switch {
    case day <= 5:
        fmt.Println("工作日")
    case day == 6 || day == 7:
        fmt.Println("周末")
    default:
        fmt.Println("输入错误")
    }
}

示例 3：使用 fallthrough 关键字

package main
import "fmt"

func main() {
    num := 2
    switch num {
    case 1:
        fmt.Println("数字1")
        fallthrough // 继续执行下一个 case
    case 2:
        fmt.Println("数字2")
        fallthrough // 继续执行下一个 case
    case 3:
        fmt.Println("数字3")
    default:
        fmt.Println("其他数字")
    }
}

2.4 注意事项

• 自动 break：Go 的 switch 在每个 case 结束后自动 break，不会像 C/C++ 那样“穿透”到下一个 case。
• 显式 fallthrough：如果需要执行下一个 case，必须使用 fallthrough 关键字。
• 性能优化：switch 语句在底层可能被编译器优化为跳转表，适合处理大量分支。

3. 适用场景对比

4. 实际应用案例

案例 1：成绩等级判断

package main
import "fmt"

func main() {
    var score int
    fmt.Print("请输入成绩：")
    fmt.Scan(&score)

    if score >= 90 {
        fmt.Println("等级：A")
    } else if score >= 80 {
        fmt.Println("等级：B")
    } else if score >= 70 {
        fmt.Println("等级：C")
    } else if score >= 60 {
        fmt.Println("等级：D")
    } else {
        fmt.Println("等级：F")
    }
}

案例 2：星期几判断

package main
import "fmt"

func main() {
    var day int
    fmt.Print("请输入数字（1-7）代表星期几：")
    fmt.Scan(&day)

    switch day {
    case 1:
        fmt.Println("星期一")
    case 2:
        fmt.Println("星期二")
    case 3:
        fmt.Println("星期三")
    case 4:
        fmt.Println("星期四")
    case 5:
        fmt.Println("星期五")
    case 6:
        fmt.Println("星期六")
    case 7:
        fmt.Println("星期日")
    default:
        fmt.Println("输入错误，请输入1到7之间的数字")
    }
}

5. 总结

• if 语句：适合处理简单的条件分支，支持初始化语句和多级嵌套。
• switch 语句：适合多条件分支场景，语法简洁，支持 fallthrough 控制流。
• 最佳实践：
  • 优先使用 switch 替代多个 if-else，提高可读性。
  • 在 if 语句中定义临时变量，限制作用域。
  • 显式处理错误（如 if err != nil），确保程序健壮性。