Jackson全栈知识体系

Appearance

<

Golang 控制流程 ​

条件语句 ​

if 语句 ​

go
package main

import "fmt"

func ifDemo() {
    score := 85

    // 基本 if 语句
    if score >= 60 {
        fmt.Println("及格")
    }

    // if-else 语句
    if score >= 90 {
        fmt.Println("优秀")
    } else if score >= 80 {
        fmt.Println("良好")
    } else if score >= 60 {
        fmt.Println("及格")
    } else {
        fmt.Println("不及格")
    }

    // if 语句的初始化
    if num := 10; num%2 == 0 {
        fmt.Println(num, "是偶数")
    } else {
        fmt.Println(num, "是奇数")
    }
    // 注意：num 只在 if 作用域内有效
}

switch 语句 ​

go
func switchDemo() {
    day := 3

    // 基本 switch
    switch day {
    case 1:
        fmt.Println("星期一")
    case 2:
        fmt.Println("星期二")
    case 3:
        fmt.Println("星期三")
    case 4:
        fmt.Println("星期四")
    case 5:
        fmt.Println("星期五")
    case 6, 7:
        fmt.Println("周末")
    default:
        fmt.Println("无效的日期")
    }

    // switch 带初始化语句
    switch hour := 14; {
    case hour < 12:
        fmt.Println("上午")
    case hour < 18:
        fmt.Println("下午")
    default:
        fmt.Println("晚上")
    }

    // 无条件 switch（相当于 if-else）
    score := 85
    switch {
    case score >= 90:
        fmt.Println("A")
    case score >= 80:
        fmt.Println("B")
    case score >= 70:
        fmt.Println("C")
    case score >= 60:
        fmt.Println("D")
    default:
        fmt.Println("F")
    }

    // fallthrough 关键字
    num := 2
    switch num {
    case 1:
        fmt.Println("一")
        fallthrough
    case 2:
        fmt.Println("二")
        fallthrough
    case 3:
        fmt.Println("三")
    default:
        fmt.Println("其他")
    }
    // 输出: 二 三
}

类型 switch ​

go
func typeSwitchDemo() {
    var x interface{} = "hello"

    switch v := x.(type) {
    case nil:
        fmt.Println("x 是 nil")
    case int:
        fmt.Printf("x 是 int 类型，值为 %d\n", v)
    case string:
        fmt.Printf("x 是 string 类型，值为 %s\n", v)
    case bool:
        fmt.Printf("x 是 bool 类型，值为 %t\n", v)
    default:
        fmt.Printf("未知类型: %T\n", v)
    }
}

循环语句 ​

for 循环 ​

Go 语言只有 for 循环，没有 while 和 do-while。

go
func forDemo() {
    // 标准 for 循环
    fmt.Println("标准 for 循环:")
    for i := 0; i < 5; i++ {
        fmt.Printf("%d ", i)
    }
    fmt.Println()

    // 类似 while 循环
    fmt.Println("\n类似 while 循环:")
    j := 0
    for j < 5 {
        fmt.Printf("%d ", j)
        j++
    }
    fmt.Println()

    // 无限循环
    fmt.Println("\n无限循环（带 break）:")
    k := 0
    for {
        if k >= 5 {
            break
        }
        fmt.Printf("%d ", k)
        k++
    }
    fmt.Println()

    // 省略初始化和后置语句
    fmt.Println("\n省略部分语句:")
    m := 0
    for ; m < 5; {
        fmt.Printf("%d ", m)
        m++
    }
    fmt.Println()
}

for range 循环 ​

用于遍历数组、切片、字符串、map 和 channel。

go
func forRangeDemo() {
    // 遍历切片
    fmt.Println("遍历切片:")
    numbers := []int{10, 20, 30, 40, 50}
    for index, value := range numbers {
        fmt.Printf("索引: %d, 值: %d\n", index, value)
    }

    // 只要索引
    fmt.Println("\n只要索引:")
    for index := range numbers {
        fmt.Printf("%d ", index)
    }
    fmt.Println()

    // 只要值（使用 _ 忽略索引）
    fmt.Println("\n只要值:")
    for _, value := range numbers {
        fmt.Printf("%d ", value)
    }
    fmt.Println()

    // 遍历字符串
    fmt.Println("\n遍历字符串:")
    str := "Hello, 世界"
    for index, char := range str {
        fmt.Printf("索引: %d, 字符: %c, Unicode: %U\n", index, char, char)
    }

    // 遍历 map
    fmt.Println("\n遍历 map:")
    person := map[string]string{
        "name": "Jackson",
        "city": "Beijing",
        "job":  "Engineer",
    }
    for key, value := range person {
        fmt.Printf("%s: %s\n", key, value)
    }
}

跳转语句 ​

break 语句 ​

