for循环

1. 标准的三段式 `for` 循环

C++ 语言:

for (int i = 0; i < 10; ++i) { // C++需要括号
    std::cout << i << std::endl;
}

Go 语言:

// 注意：没有圆括号 ()，但花括号 {} 是必须的
for i := 0; i < 10; i++ {
    fmt.Println(i)
}
// 变量 i 的作用域仅限于这个 for 循环内部

关键不同点:

无圆括号 (): Go的for语句后面不需要用()把三个部分括起来，这让语法更简洁。
强制花括号 {}: 即使循环体只有一行，Go也强制要求使用{}。这避免了C++中因代码缩进而产生的经典bug（例如，在if或for下意外地只执行了多行中的第一行），提高了代码的健壮性和可读性。
变量作用域: Go的初始化语句 i := 0 声明的变量i，其作用域被严格限制在for循环内部，这一点和现代C++的做法是一致的。

2. 模拟 `while` 循环

在Go中，如果你想实现while循环的功能，只需要省略初始化语句和后置语句，只保留条件表达式即可。

C++ 语言:

int sum = 1;
while (sum < 1000) {
    sum += sum;
}
std::cout << sum << std::endl;

Go 语言 (while 形式):

sum := 1
// 只有条件表达式，这就是Go的 "while"
for sum < 1000 {
    sum += sum
}
fmt.Println(sum)

结论: Go的 for condition {} 就是C++的 while (condition) {}。

3. 模拟无限循环 (以及 `do-while`)

如果连条件表达式也省略掉，那么你就得到了一个无限循环。

如何模拟 do-while？ Go没有do-while的直接语法，但可以通过for的无限循环形式轻松模拟，保证循环体至少执行一次。

C++ (do-while):

do {
    std::cout << "This will run at least once." << std::endl;
} while (shouldContinue());

Go (模拟 do-while):

// 循环体先执行，然后在末尾判断退出条件
for {
    fmt.Println("This will run at least once.")
    if !shouldContinue() {
        break
    }
}

C++ 语言:

for (;;) { // 或者 while(true)
    if (someCondition()) {
        break;
    }
}

Go 语言 (无限循环形式):

for { // 省略所有部分，即为无限循环
    // 必须在循环体内部通过 break 或 return 来退出
    if someCondition() {
        break
    }
}

4. 范围遍历循环 (`for...range`)

Go的for循环还有一个非常强大的形式，用于遍历数组、切片、字符串、map、通道等，它等同于C++11引入的范围for循环。

C++ 语言:

std::vector<int> numbers = {2, 3, 5, 7};
// 范围for循环只返回元素值
for (const auto& value : numbers) {
    std::cout << "Value: " << value << std::endl;
}

Go 语言:

numbers := []int{2, 3, 5, 7}
// for...range 同时返回索引和值，非常方便
for index, value := range numbers {
    fmt.Printf("Index: %d, Value: %d\n", index, value)
}

Go的优势: for...range可以同时获取索引和值，如果你不需要索引，可以用下划线_忽略它：for _, value := range numbers。

Go `for` 的形式	对应的 C++ 概念
`for init; cond; post {}`	`for (init; cond; post) {}` (标准 `for`)
`for cond {}`	`while (cond) {}` (`while` 循环)
`for {}`	`for (;;)` 或 `while (true)` (无限循环)
`for i, v := range coll {}`	`for (const auto& v : coll) {}` (范围 `for`)

if语句

1. 基础的 `if-else` 结构

这部分和你熟悉的C++逻辑完全一样，只是语法略有不同。

C++ 语言:

void checkSign(int num) {
    if (num > 0) {
        std::cout << "Positive" << std::endl;
    } else if (num < 0) {
        std::cout << "Negative" << std::endl;
    } else {
        std::cout << "Zero" << std::endl;
    }
}

Go 语言:

func checkSign(num int) {
    if num > 0 {
        fmt.Println("Positive")
    } else if num < 0 {
        fmt.Println("Negative")
    } else {
        fmt.Println("Zero")
    }
}

关键区别：

Go不需要用 () 包围条件。
Go必须用 {} 包围代码块，即使只有一行。这可以防止在C++中因为缩进误导而产生的bug。

2. `if` 的强大特性：带初始化短语句

if语句可以在进行条件判断之前，先执行一个简短的初始化语句（比如声明一个变量）。

语法格式: if <初始化语句>; <条件表达式> { ... }

最大的好处: 在这个初始化语句中声明的变量，其作用域被严格限制在 if-else if-else 的所有分支中，执行完后立即销毁，不会“泄漏”到外部作用域。

这极大地增强了代码的局部性和封装性。

对比示例：

场景: 我们有一个函数calculate(), 它返回一个数字和一个错误。我们想判断这个数字是否大于10。

没有初始化语句的“传统”写法:

// val 和 err 在 if 语句之前声明
val, err := calculate()

if err != nil {
    fmt.Println("Error occurred")
} else if val > 10 {
    fmt.Println("Value is greater than 10")
} else {
    fmt.Println("Value is 10 or less")
}

