运算符和流程控制

运算符

介绍运算符之前，需要知道表达式，什么是表达式？在 Go 语言中的表达式是运算或者求值的最小单位。表达式通过运算符及其对应操作数构成，用于产生另一个值，简单理解就是表达式就是是为了通过运算和计算，来获取我们想要的结果数据的书写形式。

下面是一些 Go 语言表达式的示例：

x := 42             // 整型字面量
y := 3.14           // 浮点型字面量  
found := true       // 布尔型字面量
name := "Alice"     // 字符串字面量

ages := []int{25, 30, 35}             // Slice字面量
user := struct{name string; age int}{ // 结构体字面量
    name: "Bob",
    age:  28,
}

sum := 5 + 3                    // 算术运算
isEqual := (x == 42)            // 关系运算  
logical := (found && !isEqual)  // 逻辑运算

total := add(5, 7)   // 自定义函数调用
length := len(name)  // 内置函数调用

value, ok := m["key"]     // 解析map值和bool判断是否存在
intVal, isInt := x.(int)  // x值是否为int类型
switch x := x.(type) {    // 类型switch
case int:
    fmt.Println("int")
// ...
}

p := person{name:"Alice", age:30}
personName := p.name        // 结构体成员访问
chars := name[1:4]          // 字符串切片索引
secondValue := ages[1]      // 数组/slice索引

算术运算符

下表列出了所有 Go 语言的算术运算符。假定 A 值为 10，B 值为 20。

运算符	描述	示例
+	相加	A + B 输出结果 30
-	相减	A - B 输出结果 -10
*	相乘	A * B 输出结果 200
/	相除	B / A 输出结果 2
%	取模(余数)	B % A 输出结果 0
++	自增	A++ 输出结果 11
--	自减	B-- 输出结果 19

示例：

package main

import "fmt"

func main() {
	// 算数运算符示例
	a := 10
	b := 20

	// 加
	sum := a + b
	fmt.Printf("和: %d\n", sum)

	// 减
	diff := a - b
	fmt.Printf("差: %d\n", diff)

	// 乘
	prod := a * b
	fmt.Printf("积: %d\n", prod)

	// 除
	quot := b / a
	fmt.Printf("商: %d\n", quot)

	// 取模
	rem := b % a
	fmt.Printf("余数: %d\n", rem)

	// 自增
	a++
	fmt.Printf("a: %d\n", a)

	// 自减
	b--
	fmt.Printf("b: %d\n", b)
}

关系运算符

下表列出了所有 Go 语言的关系运算符，假定 A=10 B=20。

运算符	描述	示例
==	检查两个值是否相等，如果相等返回 True 否则返回 False	(A == B) 返回 False
!=	检查两个值是否不相等，如果不相等返回 True 否则返回 False	(A != B) 返回 True
>	检查左边值是否大于右边值，如果是返回 True 否则返回 False	(A > B) 返回 False
<	检查左边值是否小于右边值，如果是返回 True 否则返回 False	(A < B) 返回 True
>=	检查左边值是否大于等于右边值，如果是返回 True 否则返回 False	(A >= B) 返回 False
<=	检查左边值是否小于等于右边值，如果是返回 True 否则返回 False	(A <= B) 返回 True

示例：

package main

import "fmt"

func main() {
	// 关系运算符示例
	a := 10
	b := 20

	// ==
	equal := a == b
	fmt.Printf("相等: %t\n", equal)

	// !=
	notEqual := a != b
	fmt.Printf("不相等: %t\n", notEqual)

	// >
	greaterThan := a > b
	fmt.Printf("大于: %t\n", greaterThan)

	// <
	lessThan := a < b
	fmt.Printf("小于: %t\n", lessThan)

	// >=
	greaterOrEqual := a >= b
	fmt.Printf("大于等于: %t\n", greaterOrEqual)

	// <=
	lessOrEqual := a <= b
	fmt.Printf("小于等于: %t\n", lessOrEqual)
}

逻辑运算符

下表列出了所有 Go 语言的逻辑运算符。假定 A 为 True，B 为 False。

运算符	描述	示例
&&	逻辑与运算符。如果两边的操作数都是 True，则为 True，否则为 False	(A && B) 为 False
\|\|	逻辑或运算符。如果两边的操作数有一个 True，则为 True，否则为 False	(A \|\| B) 为 True
!	逻辑非运算符。执行与运算符相反的操作，有True返回False，有False返回True	!(A && B) 为 True

