Go语言基础：循环与条件

1. for循环基础

Go语言仅保留`for`循环结构，支持多种变体形式，包括传统C风格、范围遍历等：

示例：for循环变体

package main

import "fmt"

func main() {
    // 传统C风格循环
    for i := 0; i < 5; i++ {
        fmt.Printf("i=%d ", i)
    }
    fmt.Println()

    // 省略初始化和递增（类似while循环）
    j := 0
    for j < 3 {
        fmt.Printf("j=%d ", j)
        j++
    }
    fmt.Println()

    // 无限循环（需配合break退出）
    k := 0
    for {
        if k > 2 {
            break
        }
        fmt.Printf("k=%d ", k)
        k++
    }
    fmt.Println()

    // 范围遍历（数组/切片）
    nums := []int{10, 20, 30}
    for idx, val := range nums {
        fmt.Printf("索引%d: 值%d ", idx, val)
    }
}

关键点说明：

无`while`和`do-while`关键字，通过`for`实现
范围遍历（`range`）返回索引和值，可通过`_`忽略不需要的部分
无限循环需通过`break`或`return`终止

2. if条件语句

Go的`if`语句支持初始化子句（可声明局部变量），条件无需括号包裹：

示例：if条件使用

package main

import "fmt"

func checkScore(score int) {
    // 初始化子句声明局部变量
    if grade := score / 10; grade >= 9 {
        fmt.Println("优秀")
    } else if grade >= 6 {
        fmt.Println("合格")
    } else {
        fmt.Println("不合格")
    }
}

func main() {
    checkScore(85)  // 合格
    checkScore(92)  // 优秀
    checkScore(58)  // 不合格
}

注意事项：

初始化子句声明的变量仅在`if`作用域内有效
支持嵌套`if`语句，但建议保持逻辑简洁

3. switch分支语句

Go的`switch`语句功能强大，支持类型断言、无表达式形式（类似多条件`if-else`）和自动break（需`fallthrough`显式穿透）：

示例：switch高级用法

package main

import (
    "fmt"
    "time"
)

func describe(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("整数%d\n", v)
    case string:
        fmt.Printf("字符串'%s'\n", v)
    case time.Time:
        fmt.Printf("时间%s\n", v.Format("2006-01-02 15:04:05"))
    default:
        fmt.Println("未知类型")
    }
}

func main() {
    // 传统值匹配
    day := time.Now().Weekday()
    switch day {
    case time.Saturday, time.Sunday:
        fmt.Println("周末")
    default:
        fmt.Println("工作日")
    }

    // 无表达式形式
    score := 88
    switch {
    case score >= 90:
        fmt.Println("A等级")
    case score >= 80:
        fmt.Println("B等级")
    default:
        fmt.Println("C等级")
    }

    // 类型断言
    describe(42)
    describe("hello")
    describe(time.Now())
}

特性总结：

无表达式`switch`等价于`if-else if`链
支持多个值匹配（用逗号分隔）
`fallthrough`关键字可穿透到下一个case（需谨慎使用）

4. 循环控制语句

Go提供`break`、`continue`和`goto`控制循环流程，`goto`通常用于跳出多层循环：

示例：循环控制

package main

import "fmt"

func findPair(nums []int, target int) {
    for i, a := range nums {
        for j, b := range nums {
            if i == j {
                continue  // 跳过相同索引
            }
            if a + b == target {
                fmt.Printf("找到配对：索引%d和%d\n", i, j)
                goto end  // 跳转到标签end
            }
        }
    }
    end:
    fmt.Println("搜索结束")
}

func main() {
    // break终止当前循环
    for i := 0; i < 5; i++ {
        if i == 3 {
            break
        }
        fmt.Printf("i=%d ", i)
    }
    fmt.Println()

    // continue跳过当前迭代
    for i := 0; i < 5; i++ {
        if i%2 == 0 {
            continue
        }
        fmt.Printf("奇数i=%d ", i)
    }
    fmt.Println()

    // goto跳出多层循环
    findPair([]int{1, 2, 3, 4}, 5)
}

使用建议：

`break`和`continue`默认作用于最内层循环，可通过标签作用于外层循环
`goto`应尽量少用，避免代码逻辑混乱
标签需定义在目标语句前，且仅在当前函数内有效

5. 实战：打印乘法表

通过嵌套循环实现99乘法表，综合应用`for`循环和格式化输出：

示例：99乘法表

package main

import "fmt"

func printMultiplicationTable() {
    for i := 1; i <= 9; i++ {
        for j := 1; j <= i; j++ {
            // 格式化输出：j×i=乘积（右对齐占4位）
            fmt.Printf("%d×%d=%-4d", j, i, i*j)
        }
        fmt.Println()  // 换行
    }
}

func main() {
    printMultiplicationTable()
}

输出结果：

1×1=1   
1×2=2   2×2=4   
1×3=3   2×3=6   3×3=9   
...（后续行类似）

关键点：

外层循环控制行数（i从1到9）
内层循环控制每行的列数（j从1到i）
使用`%-4d`格式化字符串实现左对齐，保证输出对齐美观