// 在 if 结构结束后, "val" 和 "err" 变量依然存在于这里,
// 可能会被误用, 污染了外层作用域。
fmt.Println("Finished. Last value was:", val)

使用初始化语句的“地道 Go”写法:

// val 和 err 在 if 语句内部声明
// 它们的作用域仅限于这个 if-else if-else 块
if val, err := calculate(); err != nil {
    // 这里的 val 和 err 可见
    fmt.Println("Error occurred")
} else if val > 10 {
    // 这里的 val 和 err 也可见
    fmt.Println("Value is greater than 10")
} else {
    // 这里的 val 和 err 还可见
    fmt.Println("Value is 10 or less")
}

// 编译错误！在这里 "val" 和 "err" 已经不存在了，无法访问。
// undefined: val
// fmt.Println("Finished. Last value was:", val)

与 C++ 的联系

这个特性非常有用，以至于 C++17 也引入了完全相同的机制！

C++17 示例:

if (auto [val, err] = calculate(); err != nullptr) {
    // handle error
} else if (val > 10) {
    // ...
}
// "val" 和 "err" 在这里也不可见

这说明Go的这个设计被证明是优秀的编程实践，有助于编写更健壮、更易于维护的代码。

switch语句

1. 默认不“贯穿”（Implicit `break`）

这是Go switch最核心的安全改进，它彻底解决了C/C++中一个经典的bug来源。

Go 中的显式“贯穿” - fallthrough: 如果你确实需要C++那种“贯穿”的行为，Go要求你明确地使用fallthrough关键字。这使得代码的意图变得清晰，可以防止意外的贯穿。

num := 2
switch num {
case 1:
    fmt.Println("is one")
case 2:
    fmt.Println("is two")
    fallthrough // 我明确要求继续执行下一个case
case 3:
    fmt.Println("is also somewhat three")
}
// 输出:
// is two
// is also somewhat three

Go 的安全设计: 在Go中，每个case分支在执行完毕后会自动终止（break）。这种行为通常更符合程序员的直觉。

package main
import "fmt"

func main() {
    day := 2
    switch day {
    case 1:
        fmt.Println("Monday")
    case 2:
        fmt.Println("Tuesday") // 执行完这里后，switch就结束了
    case 3:
        fmt.Println("Wednesday")
    default:
        fmt.Println("Another day")
    }
    // 正确的输出: Tuesday
}

C++ 的“贯穿”陷阱: 在C++中，switch的默认行为是“贯穿”（Fallthrough）。一旦一个case被匹配，程序会继续执行下去，直到遇到break或switch结束。程序员经常会忘记写break，导致意外的行为。

#include <iostream>

int main() {
    int day = 2;
    switch (day) {
        case 1:
            std::cout << "Monday"; // 忘记写 break
        case 2:
            std::cout << "Tuesday";
        case 3:
            std::cout << "Wednesday"; // 忘记写 break
        default:
            std::cout << "Another day";
    }
    // 意外的输出: TuesdayWednesdayAnother day
    return 0;
}

2. 更灵活的 `case` 值

这是Go switch功能强大的体现。

C++ 的限制: C++的case标签必须是编译时可以确定的整型常量（比如数字字面量、enum成员或constexpr变量）。你不能使用普通的变量或表达式。

Go 的灵活性: Go的case可以是任何可比较的类型的值，包括变量、函数返回值或表达式。

func checkAccess(role string) {
    const adminRole = "admin"
    editorRole := "editor" // 普通变量

    switch role {
    case adminRole: // 使用常量
        fmt.Println("Full access granted.")
    case editorRole: // 使用变量
        fmt.Println("Can write content.")
    case "viewer": // 使用字面量
        fmt.Println("Read-only access.")
    default:
        fmt.Println("Access denied.")
    }
}

3. 无表达式的 `switch` (替代 if-else 链)

Go的switch还有一个强大的用法：省略switch后面的条件表达式。当这么做时，它就等价于 switch true，可以用来替代一长串的if-else if-else语句，并且通常更具可读性。

switch 的等价写法 (更优雅):

score := 85
switch { // 省略了条件，相当于 switch true
case score >= 90: // 第一个为 true 的 case 会被执行
    fmt.Println("Grade: A")
case score >= 80:
    fmt.Println("Grade: B")
case score >= 70:
    fmt.Println("Grade: C")
default:
    fmt.Println("Grade: D")
}

if-else 的写法:

score := 85
if score >= 90 {
    fmt.Println("Grade: A")
} else if score >= 80 {
    fmt.Println("Grade: B")
} else if score >= 70 {
    fmt.Println("Grade: C")
} else {
    fmt.Println("Grade: D")
}

defer推迟

defer 的工作机制：一个 LIFO 栈

你可以把 defer 理解为往一个“待办事项”清单上添加任务。当一个函数即将结束时，它会从这个清单里从后往前地执行所有任务。

这个“清单”在技术上是一个栈 (Stack)。