示例：

package main

import "fmt"

func main() {
	// 逻辑运算符
	a := true
	b := false

	// 逻辑与
	AndResult := a && b
	fmt.Printf("逻辑与: %t\n", AndResult)

	// 逻辑或
	OrResult := a || b
	fmt.Printf("逻辑或: %t\n", OrResult)

	// 逻辑非
	NotResult := !a
	fmt.Printf("逻辑非: %t\n", NotResult)
}

位运算符

下表列出了所有 Go 语言的位运算符，假定 A = 60 (0011 1100)，B = 13 (0000 1101)

运算符	描述	示例
&	按位与运算符，按二进制位进行"与"运算。只有两个二进位都为1时，结果位才为1，否则为0	(A & B) 将得到 12 (0000 1100)
\|	按位或运算符，按二进制位进行"或"运算。只要有一个二进位为1，结果位就为1，否则为0	(A \| B) 将得到 61 (0011 1101)
^	按位异或运算符，按二进制位进行异或运算。两个二进位相同(1或全为0)结果为0，不同则结果为1	(A ^ B) 将得到 49 (0011 0001)
&^	按位清除运算符，按位置零运算，先按位与运算，然后去除被操作数二的位	(A &^ B) 将得到 48 (0011 0000)
<<	按位左移运算符，将操作数向左移动指定位数(操作数右边附 0)，超出左边部分被丢弃	(A << 2) 将得到 240 (1111 0000)
>>	按位右移运算符，将操作数向右移动指定位数(操作数左边附 0)，超出右边部分被丢弃	(A >> 2) 将得到 15 (0000 1111)

示例：

package main

import "fmt"

func main() {
	// 位运算符示例
	a := 60 // 0011 1100
	b := 13 // 0000 1101

	// 按位与运算符
	And := a & b
	fmt.Printf("按位与: %d (%08b)\n", And, And)

	// 按位或运算符
	Or := a | b
	fmt.Printf("按位或: %d (%08b)\n", Or, Or)

	// 按位异或运算符
	Xor := a ^ b
	fmt.Printf("按位异或: %d (%08b)\n", Xor, Xor)

	// 按位清除运算符
	AndNot := a &^ b
	fmt.Printf("按位清除: %d (%08b)\n", AndNot, AndNot)

	// 按位左移运算符
	Left := a << 2
	fmt.Printf("按位左移: %d (%08b)\n", Left, Left)

	// 按位右移运算符
	Right := a >> 2
	fmt.Printf("按位右移: %d (%08b)\n", Right, Right)
}

赋值运算符

下表列出了所有 Go 语言的赋值运算符。

运算符	描述	示例
=	简单赋值运算符，将一个表达式的值赋给左值	C = A + B将把 A + B 表达式结果赋值给 C
+=	相加后再赋值	C += A 相当于 C = C + A
-=	相减后再赋值	C -= A 相当于 C = C - A
*=	相乘后再赋值	C = A 相当于 C = C A
/=	相除后再赋值	C /= A 相当于 C = C / A
%=	求余后再赋值	C %= A 相当于 C = C % A
<<=	按位左移后赋值	C <<= 2 相当于 C = C << 2
>>=	按位右移后赋值	C >>= 2 相当于 C = C >> 2
&=	按位与后赋值	C &= 2 相当于 C = C & 2
^=	按位异或后赋值	C ^= 2 相当于 C = C ^ 2
\|=	按位或后赋值	C \|= 2 相当于 C = C \| 2

示例：

package main

import "fmt"

