GO语言基础：运算符、流程控制

好的，我们继续学习 Go 语言的运算符和流程控制！这部分内容是你编写逻辑代码的基础，掌握它们后，你就能写出有判断、有循环的程序了。

---

一、运算符

运算符用于执行程序中的运算操作。Go 语言中的运算符可以分为以下几类。

1. 算术运算符

用于基本的数学运算。

运算符	描述	示例（a=10, b=3）	结果
+	相加	a + b	13
-	相减	a - b	7
*	相乘	a * b	30
/	相除	a / b	3（整数除法，结果为整数）
%	取余	a % b	1

⚠️ 注意：整数除法会截断小数部分；浮点数除法使用 / 即可。

示例：

a := 10
b := 3
fmt.Println(a + b) // 13
fmt.Println(a - b) // 7
fmt.Println(a * b) // 30
fmt.Println(a / b) // 3
fmt.Println(a % b) // 1

x := 10.0
y := 3.0
fmt.Println(x / y) // 3.3333333333333335

2. 比较运算符

比较两个值，返回布尔值 true 或 false。

运算符	描述	示例（a=5, b=3）	结果
==	等于	a == b	false
!=	不等于	a != b	true
<	小于	a < b	false
<=	小于等于	a <= b	false
>	大于	a > b	true
>=	大于等于	a >= b	true

示例：

age := 18
fmt.Println(age >= 18) // true
fmt.Println(age == 20) // false

3. 逻辑运算符

用于组合布尔值，常用于条件判断。

运算符	描述	示例（a=true, b=false）	结果
&&	逻辑与	a && b	false
`		`	逻辑或	`a		b`	true
!	逻辑非	!a	false

示例：

isMember := true
age := 20
if isMember && age >= 18 {
    fmt.Println("会员且成年")
}

4. 位运算符

对整数在内存中的二进制位进行操作。主要用于底层编程、性能优化等场景。

运算符	描述	示例（a=60（0011 1100）, b=13（0000 1101））	结果
&	按位与	a & b	12（0000 1100）
`	`	按位或	`a	b`	61（0011 1101）
^	按位异或	a ^ b	49（0011 0001）
&^	位清除（AND NOT）	a &^ b	48（0011 0000）
<<	左移	a << 2	240（1111 0000）
>>	右移	a >> 2	15（0000 1111）

💡 提示：初学者可以先了解基本用法，实际需要时再深入研究。

示例：

a := 60 // 二进制 00111100
b := 13 // 二进制 00001101
fmt.Printf("a & b = %d\n", a&b)   // 12
fmt.Printf("a | b = %d\n", a|b)   // 61
fmt.Printf("a ^ b = %d\n", a^b)   // 49

5. 赋值运算符

用于给变量赋值，常与算术或位运算符结合使用。

运算符	描述	示例	等价于
=	简单赋值	a = b	a = b
+=	相加后赋值	a += b	a = a + b
-=	相减后赋值	a -= b	a = a - b
*=	相乘后赋值	a *= b	a = a * b
/=	相除后赋值	a /= b	a = a / b
%=	取余后赋值	a %= b	a = a % b
&=	按位与后赋值	a &= b	a = a & b
`	=`	按位或后赋值	`a	= b`	`a = a	b`
^=	按位异或后赋值	a ^= b	a = a ^ b
<<=	左移后赋值	a <<= 2	a = a << 2
>>=	右移后赋值	a >>= 2	a = a >> 2

示例：

x := 5
x += 3   // x = x + 3 => 8
x *= 2   // x = x * 2 => 16

6. 其他运算符

• 取地址运算符 &：获取变量的内存地址。
• 指针解引用运算符 *：通过指针访问指向的值。
• 接收运算符 <-：用于通道（channel）的发送和接收。

这些属于进阶内容，我们后面再详细学习。

---

二、流程控制

流程控制决定了程序的执行路径。Go 语言的流程控制包括条件语句、循环语句和跳转语句。

1. if 语句

if 用于根据条件执行不同的代码块。Go 的 if 有一些独特之处：条件表达式不需要括号，但执行体必须用大括号 {} 括起来。

基本形式：

if 条件 {
    // 条件为 true 时执行
} else if 条件2 {
    // 条件2为 true 时执行
} else {
    // 所有条件都不满足时执行
}

