本文详细介绍了Golang中的各种运算符，包括算术运算符、赋值运算符、比较运算符、逻辑运算符和位运算符，以及它们的使用细节和示例。同时，文章还涵盖了Golang中的流程控制结构，如if-else分支、for循环，以及如何实现类似三元运算的功能。此外，还讲解了如何通过switch语句进行类型判断和多重循环控制，以及break、continue和return语句的用法。
第四章 运算符
4.1运算符的介绍
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等
- 算术运算符
- 赋值运算符
- 比较运算符
- 逻辑运算符
- 位运算符
- 其它运算符
4.2算术运算符
- 算数运算符是对数值型的变量进行运算。如：加减乘除
- 算术运算符一览
%:a % b = a - a / b * b - 算术运算符的细节说明
- 对于除号“/”，整数之间做除法时，只保留整数部分，舍弃小数部分。
- 当对一个数取模（取余）时，可以等价:a % b = a - a / b * b
- Golang的自增自减只能当做一个独立语言使用，不能：b :=a++ 或者 b := a–
- Golang的++和–只能写在变量后面，不能写在变量的前面，即：只有a++ a–没有++a --a
- Golang的设计者去掉c/java中的自增自减的容易混淆的写法，让Golang更加简洁
4.3关系运算符（比较运算符）
- 介绍
- 关系运算符的结果都是bool型，true 或者 false
- 关系表达式经常用在if结构的条件中或循环结构的条件中
- 关系运算符预览
案例演示
package main
import "fmt"
//演示Golang中关系运算符的使用
func main() {
var n1 int = 9
var n2 int = 8
fmt.Println(n1 == n2)
fmt.Println(n1 != n2)
fmt.Println(n1 > n2)
fmt.Println(n1 >= n2)
fmt.Println(n1 < n2)
fmt.Println(n1 <= n2)
flag := n1 > n2
fmt.Println("flag=", flag)
}
- 细节说明
- 关系运算符的类型都是bool类型
- 关系运算符组成的表达式，我们称为关系表达式：a>b
- 比较运算符“==”不能误写成“=”
4.4逻辑运算符
- 介绍
用于连接多个条件（一般来讲就是关系表达式），最终结果是一个bool值 - 逻辑运算符一览
package main
import "fmt"
//演示Golang中逻辑运算符的使用
func main() {
var age int = 40
//逻辑 &&
if age > 30 && age < 50 {
fmt.Println("ok1")
}
if age >30 && age<40 {
fmt.Println("ok2")
}
//逻辑 ||
if age > 30 || age < 50 {
fmt.Println("ok3")
}
if age >30 || age<40 {
fmt.Println("ok4")
}
//逻辑 ！
if age > 30 {
fmt.Println("ok3")
}
if !(age >30) {
fmt.Println("ok4")
}
}
案例结果：
- 注意事项和细节说明
- &&也叫短路与：如果第一个条件为false，则第二个条件不会判断，最终结果为false
- ||也叫短路或：如果第一个为true，则第二个条件不会判断，最终结果为true
4.5赋值运算符
- 介绍
赋值运算符就是将某个运算后的值，赋给指定的变量 - 赋值运算符的分类
与二进制相关 - 赋值运算的案例演示
package main
import "fmt"
//演示Golang中赋值运算符的使用
func main() {
//var i int
//i = 10//基本赋值
//有两个变量，a和b，要求将其进行交换，最终打印结果
a := 9
b := 2
fmt.Printf("交换前的情况是 a = %v , b = %v\n", a, b)
//定义一个临时变量
t := a
a = b
b = t
fmt.Printf("交换后的情况是 a = %v , b = %v\n", a, b)
a += 17
fmt.Println("a =", a)
}
- 赋值运算符的特点
- 运算顺序从右向左
- 赋值运算符的左边 只能是变量，右边可以是变量、表达式、常量值
- 复合赋值运算等价于下面的效果
比如：a += 3 等价于a = a + 3
- 面试题：有两个变量，和b,要求将其进行交换，但是不允许使用中间变量，最终打印结果
package main
import (
"fmt"
)
func main() {
var a int = 10
var b int = 20
a = a + b
b = a - b //b = a + b - b
a = a - b //a = a + b - a
fmt.Printf("a = %v b = %v", a, b)
}
- 运算符的优先级
运算符优先级一览表
- 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
- 只有单目运算符、赋值运算符是从右向左运算的。
- 梳理了一个大概的优先级
1:括号，+，
2:单日运算
3:算术运算符
4:移位运算
5:关系运算符
6:位运算符
7:逻辑运算符
8:赋值运算符
9:逗号
4.6位运算符
4.7其它运算符
4.8特别说明
Go语言中没有三元运算
var n int
var i int = 10
var j int = 12
//传统的三元运算
//n = i > j ? i : j
if i > j{
n = i
} else{
n = j
}
fmt.Println("n=", n)//12
//使用if else 实现基本的三元运算
4.9键盘输入语句
- 介绍
在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。InputDemo.go - 步骤：
- 导入fmt包
- 调用fmt包的fmt.Scanln() 或者 fmt.Scanf()
- 案例演示：fmt.Scanln
package main
import (
"fmt"
)
func main() {
var name string
var age byte
var sal float32
var isPass bool
fmt.Println("请输入名字 ")
fmt.Scanln(&name)
fmt.Println("请输入年龄 ")
fmt.Scanln(&age)
fmt.Println("请输入薪水")
fmt.Scanln(&sal)
fmt.Println("请输入是否通过考试")
fmt.Scanln(&isPass)
fmt.Printf("名字是 %v\n 年龄是 %v\n 薪税是 %v\n 是否通过考试 %v\n", name, age, sal, isPass)
}
- 输出结果
- 案例演示：fmt.Scanf()
package main
import (
"fmt"
)
func main() {
var name string
var age byte
var sal float32
var isPass bool
fmt.Println("请输入你的名字， 年龄， 薪水，是否通过考试， 使用空格隔开")
fmt.Scanf("%s %d %f %t", &name, &age, &sal, &isPass)
fmt.Printf("名字是 %v \n 年龄是 %v \n 薪水是 %v \n 是否通过考试 %v \n", name, age, sal, isPass)
}
- 输出结果
4.10进制
- 进制介绍
对于整数，有四中表达方式：
- 二进制：在golang中，不能直接使用二进制表示一个整数，它沿用了c的特点（%b输出）
- 十进制
- 八进制
- 十六进制：0-9及A-F，满16进1.以0x或0X开头表示。此处的A-F不区分大小写
- 进制的转换介绍
- 其它进制转十进制
- 二进制转十进制
规则：从最低位开始（右边的)，将每个位上的数提取出来，乘以2的(位数-1)次方然后求和。
2）八进制转十进制
规则：从最低位开始（右边的)，将每个位上的数提取出来，乘以8的(位数-1)次方然后求和。
3）十六进制转十进制
规则：从最低位开始，将每个位上的数提取出来，乘以16的(位数-1)次方然后求和。
- 十进制转其它进制
- 十进制转二进制
规则：将该数不断除以2，直到商为0为止，然后将每步得到的余数倒过来，就是对应
的二进制。 - 十进制转八进制
规则：将该数不断除以8，直到商为0为止，然后将每步得到的余数倒过来，就是对应
的八进制。 - 十进制转十六进制
规则：将该数不断除以16，直到商为0为止，然后将每步得到的余数倒过来，就是对应
的十六进制。
- 二进制转八进制和十六进制
- 二进制转八进制
规则：将二进制数每三位一组（从低位开始组合），转成对应的八进制数即可。 - 二进制转十六进制
规则：将二进制数每四位一组（从低位开始组合），转成对应的十六进制数即可。
- 其它进制转二进制
- 八进制转换成二进制
规则：将八进制数每一位，转成对应的一个三位的二进制数即可 - 十六进制转成二进制
规则：将十六进制数每一位，转成对应的一个四位的二进制数即可
4.11位运算
- 原码、反码、补码
对于有符号的而言：
- 二进制的最高位是符号位：0表示整数，1表示负数
1---->[0000 0001] -1 ---->[1000 0001] - 正数的原码、反码、补码都一样
- 负数的反码=它的源码符号位不变，其它位取反
- 负数的补码=它的反码+1
- 0的反码、补码都是0
- 在计算机运算的时候，都是用补码的方式来运算的
- 位运算符和位移运算符
Golang中有3个位运算
分别是”按位与&、按位或|、按位异或^，它们的运算规则是：
按位与&
两位全为1，结果为1，否则为0
2&3
按位或|
两位有一个为1，结果为1，否则为0
按位异或^
两位一个为0，一个为1，结果为1，否则为0
fmt.Println("2&3 =", 2&3)
fmt.Println("2|3 =", 2|3)
fmt.Println("2^3 =", 2^3)
-2^2
- golang中有2个位移运算符：
`>>、<< 右移和左移，运算规则：
右移运算符 >>：低位溢出，符号位不变，并用符号位补溢出的高位
左移运算符 <<：符号位不变，低位补 0
第五章 流程控制
5.1流程控制的介绍
在程序中，程序运行的流程控制决定程序是如何执行的，是必须掌握的，主要有三大流程控制语句。
- 顺序控制
- 分支控制
- 循环控制
5.2顺序控制
顺序控制的介绍
- 程序从上到下逐行地执行，中间没有任何判断和跳转
顺序控制的流程图
顺序变量的举例和注意事项
Golang中定义变量时采用合法的前向引用。如：
func main(){
var num1 int = 10 //声明了num1
var num2 int = num1 + 20 //使用num1
fmt.Println(num2)
}
//错误形式
func main(){
var num2 int = num1 + 20
var num1 int = 10 //应当先声明再使用
fmt.Println(num2)
}
5.3分支控制 if-else
分支控制 if-else的介绍
让程序有选择的执行，分支控制有三种：
- 单分支
- 双分支
- 多分支
单分支
- 基本语法
if 条件表达式{
执行代码块
}
说明：当条件表达式为true时，就会执行{}的代码。
注意：{}必须存在。
package main
import "fmt"
func main() {
//输入年龄，如果大于18输出“你年龄大于18，要对自己负责哦”
var age int //定义年龄
fmt.Println("请输入年龄：")
fmt.Scanln(&age)//通过控制台输入年龄
if age > 18 {
fmt.Println("你年龄大于18，要对自己负责哦")
}
}
单分支语句流程图
说明：golang支持在if中，直接定义一个变量
if age := 20; age > 18{
fmt.Println("你年龄大于18，要对自己负责哦")
}
双分支
- 基本语法
if 条件表达式{
执行代码块1
}else{
执行代码块2
}
说明：当条件表达式成立，即执行代码块1，否则执行代码块2。其中{}也是必须的。 - 应用案例
package main
import "fmt"
func main() {
//输入年龄，如果大于18输出“你年龄大于18，要对自己负责哦”，如果年龄小于18则输出“年龄小于18”
var age int //定义年龄
fmt.Println("请输入年龄：")
fmt.Scanln(&age)//输入年龄
if age > 18 {
fmt.Println("你年龄大于18，要对自己负责哦")
}else {
fmt.Println("年龄小于18")
}
}
- 双分支对应的流程图
强调：双分支只会执行其中一个分支。
多分支
- 基本语法
if条件表达式1{
执行代码块1
} else if 条件表达式2 {
执行表达块2
}
…… //else if 可以有多个
else {
执行表达块n
} - 对上面基本语法的说明
- 多分支的判断流程是
（1）先判断条件表达式1是否成立，如果为true，就执行代码块1
（2）如果条件表达式1为false，就判断条件表达式2是否成立，如果条件表达式2为真，就执行代码块2
（3）以此类推
（4）如果所有的条件表达式都不成立，则执行else中的语句块。 - else不是必须的
- 多分支只能有一个执行入口
- 多分支流程图
嵌套分支
- 基本介绍
在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支结构称为内层分支，外面的分支结构称为外层分支。 - 基本语法
if条件表达式{
if条件表达式{
}else{
}
}
说明：嵌套分支不宜过多，建议控制在三层内。 - 应用案例1
参加百米运动会，如果用时8秒以内进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。输入成绩和性别。
package main
import "fmt"
func main() {
//参加百米运动会，如果用时8秒以内进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。输入成绩和性别。
//定义变量接收秒数 float64
//定义变量接收性别 string
var second float64
fmt.Println("请输入秒数")
fmt.Scanln(&second)
if second <= 8 {
var sex string
fmt.Println("请输入性别")
fmt.Scanln(&sex)
if sex == "男" {
fmt.Println("进入男子组决赛")
} else {
fmt.Println("进入女子组决赛")
}
} else {
fmt.Println("out...")
}
}
- 应用案例二
package main
import "fmt"
func main() {
//定义变量输入月份，定义年龄
var month byte
var age byte
var price float64 = 60.0
fmt.Println("请输入游玩月份")
fmt.Scanln(&month)
fmt.Println("请输入游客年龄")
fmt.Scanln(&age)
if month >= 4 && month <= 10 {
if age > 60 {
fmt.Printf("%v 月 票价 %v 年龄 %v", month, price/3, age)
} else if age >= 18 {
fmt.Printf("%v 月 票价 %v 年龄 %v", month, price, age)
} else {
fmt.Printf("%v 月 票价 %v 年龄 %v", month, price/2, age)
}
} else {
if age >= 18 && age < 60 {
fmt.Println("淡季，成人票价40")
} else {
fmt.Println("淡季，老人和儿童票价20")
}
}
}
switch 分支语句
- 基本介绍
- switch语句用于基于不同条件执行不同动作，每一个case分支都是唯一的，从上到下逐一测试，直到匹配位置
- 匹配项后面不需要加break
- 基本语法
switch 表达式{
case 表达式1，表达式2，…：
语句块1
case表达式3，表达式4，…:
语句块2
//case语句可以有多个
default:
语句块
} - switch流程图
- 对上图的总结说明
- switch的执行的流程是，先执行表达式，得到值，然后和case的表达式进行比较，如果相等，就匹配到，然后执行对应的case的语句块，然后退出switch控制。
- 如果switch的表达式的值没有和任何的case的表达式匹配成功，则执行default的语句块。执行后退出switch的控制
- golang中的case的表达式可以有多个，使用逗号间隔。
- golang中的case语句块不需要写break，因为默认会有，即在默认情况下，当程序执行完case语句块后，就直接退出该switch控制结构。
- 快速入门案例
请编写一个程序，该程序可以接收一个字符，比如：a,b,c,d,e,f,ga表示星期一，b表示星期二根据用户的输入显示相依的信息.要求使用switch语句完成
package main
import "fmt"
func main() {
//定义变量输入月份，定义年龄
var key byte
fmt.Println("请输入一个字符 a,b,c,d,e,f,g")
fmt.Scanf("%c", &key)
switch key {
case 'a':
fmt.Println("周一")
case 'b':
fmt.Println("周二")
case 'c':
fmt.Println("周三")
case 'd':
fmt.Println("周四")
case 'e':
fmt.Println("周五")
case 'f':
fmt.Println("周六")
case 'g':
fmt.Println("周日")
default:
fmt.Println("输入有误...")
}
}
- switch的使用的注意事项和细节
- case/switch后是一个表达式（即：常量值、变量、一个有返回值的函数等都可以）
- case后的各个表达式的值的数据类型，必须和switch的表达式数据类型一致
- case后面可以带多个表达式，使用逗号间隔。比如case表达式1，表达式2…
- case后面的表达式如果是常量值（字面量），则要求不能重复
- case后面不需要带break,程序匹配到一个case后就会执行对应的代码块，然后退出switch,如果一个都匹配不到，则执行default
- default语句不是必须的.
- switch后也可以不带表达式，类似if-else分支来使用。
- switch后也可以直接声明/定义一个变量，分号结束，不推荐。
- switch穿透-fallthrough,如果在case语句块后增加fallthrough,则会继续执行下一个case,也叫switch穿透
- Type Switch:switch语句还可以被用于ype-switch来判断某个interface变量中实际指向的
变量类型
- switch和if的比较
总结了什么情况下使用switch，什么情况下用if- 如果判断的具体数值不多，而且符合整数、浮点数、字符、字符串这几种类型。建议使用switch语句，简洁高效。
- 其他情况：对区间判断和结果都为bool类型的判断，使用if，if的使用范围更广。
for循环控制
- for循环的基本语法
- 语法格式
for循环变量初始化；循环条件；循环变量迭代{
循环操作（语句）
} - 对上面的语法格式说明
- 循环变量初始化
- 循环条件
- 循环操作（语句），有人也叫循环体
- 循环变量迭代
- for循环执行的顺序说明
- 执行循环变量初始化，比如 i:=1
- 执行循环条件，比如i<=10
- 如果循环条件为真，就执行循环操作：比如fmt.Println(“…”)
- 执行循环变量迭代，比如i++
- 反复执行2,3,4步骤，直到循环条件False，就退出for循环。
- for循环执行流程分析
- for循环的使用注意事项和细节
- 循环条件是返回一个布尔值的表达式
- for循环的第二种表达方式
for 循环判断条件{
//循环执行语句
}
景变量初始化和变量迭代写到其它位置 - for循环的第三种使用方式
for {
// 循环执行语句
}
上面的写法等价for ;;{} 是一个无限循环，通常需要配合break语句使用 - golang提供for-range的方式，可以方便遍历字符串和数组
while和do…while的实现
go语言没有while和do…while语法，可以通过for循环来实现其使用效果
- while循环的实现
循环变量初始化
for{
if循环条件表达式{
break//跳出for循环…
}
循环操作（语句）
循环变量迭代
}
说明：
- for循环是一个无限循环
- break语句目的是跳出for循环
使用实现输出10句"hello"
func main(){
var i int = 1
for{
if i > 10
break
}
fmt.Println("hello", i)
i++
}
fmt.Println("i=", i)
- do…while的实现
循环变量初始化
for{
循环操作（语句）
循环变量迭代
if循环条件表达式{
break//跳出for循环…
}
}
说明：
- 上面的循环是先执行，在判断，因此执行一次。
- 当循环条件成立后，就会执行break，break就是跳出for循环，结束循环
多重循环控制
- 基本介绍
- 将一个循环放在另一个循环体内，就形成了嵌套循环。在外边的for称为外层循环，在里面的for循环称为内层循环
- 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完成跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
- 外层循环次数为m次，内层为n次，则内层循环体水上需要执行m*n次
- 应用案例
- 统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成
绩从键盘输入]
package main
import "fmt"
func main() {
//1)统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成
//绩从键盘输入]
var classNum int = 3
var stuNum int = 5
var allScore float64 = 0.0
for j := 1; j <= classNum; j++ {
sum := 0.0
for i := 1; i <= stuNum; i++ {
var score float64
fmt.Printf("请输入第 %d 班 第 %d 个学生的成绩 \n", j, i)
fmt.Scanln(&score)
sum += score
}
fmt.Printf("第 %d 个班级的平均分是 %v\n", j, sum/float64(stuNum))
allScore += sum
}
fmt.Printf("各个班级的总成绩为 %v 所有班级的平均分是 %v", allScore, allScore/float64(stuNum*3))
}
- 统计三个班的及格人数，每个班有五人
package main
import "fmt"
func main() {
//1)统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成
//绩从键盘输入]
//2)统计三个班的及格人数，每个班有五人
var classNum int = 3 //定义班级数量
var stuNum int = 5 //定义每班人数
var allScore float64 = 0.0 //定义总成绩
var passScore float64 = 60.0 //定义及格分数
var passCount int = 0 //定义及格人数
for j := 1; j <= classNum; j++ {
sum := 0.0
for i := 1; i <= stuNum; i++ {
var score float64
fmt.Printf("请输入第 %d 班 第 %d 个学生的成绩 \n", j, i)
fmt.Scanln(&score)
if score >= passScore { //判断及格人数
passCount++ //及格人数累加
}
//累计总分
sum += score
}
fmt.Printf("第 %d 个班级的平均分是 %v\n", j, sum/float64(stuNum))
allScore += sum
}
fmt.Printf("各个班级的总成绩为 %v 所有班级的平均分是 %v 三个班总体及格人数是 %v", allScore, allScore/float64(stuNum*3), passCount)
}
- 打印金字塔
var totalLevel int = 20
//i表示层数
for i := 1; i <= totalLevel; i++ {
//在打印*前需要先打印空格，空格=总层数-当前层数
for j := 1; j <= totalLevel-i; j++ {
fmt.Print(" ")
}
//k表示每层需要打印多少个*
for k := 1; k <= 2*i-1; k++ {
if k == 1 || k == 2*i-1 || i == totalLevel {
fmt.Print("*")
} else {
fmt.Print(" ")
}
}
fmt.Println()
}
- 打印九九乘法表
var totalLevel int = 9
for i := 1; i <= totalLevel; i++ {
for j := 1; j <= i; j++ {
fmt.Printf("%v * %v = %v \t", j, i, j*i)
}
fmt.Println()
}
跳转控制语句-break
- 基本介绍
break语句用于终止某个语句块的执行，用于中断当前for循环或跳出switch语句。 - 案例演示
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
var count int = 0
for {
rand.NewSource(time.Now().Unix())
n := rand.Intn(100) + 1
fmt.Println("n=", n)
count++
if n == 99 {
break //跳出for循环
}
}
fmt.Println("生成99一共使用了", count)
}
在代码实现过程中，遇到了引包失败的情况，原因是：最新的go1.20与idea的版本匹配问题，最好使用2022版idea。
- 基本语法：
{
…
break
…
} - for循环为例，break的示意图
- break的注意事项和使用说明
- break语句出现在多层嵌套的语句块中时，可以通过标签知名要终止的是哪一层语句块
- 基本使用：
label1:{ ……
label2: { ……
label3: { ……
break label2;
……
}
}
}
- 案例说明
package main
import "fmt"
func main() {
label2:
for i := 0; i < 4; i++ {
//label1:
for j := 0; j < 10; j++ {
if j == 2 {
break label2
}
fmt.Println("j = ", j)//输出0，1
}
}
}
说明：
- break默认会跳出最近的for循环
- break可以配合label使用，可以跳出标签对应的for循环。
跳转控制语句-continue
- 基本介绍
- continue语句用于结束本次循环，执行下一次循环
- continue语句出现在多层嵌套的循环语句体中时，可以通过标签指名要跳过的是哪一层循环。
- 基本语法
{ ……
continue;
……
} - continue的流程图
- continue练习
- continue实现打印1一一l00之内的奇数[要求使用for循环+continue]
package main
import "fmt"
func main() {
for i := 1; i <= 100; i++ {
if i%2 == 0 {
continue
}
fmt.Println("奇数是", i)
}
}
- 从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序
package main
import "fmt"
func main() {
//从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序
var positiveCount int //正数个数
var negativeCount int //负数个数
var num int
for {
fmt.Println("请输入一个整数")
fmt.Scanln(&num)
if num == 0 {
break//输入0时结束程序
}
if num > 0 {
positiveCount++//正数个数总和
continue
}
negativeCount++//负数个数总和
}
fmt.Printf("正数的个数是%v 负数的个数是%v\n", positiveCount, negativeCount)
}
某人有100,000元，每经过一次路口，需要交费，规则如下：
当现金>50000时，每次交5%
当现金<=50000时，每次交1000
编程计算该人可以经过多少次路口，使用for break方式完成
package main
import "fmt"
func main() {
//某人有100,000元，每经过一次路口，需要交费，规则如下：
//当现金>50000时，每次交5%
//当现金<=50000时，每次交1000
//编程计算该人可以经过多少次路口，使用for break方式完成
var money float64 = 100000
var sum int
for {
if money > 50000 {
money -= money * 0.05
} else if money <= 50000 && money >= 1000 {
money -= 1000
} else {
break
}
sum++
}
fmt.Printf("该人可以经过%d次路口,还剩%v元", sum, money)
}
输出结果
跳转控制语句-goto
- 介绍
- go语言的goto语句可以无条件地转移到程序中指定的行
- goto语句通常与条件语句配合使用。可以用来 实现条件转移，跳出循环体等功能
- 在Go程序设计中一般不主张使用goto语句，以免造成流程的混乱，是理解和调试程序都产生困难。
- 基本语法：
goto label
…
label:statement
跳转控制语句-return
- 介绍：
return使用在方法 或者函数中，表示跳出所在的方法或者函数。
说明：
- 如果return是在普通的函数，则表示跳出该函数，即不再执行函数中return后面的代码，可理解成终止函数
- 如果return是在main函数，则表示，终止main函数，也就是终止程序。
扫一扫
1454
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