func main() {
	// 赋值运算符示例
	var A = 10
	var B = 5
	var C int

	// 简单赋值运算符
	C = A + B
	fmt.Println("C =", C) // 输出：C = 15

	// 相加后再赋值
	C += A
	fmt.Println("C =", C) // 输出：C = 25

	// 相减后再赋值
	C -= A
	fmt.Println("C =", C) // 输出：C = 15

	// 相乘后再赋值
	C *= A
	fmt.Println("C =", C) // 输出：C = 150

	// 相除后再赋值
	C /= A
	fmt.Println("C =", C) // 输出：C = 15

	// 求余后再赋值
	C %= A
	fmt.Println("C =", C) // 输出：C = 5

	// 按位左移后赋值
	C <<= 2
	fmt.Println("C =", C) // 输出：C = 20

	// 按位右移后赋值
	C >>= 2
	fmt.Println("C =", C) // 输出：C = 5

	// 按位与后赋值
	C &= 2
	fmt.Println("C =", C) // 输出：C = 0

	// 按位异或后赋值
	C ^= 2
	fmt.Println("C =", C) // 输出：C = 2

	// 按位或后赋值
	C |= 2
	fmt.Println("C =", C) // 输出：C = 2
	
	// 按位非后赋值
	C &^= 2
	fmt.Println("C =", C) // 输出：C = 0
}

其他运算符

下表列出了所有 Go 语言的其他运算符。

运算符	描述	示例
&	返回变量存储地址	&a 将取变量 a 的存储地址
*	指针变量	*a 将取值给定地址 a 的值
<-	发送和接收操作符，用于通道操作	<- ch 从通道接收数据，ch <- 3 向通道发送数据3
,	逗号运算符，用于构造并列序列	5, 7 , 8 定义了一个包含3个整数的并列序列

示例：

package main

import "fmt"

func main() {
    // 其他运算符示例
	var a = 10
	var b *int // 指针变量

	b = &a                  // 获取变量 a 的存储地址
	fmt.Println("a =", a)   // 输出：a = 10
	fmt.Println("b =", b)   // 输出：b = 0xc0000140a8
	fmt.Println("*b =", *b) // 输出：*b = 10 (通过指针变量获取地址对应的值)

	ch := make(chan int) // 创建一个整数类型的通道

	go func() {
		ch <- 3 // 向通道发送数据3
	}()

	x := <-ch             // 从通道接收数据
	fmt.Println("x =", x) // 输出：x = 3

	// 逗号运算符
	var (
		num1 = 5
		num2 = 7
		num3 = 8
	)
	fmt.Println(num1, num2, num3) // 输出：5 7 8
}

运算符优先级

有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低。

优先级	运算符
5	`*` `/` `%` `<<` `>>` `&` `&^`
4	`+` `-` `\|` `^`
3	`==` `!=` `<` `<=` `>` `>=`
2	`&&`
1	`\|\|`

示例：

package main

import "fmt"

func main() {
	// 运算符优先级示例
	a := 5
	b := 3
	c := 2

	// 表达式计算顺序
	result1 := a + b*c // 先计算 b * c，再加 a
	// result1 = 5 + 3 * 2 = 11

	result2 := (a + b) * c // 先计算 a + b，再乘以 c
	// result2 = (5 + 3) * 2 = 16

	result3 := a * b / c // 先计算 a * b，再除以 c
	// result3 = 5 * 3 / 2 = 7

	result4 := a%b + c // 先计算 a % b，再加 c
	// result4 = 5 % 3 + 2 = 4

	result5 := a < b && b < c // 先计算 a < b，再计算 b < c，最后进行逻辑与运算
	// result5 = false && true = false

	fmt.Println("result1:", result1)
	fmt.Println("result2:", result2)
	fmt.Println("result3:", result3)
	fmt.Println("result4:", result4)
	fmt.Println("result5:", result5)
}

流程控制

简单概述

程序的流程控制结构一共有三种：

顺序结构：按照代码的先后顺序依次执行，这是最基本的流程控制结构。
选择结构：根据条件判断执行不同的代码块，常见的选择结构包括 if-else 语句和 switch 语句。
循环结构：重复执行某些代码，Go 语言中常用的循环结构是 for 循环。

除了这三种基本的流程控制结构，Go 语言还提供了一些其他的流程控制语句，如 break、continue 和 defer、goto 等，用于更细粒度地控制程序的执行流程。

顺序结构

顺序结构：按照代码的顺序从上到下逐行执行，也是从左往右执行的，这意味着在代码中定义的变量、函数和语句将按照它们的顺序依次执行。

语法格式：

逻辑代码1
逻辑代码2 
逻辑代码3
...

示例：

package main

import "fmt"