当Go执行到一个defer语句时，它会把这个函数调用压入栈中。
当外层函数执行到 return、到达函数末尾，或者发生 panic (类似C++的异常) 时，Go会按照后进先出 (LIFO, Last-In, First-Out) 的顺序，依次执行栈中所有被推迟的函数调用。

示例1：后进先出 (LIFO) 的执行顺序

package main

import "fmt"

func main() {
    fmt.Println("函数开始")

    defer fmt.Println("第一个被推迟") // 这个最后执行
    defer fmt.Println("第二个被推迟") // 这个中间执行
    defer fmt.Println("第三个被推迟") // 这个最先执行

    fmt.Println("函数即将结束")
}

输出结果:

函数开始
函数即将结束
第三个被推迟
第二个被推迟
第一个被推迟

这个结果清晰地展示了 LIFO 的顺序。

关键规则：参数立即求值

这是 defer 的一个重要特性，也是一个常见的“陷阱”。你原文中描述得非常准确：推迟的是函数的“调用”行为，但函数的“参数”是在 defer 语句被执行时就立刻计算好并保存下来的。

示例2：参数求值时机

package main

import "fmt"

func main() {
    i := 0
    // 当执行到下面这行 defer 时，i 的值是 0。
    // 所以，fmt.Println 的参数被确定为 0，并被保存起来。
    defer fmt.Println("defer 打印:", i)

    i++ // i 的值变为 1
    fmt.Println("立即打印:", i)
}

输出结果:

立即打印: 1
defer 打印: 0

这个结果证明了 defer 语句中的 i 在被推迟时值就是 0，后续对 i 的修改不会影响到已经被推迟的那个函数调用的参数。

defer 的核心用途：保证资源被释放

这才是 defer 存在的真正意义，也是它与C++ RAII思想相通的地方。

在编程中，我们经常需要打开一些资源，比如文件、数据库连接、网络连接、或者一个互斥锁(Mutex)，并且必须保证在函数退出时，无论函数是正常返回、提前因错误返回、还是发生panic，这些资源都能够被正确地关闭或释放。

C++ 的解决方案：RAII 在C++中，你通过把资源封装在对象里，利用析构函数 (destructor) 在对象离开作用域时自动被调用的特性来保证资源的释放。比如 std::lock_guard 或 std::unique_ptr。
Go 的解决方案：defer Go没有析构函数，所以它提供了 defer 这个更轻量、更直接的工具。最佳实践是：在资源获取成功后，立刻用 defer 安排它的释放操作。

示例3：安全地关闭文件

不使用 defer 的笨拙写法 (容易出错):

func processFile(filename string) error {
    f, err := os.Open(filename)
    if err != nil {
        return err
    }

    // ...在这里做一些文件操作...
    if someCondition {
        f.Close() // 如果在这里返回，需要关闭一次
        return someError
    }

    // ...又做了一些操作...

    f.Close() // 在函数末尾正常返回，又需要关闭一次
    return nil
}

这种写法非常繁琐，而且很容易忘记在某个提前返回的分支中调用 f.Close()，从而导致资源泄漏。

使用 defer 的优雅、安全的写法:

func processFile(filename string) error {
    f, err := os.Open(filename)
    if err != nil {
        return err
    }
    // 在文件成功打开后，立刻用 defer 安排关闭操作。
    // 不管这个函数从哪个路径返回，f.Close() 都保证会被执行。
    defer f.Close()

    // ...在这里做任何文件操作...
    if someCondition {
        return someError // f.Close() 会在 return 前被调用
    }

    // ...又做了一些操作...

    return nil // f.Close() 会在 return 前被调用
}

这种写法干净、简洁，且绝对不会忘记关闭文件。defer f.Close() 完美地解决了资源管理的问题。

Golang - 流程控制语句

beautifulremi

for循环

1. 标准的三段式 `for` 循环

2. 模拟 `while` 循环

3. 模拟无限循环 (以及 `do-while`)

4. 范围遍历循环 (`for...range`)

if语句

1. 基础的 `if-else` 结构

2. `if` 的强大特性：带初始化短语句

switch语句

1. 默认不“贯穿”（Implicit `break`）

2. 更灵活的 `case` 值

3. 无表达式的 `switch` (替代 if-else 链)

defer推迟

for循环

1. 标准的三段式 for 循环

2. 模拟 while 循环

3. 模拟无限循环 (以及 do-while)

4. 范围遍历循环 (for...range)

if语句

1. 基础的 if-else 结构

2. if 的强大特性：带初始化短语句

switch语句

1. 默认不“贯穿”（Implicit break）

2. 更灵活的 case 值

3. 无表达式的 switch (替代 if-else 链)

defer推迟

1. 标准的三段式 `for` 循环

2. 模拟 `while` 循环

3. 模拟无限循环 (以及 `do-while`)

4. 范围遍历循环 (`for...range`)

1. 基础的 `if-else` 结构

2. `if` 的强大特性：带初始化短语句

1. 默认不“贯穿”（Implicit `break`）

2. 更灵活的 `case` 值

3. 无表达式的 `switch` (替代 if-else 链)