人工智能uu

这个屌丝很懒，什么也没留下！

热门标签

Golang学习笔记（2）_golang ++

作者：人工智能uu | 2024-07-05 13:14:38

踩

golang ++

第四章运算符

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)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

细节说明

关系运算符的类型都是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")
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

案例结果：
在这里插入图片描述

注意事项和细节说明

&&也叫短路与：如果第一个条件为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)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

赋值运算符的特点

运算顺序从右向左
赋值运算符的左边只能是变量，右边可以是变量、表达式、常量值
复合赋值运算等价于下面的效果
比如：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
10
11
12

运算符的优先级
运算符优先级一览表

运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
只有单目运算符、赋值运算符是从右向左运算的。
梳理了一个大概的优先级
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 实现基本的三元运算

1
2
3
4
5
6
7
8
9
10
11
12
13

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)
	

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

输出结果
案例演示：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)
}




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

输出结果

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)
1
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)
}
1
2
3
4
5
6
7
8
9
10
11

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，要对自己负责哦")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

单分支语句流程图
在这里插入图片描述

说明：golang支持在if中，直接定义一个变量

	if age := 20; age > 18{
		fmt.Println("你年龄大于18，要对自己负责哦")
	}
1
2
3

双分支

基本语法
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")
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

双分支对应的流程图

强调：双分支只会执行其中一个分支。

多分支

基本语法
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...")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

应用案例二

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")
		}
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

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("输入有误...")
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

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
1. 如果判断的具体数值不多，而且符合整数、浮点数、字符、字符串这几种类型。建议使用switch语句，简洁高效。
2. 其他情况：对区间判断和结果都为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)
1
2
3
4
5
6
7
8
9
10

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))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

统计三个班的及格人数，每个班有五人

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)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

打印金字塔

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()

	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

打印九九乘法表

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()
	}
1
2
3
4
5
6
7

跳转控制语句-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)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

在代码实现过程中，遇到了引包失败的情况，原因是：最新的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
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

说明：

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)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为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)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

某人有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)

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

输出结果
在这里插入图片描述

跳转控制语句-goto

介绍

go语言的goto语句可以无条件地转移到程序中指定的行
goto语句通常与条件语句配合使用。可以用来实现条件转移，跳出循环体等功能
在Go程序设计中一般不主张使用goto语句，以免造成流程的混乱，是理解和调试程序都产生困难。

基本语法：
goto label
…
label:statement

跳转控制语句-return

介绍：
return使用在方法或者函数中，表示跳出所在的方法或者函数。
说明：

如果return是在普通的函数，则表示跳出该函数，即不再执行函数中return后面的代码，可理解成终止函数
如果return是在main函数，则表示，终止main函数，也就是终止程序。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/人工智能uu/article/detail/790231

Golang学习笔记（2）_golang ++

第四章 运算符

4.1运算符的介绍

4.2算术运算符

4.3关系运算符（比较运算符）

4.4逻辑运算符

4.5赋值运算符

4.6位运算符

4.7其它运算符

4.8特别说明

4.9键盘输入语句

4.10进制

4.11位运算

第五章 流程控制

5.1流程控制的介绍

5.2顺序控制

顺序控制的介绍

顺序控制的流程图

顺序变量的举例和注意事项

5.3分支控制 if-else

分支控制 if-else的介绍

单分支

双分支

多分支

嵌套分支

switch 分支语句

for循环控制

while和do…while的实现

多重循环控制

跳转控制语句-break

跳转控制语句-continue

跳转控制语句-goto

跳转控制语句-return

第四章运算符

第五章流程控制