func main() {
	// 顺序结构，从上到下执行，从左到右执行。
	fmt.Println("Start")
	fmt.Println("Step 1")
	fmt.Println("Step 2")
	fmt.Println("Step 3")
	fmt.Println("End")
}

if语句

分支语句 if 是一种条件语句，用于根据给定的条件选择性地执行不同的代码块。在 Go 语言中，if 语句可以有两种形式：普通的 if 和带有 else 的 if。

语法格式：

单个ifif...else多个if...else

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
}

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
} else {
  /* 在布尔表达式为 false 时执行 */
}

if 布尔表达式1 {
   /* 在布尔表达式1为 true 时执行 */
} else if 布尔表达式2 {
   /* 在布尔表达式1为 false ,布尔表达式2为true时执行 */
} else {
   /* 在上面两个布尔表达式都为false时，执行*/
}

示例：

示例1示例2示例3示例4

package main

import "fmt"

func main() {
	// 单if语句示例
	// var a int = 15
	var a int = 8
	if a < 10 {
		// 当a小于10的时候进入if语句内执行里面的逻辑
		fmt.Println("a小于10")
	}
	// 这里的条件按照顺序结构，后面都是会执行的。
	fmt.Println("a大于10")
}

package main

import "fmt"

func main() {
	// if...else语句示例
	// 判断成绩是否及格
	var score int = 60
	if score >= 60 {
		fmt.Println("及格")
	} else {
		fmt.Println("不及格")
	}
}

package main

import "fmt"

func main() {
	// 多个if else 语句示例
	score := 85

	if score >= 90 {
		fmt.Println("优秀")
	} else if score >= 80 {
		fmt.Println("良好")
	} else if score >= 70 {
		fmt.Println("中等")
	} else if score >= 60 {
		fmt.Println("及格")
	} else {
		fmt.Println("不及格")
	}
}

package main

import "fmt"

func main() {
	// 嵌套if else示例
	age := 25
	height := 180

	if age >= 18 {
		fmt.Println("年龄符合要求")
		if height >= 160 {
			fmt.Println("身高符合要求")
			fmt.Println("符合报名条件")
		} else {
			fmt.Println("身高不符合要求")
			fmt.Println("不符合报名条件")
		}
	} else {
		fmt.Println("年龄不符合要求")
		fmt.Println("不符合报名条件")
	}
}

if变体形式

Go 语言中的 if 语句有一个变体形式，称为 "if with initialization"，可以在条件判断之前执行一个简单的语句。这种变体允许我们在 if 语句中声明并初始化一个变量，该变量的作用域仅限于 if 语句块。

语法格式：

// 如果 条件表达式 为 true，则执行与之关联的代码块。
if 初始化语句; 条件表达式 {
    // 当条件为 true 时执行的代码
}

示例：

示例1示例2

package main

func main() {
	// if语句变体形式
	if num := 20; num%2 == 0 {
		println("num是偶数")
	} else {
		println("num是奇数")
	}
}

package main

import "fmt"

func main() {
	// 使用初始化语句
	// error错误处理，后面文档中有介绍
	if x, err := getData(); err == nil {
		fmt.Println("数据获取成功:", x)
	} else {
		fmt.Println("数据获取失败:", err)
	}
}

// getData 获取数据
func getData() (int, error) {
	return 42, nil
}

switch语句

在 Go 语言中 switch 语句是一种多分支选择语句，用于根据表达式的值选择性地执行不同的代码块，switch 语句可以比较简洁地实现多个条件的判断和分支。

语法格式：

表达式 switch格式类型 switch格式

switch [表达式] {
case 值1:
    // 当表达式的值与值1匹配时执行的代码块
case 值2:
    // 当表达式的值与值2匹配时执行的代码块
...
default:
    // 当表达式的值与上述所有值都不匹配时执行的代码块
}

switch {
case 条件表达式1:
    // 当条件表达式满足时执行的代码块
case 条件表达式2:
    // 当条件表达式满足时执行的代码块
...
default:
    // 当表达式的值与上述所有值都不匹配时执行的代码块
}

示例：

示例1示例2示例3示例4

package main

func main() {
	// 表达式 switch语句格式
	// go语句switch语句改进语法设计，case与case之间是独立的代码块，不需要通过 break 语句跳出当前 case 代码块以避免执行到下一行。

	var str = "hello"

	switch str {
	case "hello":
		println(1)
	case "world":
		println(2)
	default:
		println(0)
	}
}