go
func breakDemo() {
    // break 跳出循环
    fmt.Println("break 示例:")
    for i := 0; i < 10; i++ {
        if i == 5 {
            break
        }
        fmt.Printf("%d ", i)
    }
    fmt.Println()

    // break 跳出多层循环（使用标签）
    fmt.Println("\nbreak 标签示例:")
OuterLoop:
    for i := 0; i < 3; i++ {
        for j := 0; j < 3; j++ {
            if i == 1 && j == 1 {
                break OuterLoop
            }
            fmt.Printf("(%d,%d) ", i, j)
        }
    }
    fmt.Println()
}

continue 语句 ​

go
func continueDemo() {
    // continue 跳过当前迭代
    fmt.Println("continue 示例:")
    for i := 0; i < 10; i++ {
        if i%2 == 0 {
            continue
        }
        fmt.Printf("%d ", i)
    }
    fmt.Println()

    // continue 标签
    fmt.Println("\ncontinue 标签示例:")
OuterLoop:
    for i := 0; i < 3; i++ {
        for j := 0; j < 3; j++ {
            if j == 1 {
                continue OuterLoop
            }
            fmt.Printf("(%d,%d) ", i, j)
        }
    }
    fmt.Println()
}

goto 语句 ​

go
func gotoDemo() {
    fmt.Println("goto 示例:")
    i := 0

Loop:
    if i < 5 {
        fmt.Printf("%d ", i)
        i++
        goto Loop
    }
    fmt.Println("\n循环结束")

    // goto 跳过代码块
    goto Skip
    fmt.Println("这行不会执行")

Skip:
    fmt.Println("跳过了上面的代码")
}

延迟执行（defer） ​

defer 语句会延迟函数的执行直到外层函数返回。

go
func deferDemo() {
    fmt.Println("开始")

    defer fmt.Println("延迟执行 1")
    defer fmt.Println("延迟执行 2")
    defer fmt.Println("延迟执行 3")

    fmt.Println("结束")

    // 输出顺序:
    // 开始
    // 结束
    // 延迟执行 3
    // 延迟执行 2
    // 延迟执行 1
}

func deferWithLoop() {
    fmt.Println("\ndefer 在循环中:")
    for i := 0; i < 5; i++ {
        defer fmt.Printf("%d ", i)
    }
    // 输出: 4 3 2 1 0
}

实战示例 ​

示例1：查找素数 ​

go
func isPrime(n int) bool {
    if n <= 1 {
        return false
    }
    for i := 2; i*i <= n; i++ {
        if n%i == 0 {
            return false
        }
    }
    return true
}

func findPrimes(max int) {
    fmt.Printf("1到%d之间的素数:\n", max)
    count := 0
    for i := 2; i <= max; i++ {
        if isPrime(i) {
            fmt.Printf("%d ", i)
            count++
            if count%10 == 0 {
                fmt.Println()
            }
        }
    }
    fmt.Printf("\n共找到 %d 个素数\n", count)
}

示例2：九九乘法表 ​

go
func multiplicationTable() {
    fmt.Println("九九乘法表:")
    for i := 1; i <= 9; i++ {
        for j := 1; j <= i; j++ {
            fmt.Printf("%d×%d=%2d  ", j, i, i*j)
        }
        fmt.Println()
    }
}

示例3：猜数字游戏 ​

go
func guessNumber() {
    target := 42
    attempts := 0
    maxAttempts := 5

    fmt.Println("猜数字游戏（1-100）")

    guesses := []int{30, 50, 40, 42} // 模拟用户输入

    for _, guess := range guesses {
        attempts++
        fmt.Printf("\n第 %d 次猜测: %d\n", attempts, guess)

        switch {
        case guess < target:
            fmt.Println("太小了！")
        case guess > target:
            fmt.Println("太大了！")
        default:
            fmt.Printf("恭喜！你猜对了！用了 %d 次\n", attempts)
            return
        }

        if attempts >= maxAttempts {
            fmt.Printf("游戏结束！正确答案是 %d\n", target)
            return
        }
    }
}

完整示例 ​

go
package main

import "fmt"

func main() {
    // 成绩等级判定
    scores := []int{95, 87, 76, 65, 54}

    fmt.Println("=== 成绩等级判定 ===")
    for i, score := range scores {
        fmt.Printf("学生%d - 分数: %d, ", i+1, score)

        switch {
        case score >= 90:
            fmt.Println("等级: A (优秀)")
        case score >= 80:
            fmt.Println("等级: B (良好)")
        case score >= 70:
            fmt.Println("等级: C (中等)")
        case score >= 60:
            fmt.Println("等级: D (及格)")
        default:
            fmt.Println("等级: F (不及格)")
        }
    }

    // 查找素数
    fmt.Println("\n=== 素数查找 ===")
    findPrimes(50)

    // 九九乘法表
    fmt.Println("\n=== 九九乘法表 ===")
    multiplicationTable()
}

小结 ​

  • if/else：条件判断，支持初始化语句
  • switch：多分支选择，支持多个条件、类型判断
  • for：唯一的循环语句，功能强大
  • for range：遍历数组、切片、map、字符串
  • break：跳出循环
  • continue：跳过当前迭代
  • goto：无条件跳转（慎用）
  • defer：延迟执行，常用于资源清理