06 go语言（golang） - 循环语句运算符
循环语句
在Go语言中，for 循环是实现循环的主要方式，它非常灵活且强大。
1. 基本的 for 循环
这种形式类似于 C/C++ 和 Java 中的 for 循环。它包括三个部分：初始化语句；条件表达式；后续操作（通常是递增或递减）。
for 初始化; 条件; 后续操作 {
// 循环体代码
}
示例代码：
for num := 0; num < 20; num++ {
fmt.Println(num)
}
// 后续操作可以放到for循环里面
for num := 0; num < 20; {
fmt.Println(num)
num++
}
2. 类似 while 的 for 循环
在Go中，你可以省略初始化和后续操作部分，只保留条件表达式，使其行为类似于传统意义上的 while 循环。
for 条件 {
// 循环体代码
}
示例代码：
num := 0
for num < 20 {
fmt.Println(num)
num++
}
3. 无限循环
如果你省略了所有三个部分（初始化、条件、后续操作），那么循环将变成一个无限循环。
for {
// 永远执行直到内部有break或return等跳出逻辑。
}
示例代码：
package main
import (
"fmt"
"time"
)
func main() {
num := 0
for {
fmt.Println(num)
num++
// 睡眠1秒
time.Sleep(time.Second * 1)
}
}
4. range循环
Go 还提供了一种特殊形式的 for 来迭代集合类型（如数组、切片和映射map）。使用关键字 range, 它会返回两个值：索引和元素值。
nums := []int{10, 20, 30, 40, 50}
for index, value := range nums {
fmt.Printf("下标: %d ，下标对应值: %d\n", index, value)
}
// 在 range 循环中，如果不需要索引，可以使用 _ 来忽略它：
for _, value := range nums {
fmt.Printf("下标对应值: %d\n", value)
}
5. 控制语句：break 和 continue
基本用法
break: 跳出整个循块。continue: 跳过当前迭代，并开始下一次迭代。
每种类型的 for 循块都可以使用这些控制语句来改变其执行流程。
for i := 0; i < 20; i++ {
fmt.Println(i)
// 到5的时候跳出循环
if i == 5 {
break
}
}
for i := 0; i < 20; i++ {
// 到5的时候跳过，继续下次循环
if i == 5 {
continue
}
fmt.Println(i)
}
配合标签使用
在Go语言中，continue 和 break 可以与标签（label）配合使用来控制嵌套循环的流程。这种用法可以让你直接跳出多层循环或者继续执行外层循环的下一次迭代，而不仅仅是最内层的那个。
标签是紧跟着冒号的一个标识符（例如 Label:），它可以放在任何语句之前，但通常用于循环语句前。
使用 break 与标签
当你使用带有标签的 break 时，你可以结束指定标签所指向的循环，而不仅是当前最内部的那个for循环。
package main
import "fmt"
func main() {
OuterLoop:
for i := 0; i < 3; i++ {
for j := 0; j < 3; j++ {
if i > j {
fmt.Printf("已满足条件i>j，跳出整个循环 i = %d, j = %d\n", i, j)
break OuterLoop
}
fmt.Printf("i = %d, j = %d\n", i, j)
}
}
}
输出：
i = 0, j = 0
i = 0, j = 1
i = 0, j = 2
已满足条件i>j，跳出整个循环 i = 1, j = 0
使用 continue 与标签
当你使用带有标签的 continue时，程序会跳过当前迭代，并开始执行带有该标签的外层循环下一次迭代。
package main
import "fmt"
func main() {
OuterLoop:
for i := 0; i < 3; i++ {
for j := 0; j < 3; j++ {
if i == j {
fmt.Printf("已满足条件i==j，继续下个循环 i = %d, j = %d\n", i, j)
continue OuterLoop // 跳到OuterLoop开始新一轮迭代
}
fmt.Printf("i = %d, j = %d\n", i, j)
}
}
}
输出：
已满足条件i==j，继续下个循环 i = 0, j = 0
i = 1, j = 0
已满足条件i==j，继续下个循环 i = 1, j = 1
i = 2, j = 0
i = 2, j = 1
已满足条件i==j，继续下个循环 i = 2, j = 2
练习
前面 05 go语言（golang） - 常量和条件语句 文章中的练习题，现在可以优化为：
用户输入一个数字，看是否与程序随机生成的一样
package main
import (
"fmt"
"math/rand"
)
func main() {
fmt.Println("猜猜看，请输入我想1-100数字：")
var targetNumber int = rand.Intn(100) + 1 // 随机生成1-100的数字，左闭右开，不加一的话是0到99
//println(targetNumber)
count := 0
for {
if number := inputNumber(); number > targetNumber {
fmt.Printf("比 %d 小，再猜猜\n", number)
count++
} else if number < targetNumber {
fmt.Printf("比 %d 大，再猜猜\n", number)
count++
} else {
fmt.Printf("恭喜！猜对了！一共猜了 %d 次\n", count)
break
}
}
}
func inputNumber() int {
var number int
_, err := fmt.Scanf("%d", &number)
if err != nil {
fmt.Println("输入有误请重新输入!")
return inputNumber()
}
return number
}
运算符
官方文档
1. 算术运算符
用于执行基本数学计算。
+（加）-（减）*（乘）/（除）%（模）
2. 关系运算符
用于比较两个值之间的关系。
==（等于）!=（不等于）<（小于）>（大于）<=（小于等于）>=（大于等于）
3. 逻辑运算符
用来组合条件。
&&（逻辑与）：如果两边都为真，则结果为真。||（逻辑或）：如果至少一边为真，则结果为真。!(逻辑非)：取反。
4. 赋值运算符
赋值运算符用来给变量赋值。
=（赋值）:=（短变量声明并赋值）+=（加法赋值）-=（减法赋值）*=（乘法赋值）/=（除法赋值）%=（取模赋值）
5.位操作运算符
位操作对整数在二进制级别进行操作。
&(按位与)|(按位或)^(按位异或)<<(左移)>>(右移)
示例代码
package main
import "fmt"
func main() {
// 算术运算
fmt.Println("10 + 5 =", 10+5)
fmt.Println("10 - 5 =", 10-5)
fmt.Println("10 * 5 =", 10*5)
fmt.Println("10 / 5 =", 10/5)
fmt.Println("10 % 3 =", 10%3)
// 比较运算
fmt.Println("5 == 5 为", 5 == 5)
fmt.Println("5 != 5 为", 5 != 5)
fmt.Println("7 > 3 为", 7 > 3)
fmt.Println("7 < 3 为", 7 < 3)
fmt.Println("7 <= 3 为", 7 <= 3)
fmt.Println("7 <= 3 为", 7 <= 3)
// 逻辑运算
fmt.Println("true && false 为", true && false)
fmt.Println("true || false 为", true || false)
fmt.Println("!true 为", !true)
// 赋值运算
y := 5
fmt.Println("y :=", y)
var x = 10
fmt.Println("x =", x)
x += 5
fmt.Println("x += 5 =", x)
x -= 5
fmt.Println("x -= 5 =", x)
x *= 5
fmt.Println("x *= 5 =", x)
x /= 5
fmt.Println("x /= 5 =", x)
x %= 3
fmt.Println("x %= 3 =", x)
// 位运算
fmt.Println("10 & 3 =", 10&3) // 因为10的二进制是1010，3的二进制是0011，所以按位与的结果是0010，所以结果是2
fmt.Println("10 | 3 =", 10|3) // 因为10的二进制是1010，3的二进制是0011，所以按位或的结果是1011，所以结果是11
fmt.Println("10 ^ 3 =", 10^3) // 因为10的二进制是1010，3的二进制是0011，所以按位异或（一真一假为真）的结果是1001，所以结果是9
fmt.Println("10 << 1 =", 10<<1) // 因为10的二进制是1010，左移一位就是10100，所以结果是20
fmt.Println("10 >> 1 =", 10>>1) // 因为10的二进制是1010，右移一位就是0101，所以结果是5
}
指针运算符
& 和 * 是与指针相关的运算符。它们分别用于获取变量的地址和访问指针指向的变量值。
关于指针我们下一篇文章再展开。
& 运算符
当你在一个变量前使用 & 符号时，它将返回该变量的内存地址。这是创建指针的常见方式。
package main
import "fmt"
func main() {
var a int = 58
fmt.Println("a的值:", a) // 输出变量a的值
fmt.Println("a的地址:", &a) // 输出变量a的内存地址
}
* 运算符
当你在一个指针前使用 * 符号时，它将访问该指针所指向的内存地址中存储的值（即解引用操作）。
package main
import "fmt"
func main() {
var a int = 58
var p *int = &a // p是一个int类型的指针，指向a的地址
fmt.Println("p的解引:", *p) // 使用*p来获取p所指向地址上存储的值（即a）
}