package main

import "fmt"

func main() {
    // 表达式 switch语句格式
	// 使用 switch 语句根据 day 的值判断星期几，并输出相应的信息。
	day := 3
	// day的值为3时，输出"星期三"
	switch day {
	case 1:
		fmt.Println("星期一")
	case 2:
		fmt.Println("星期二")
	case 3:
		fmt.Println("星期三")
	case 4:
		fmt.Println("星期四")
	case 5:
		fmt.Println("星期五")
	case 6:
		fmt.Println("星期六")
	case 7:
		fmt.Println("星期日")
	default:
		fmt.Println("day的数值有误!!")
	}
}

package main

import "fmt"

func main() {
	// 表达式 switch语句格式
	// switch语句示例，多个case放在一行示例
	condition := 5
	switch condition {
	case 1, 3, 5, 7, 9:
		fmt.Println(true)
	case 2, 4, 6, 8, 10:
		fmt.Println(false)
	default:
		fmt.Println(0)
	}
}

package main

import "fmt"

func main() {
	// 类型 switch语句示例
	// switch语句 case后面还可以跟表达式，switch后面就不能有表达式。
	score := 85
	switch {
	case score >= 90:
		fmt.Println("优秀")
	case score >= 80:
		fmt.Println("良好")
		break // 跳出当前 switch 语句
	case score >= 70:
		fmt.Println("中等")
	default:
		fmt.Println("不及格")
	}
}

switch语句注意事项

唯一性：每个 case 中的值必须是唯一的，不能重复。
可比较性：switch 语句的表达式和每个 case 中的值必须是可以进行比较的类型。例如，int、string、char、bool、enum 等类型都是可以进行比较的，而 slice、map、function 等类型是不可比较的。
自动跳出：在 Go 中，switch 语句的每个 case 执行完成后会自动跳出 switch 不需要使用 break 语句。
fallthrough 关键字：使用 fallthrough 关键字可以实现执行完当前 case 后继续执行下一个 case，无论下一个 case 的条件是否匹配。
default 子句：default 子句是可选的，用于处理没有与任何 case 匹配的情况。如果没有匹配的 case，将执行 default 代码块。
多条件匹配：Go 的 switch 语句可以在一个 case 中匹配多个条件，使用逗号分隔多个条件。例如：case 1, 2, 3:。
省略表达式：switch 语句的表达式可以被省略，相当于 switch true。这样可以根据条件表达式的结果进行判断和选择。
类型开关：在 switch 语句中，可以使用类型开关来匹配和判断不同的数据类型。例如：case int:、case string: 等。

注意事项示例：

var num int = 5
// 每一个case值必须是唯一的，必须为常量表达式，且需要和switch表达式的类型匹配。
switch num {
case 1:
    fmt.Println("One")
case 2:
    fmt.Println("Two")
case 3:
    fmt.Println("Three")
case 3: // 错误，重复的 case
    fmt.Println("Duplicate Three")
case "four": // 错误，类型不匹配
    fmt.Println("Four")
default:
    fmt.Println("Other")
}

var num int = 2
// fallthrough 关键字：使用 fallthrough 关键字可以实现执行完当前 case 后继续执行下一个 case，无论下一个 case 的条件是否匹配。
switch num {
case 1:
    fmt.Println("One")
case 2:
    fmt.Println("Two")
    fallthrough // 继续执行下一个 case
case 3:
    fmt.Println("Three")
default:
    fmt.Println("Other")
}
// 输出结果：
// Two
// Three

var num int = 6

switch num {
case 1:
    fmt.Println("One")
case 2:
    fmt.Println("Two")
default:
    fmt.Println("Other")
}
// 输出结果：
// Other

var num int = 3

switch num {
case 1, 2, 3:
    fmt.Println("One, Two, or Three")
case 4, 5, 6:
    fmt.Println("Four, Five, or Six")
default:
    fmt.Println("Other")
}
// 输出结果：
// One, Two, or Three

var num int = 5

switch {
case num < 5:
    fmt.Println("Less than Five")
case num == 5:
    fmt.Println("Equal to Five")
case num > 5:
    fmt.Println("Greater than Five")
default:
    fmt.Println("Other")
}
// 输出结果：
// Equal to Five