示例：

score := 85
if score >= 90 {
    fmt.Println("优秀")
} else if score >= 60 {
    fmt.Println("及格")
} else {
    fmt.Println("不及格")
}

带简短语句的 if：可以在条件之前执行一个简单语句（通常是变量声明），该语句声明的变量作用域仅在 if 块内。

if age := 20; age >= 18 {
    fmt.Println("成年")
}
// 这里不能访问 age，因为它在 if 块内声明

2. switch 语句

switch 是多分支选择语句，比多个 if-else 更清晰。Go 的 switch 每个分支默认自带 break，不会自动向下穿透（不需要写 break）。

表达式 switch：

switch 表达式 {
case 值1:
    // 匹配值1时执行
case 值2:
    // 匹配值2时执行
default:
    // 所有 case 都不匹配时执行
}

示例：

day := "Monday"
switch day {
case "Monday", "Tuesday": // 多个值用逗号分隔
    fmt.Println("工作日")
case "Saturday", "Sunday":
    fmt.Println("周末")
default:
    fmt.Println("未知")
}

无表达式的 switch：相当于 switch true，可以用作 if-else 的替代，条件写在每个 case 中。

score := 75
switch {
case score >= 90:
    fmt.Println("A")
case score >= 80:
    fmt.Println("B")
case score >= 70:
    fmt.Println("C")
default:
    fmt.Println("D")
}

类型 switch：用于判断接口变量的动态类型（后续学习接口时会用到）。

fallthrough：如果需要强制向下穿透，可以使用 fallthrough 关键字。

num := 1
switch num {
case 1:
    fmt.Println("one")
    fallthrough
case 2:
    fmt.Println("two")
}
// 输出：
// one
// two

⚠️ fallthrough 会直接执行下一个 case 的代码，不再判断条件。

3. for 循环

Go 语言只有一种循环结构：for，但可以以三种形式使用。

形式1：类似 C 的 for（有初始化、条件、后置语句）

for 初始化; 条件; 后置 {
    // 循环体
}

示例：

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

形式2：类似 while 的 for（只有条件）

sum := 1
for sum < 100 {
    sum += sum
}
fmt.Println(sum) // 128

形式3：无限循环（没有条件）

for {
    // 无限循环，直到遇到 break 或 return
}

形式4：range 子句（遍历数组、切片、映射、字符串等）

nums := []int{10, 20, 30}
for index, value := range nums {
    fmt.Printf("索引 %d: 值 %d\n", index, value)
}

💡 如果不需要索引或值，可以用 _ 忽略：for _, v := range nums 或 for i := range nums。

4. break 和 continue

• break：用于跳出当前循环（或 switch/select 语句）。
• continue：跳过当前循环的剩余语句，直接开始下一次迭代。

示例：

for i := 0; i < 10; i++ {
    if i == 5 {
        break   // 跳出循环
    }
    if i%2 == 0 {
        continue // 跳过偶数
    }
    fmt.Println(i) // 输出 1, 3
}

带标签的 break 和 continue：当有嵌套循环时，可以使用标签指定要跳出或继续的是哪一层循环。

outer:
for i := 0; i < 3; i++ {
    for j := 0; j < 3; j++ {
        if i == 1 && j == 1 {
            break outer // 直接跳出外层循环
        }
        fmt.Printf("i=%d, j=%d\n", i, j)
    }
}
// 输出：
// i=0, j=0
// i=0, j=1
// i=0, j=2
// i=1, j=0
// 然后跳出，不会输出 i=1,j=1 及之后

---

总结

• 运算符：算术、比较、逻辑、位、赋值等，是构建表达式的基础。
• if 语句：支持简短语句，条件无需括号。
• switch 语句：简洁多分支，默认不穿透，支持 fallthrough。
• for 循环：唯一循环结构，支持三种形式，配合 range 遍历集合。
• break/continue：控制循环流程，支持标签操作。

现在你已经掌握了 Go 语言的核心基础！接下来可以通过编写小程序来练习，例如：

• 判断闰年
• 打印九九乘法表
• 统计字符串中字母个数

如果你有任何疑问，欢迎随时提问。继续加油，Go 小白！