var data interface{} = "hello"

switch data.(type) {
case int:
    fmt.Println("Integer")
case string:
    fmt.Println("String")
default:
    fmt.Println("Other")
}
// 输出结果：
// String

for语句

在 Go 语言中循环结构有 for 循环、for 循环变体、for range 循环，与其他语言不同，Go 语言不支持 while 和 do-while 循环。

语法格式：

基本形式带初始化和迭代语句的形式嵌套循环语法格式for range格式

for [条件表达式] {
    // 循环体
}

// 初始化语句: 在循环开始前执行的语句，通常用于初始化循环变量。
// 条件表达式: 决定是否继续执行循环的表达式，只要条件为 true，循环就会继续执行，为 false 则退出循环。
// 后置语句: 在每次循环结束时执行，通常用于更新循环变量。
// 循环体: 包含需要重复执行的语句。
for ①初始化语句; ②条件表达式; ④后置语句 {
    ③// 循环体
}

// 嵌套循环，先执行外层循环，再执行内层循环
for ①外层循环初始化语句; ②外层循环条件表达式; ⑦外层循环后置语句 {
    // 外层循环体
    for ③内层循环初始化语句; ④内层循环条件表达式; ⑥内层循环后置语句 {
        ⑤// 内层循环体
    }
}

// index：是集合中元素的索引。
// value：是集合中元素的值。
// collection：是要遍历的集合，如数组、切片、映射或字符串。
for index, value := range collection {
    // 处理 index 和 value
}

示例：

示例1示例2示例3示例4

package main

import "fmt"

func main() {
	// 循环语句 基本形式示例
	// 求1-100的和
	sum := 0
	i := 1
	for i <= 100 {
		sum += i
		i++
	}
	fmt.Println("1-100的和:", sum)
}

package main

import "fmt"

func main() {
	// 带初始化和迭代语句的形式示例
	// 求1-100的总和
	sum := 0
	for i := 1; i <= 100; i++ {
		sum += i
	}
	fmt.Printf("sum:%d\n", sum)
}

package main

import "fmt"

func main() {
	// 嵌套循环，先执行外层循环，再执行内层循环
	// 嵌套循环案例，打印99乘法表
	for x := 1; x <= 9; x++ {
		for y := 1; y <= x; y++ {
			fmt.Printf("%d x %d = %d\t", y, x, x*y)
		}
		fmt.Println()
	}
}

package main

import "fmt"

func main() {
	// for range循环示例。
	// 遍历数组。
	arr := [...]int{10, 20, 30, 40, 50}
	fmt.Printf("%T\n", arr)
	for i, v := range arr {
		println(i, v)
	}

	fmt.Println("=========================")

	// 遍历切片。
	slice := []int{100, 200, 300, 400, 500}
	fmt.Printf("%T\n", slice)
	for i, v := range slice {
		println(i, v)
	}

	fmt.Println("=========================")

	// 遍历map
	m := map[string]int{
		"one":   1,
		"two":   2,
		"three": 3,
	}
	fmt.Printf("%T\n", m)
	for k, v := range m {
		println(k, v)
	}

	fmt.Println("=========================")

	// 遍历字符串
	str := "hello world"
	fmt.Printf("%T\n", str)
	for i, v := range str {
		println(i, v)
	}
}

goto语句

Go语言中的 goto 语句提供了一种无条件跳转的控制流方式。与大多数编程语言类似 goto 语句可以跳转到程序中的任意标签位置。但在Go语言中 goto 语句的使用应该谨慎，因为它可能导致代码难以理解和维护。

语法格式：

label:
    // 代码块

goto label

示例：

示例1

package main

import "fmt"

func main() {
	// goto: 提供了一种无条件跳转的控制流方式
	num := 100
	fmt.Println("num:", num)
	goto Label1 // 跳转到Label1标签处
	num = 200   // 这行代码不会执行
Label1:
	fmt.Println("num:", num)
}

break语句

break 语句用于跳出当前的循环或 switch 语句，通常与 for、switch 等语句配合使用。

语法格式：

// 不带标签的 break 语句用于跳出当前的循环语句(for、switch、select)。
// 带标签的 break 语句可以跳出指定的标签对应的循环语句。
break [label]

示例：

示例1示例2示例3示例4

package main

import "fmt"

func main() {
	// break不带标签示例
	for i := 1; i <= 10; i++ {
		if i == 5 {
			break // 当 i 等于 3 时，跳出当前 for 循环
		}
		fmt.Println(i) // 这里只会打印1到4
	}
}

package main

import "fmt"

func main() {
	// break带标签示例
	// 第一次循环 外层循环1次(i=0) 内层循环3次(j=0/j=1/j=2)
	// 第二次循环 外层循环1次(i=1) 内层循环3次(j=0/j=1) 此时满足条件 i==1 && j==1 就break outer 跳转到 outer 标签这里执行。
outer:
	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			if i == 1 && j == 1 {
				break outer // break outer 语句会跳出标签为 outer 的外层 for 循环，直接结束整个循环，不再执行内层循环剩余的部分。
			}
			fmt.Printf("i: %d, j: %d\n", i, j)
		}
		fmt.Printf("i: %d\n", i)
	}
	fmt.Println("main end")
}

package main

import "fmt"

func main() {
	// switch语句使用break不带标签示例
	day := 3
	switch day {
	case 1:
		fmt.Println("Monday")
	case 2:
		fmt.Println("Tuesday")
	case 3:
		fmt.Println("Wednesday")
		// 执行完 case 3 中的语句后，会自动跳出整个 switch 语句
		break
	case 4:
		fmt.Println("Thursday")
	case 5:
		fmt.Println("Friday")
	case 6:
		fmt.Println("Saturday")
	case 7:
		fmt.Println("Sunday")
	default:
		fmt.Println("Invalid day")
	}
}

package main

import "fmt"

func main() {
    // switch语句使用break带标签示例
	// 在这个例子中，我们使用了一个带有标签 outer 的 for 循环作为外层循环。
	// 在 switch 语句中，当 i 的值为 2 时，我们使用 break outer 跳出了整个外层的 for 循环，而不仅仅是跳出 switch 语句
outer:
	for i := 0; i < 10; i++ {
		fmt.Println("外层循环迭代:", i)
		switch i {
		case 1:
			fmt.Println("case 1")
		case 2:
			fmt.Println("case 2")
			break outer
		case 3:
			fmt.Println("case 3")
		}
		fmt.Println("外层循环继续")
	}
	fmt.Println("程序结束")
}

continue语句

continue 语句用于结束当前循环迭代，跳转到下一次循环，通常与 for 语句配合使用。

语法格式：

// 不带标签的 continue 语句用于结束当前循环迭代，直接进入下一次循环。
// 带标签的 continue 语句可以结束指定标签对应的循环的当前迭代，进入下一次迭代。
continue [label]

示例1示例2

package main

import "fmt"

func main() {
	// 不带标签的 continue 示例
	for i := 1; i <= 5; i++ {
		switch i {
		case 1, 3, 5:
			fmt.Printf("Skipping %d\n", i)
			continue // 结束当前循环迭代，直接进入下一次循环
		default:
			fmt.Printf("Processing %d\n", i)
		}
	}
}

package main

import "fmt"

func main() {
	// 带标签的 continue 示例
outer:
	for i := 1; i <= 3; i++ {
		fmt.Printf("Outer loop iteration: %d\n", i)

		for j := 1; j <= 3; j++ {
			switch j {
			case 2:
				fmt.Printf("Skipping inner loop iteration %d\n", j)
				continue outer // 结束标签为 outer 的循环的当前迭代
			default:
				fmt.Printf("Inner loop processing %d, %d\n", i, j)
			}
		}
	}
}

运算符和流程控制 ​

运算符 ​

算术运算符 ​

关系运算符 ​

逻辑运算符 ​

位运算符 ​

赋值运算符 ​

其他运算符 ​

运算符优先级 ​

流程控制 ​

简单概述 ​

顺序结构 ​

if语句 ​

if变体形式 ​

switch语句 ​

for语句 ​

goto语句 ​

break语句 ​

continue语句 ​

运算符和流程控制

运算符

算术运算符

关系运算符

逻辑运算符

位运算符

赋值运算符

其他运算符

运算符优先级

流程控制

简单概述

顺序结构

if语句

if变体形式

switch语句

for语句

goto语句

break语句

continue语句