盐析白兔

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

热门标签

【GO语言卵细胞级别教程】03.条件与循环语句

作者：盐析白兔 | 2024-02-16 01:14:27

踩

注意：以下演示所用的项目，在第一章节已经介绍了，这里不做赘述

【GO语言卵细胞级别教程】03.条件与循环语句

1.条件语句

1.1 if语句

1.1.1 单层if语句

语法

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

案例

package tiaojian

// if单层
import "fmt"

func OneIf(){
	var num int
	fmt.Print("请输入一个数字:")
	fmt.Scan(&num)
	if num == 100{
		fmt.Println("满分100！")
	}
	fmt.Println("程序执行完！")
	
}
// 输出结果
开始运行：
当前机器状态： 正常
请输入一个数字:100
满分100！
程序执行完！
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

1.1.2 if-else语句

语法

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
} else {
  /* 在布尔表达式为 false 时执行 */
}
1
2
3
4
5

案例

package tiaojian
// if-else 语句
import "fmt"

func IfElse(){
	var num int
	fmt.Println("请输入一个数字：")
	fmt.Scan(&num)
	if num > 2023 {
		fmt.Println("恭喜您！2024新年好")
	}else{
		fmt.Println("2023辞旧迎新！")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

1.1.3 if-else-if 语句

语法

if 布尔表达式1 {

}else if 布尔表达式{

}
1
2
3
4
5

实战

package tiaojian
// if-else 语句
import "fmt"

func IfElse(){
	var num int
	fmt.Println("请输入一个数字：")
	fmt.Scan(&num)
	if num > 2023 {
		fmt.Println("恭喜您！2024新年好")
	}else if num == 2024{
		fmt.Println("2023辞旧迎新！")
	}else {
		fmt.Println("读懂《遥远的救世主》：不去讨好生活，生活有时候会反")
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1.1.4 if 嵌套

语法：用户输入值有两个方法
（1）使用fmt.Scanf(“%d”, &age)
（2）使用fmt.Scan(&age)

if 布尔表达式1 {
   /* 在布尔表达式 1 为 true 时执行 */
   if 布尔表达式2 {
      /* 在布尔表达式 2 为 true 时执行 */
   }
}
1
2
3
4
5
6

实战

package tiaojian
// if-else 语句
import "fmt"

func IfElse(){
	var num int
	fmt.Println("请输入一个数字：")
	fmt.Scan(&num)
	if num > 2023 {
		fmt.Println("恭喜您！2024新年好")
	}else if num == 2024{
		fmt.Println("2023辞旧迎新！")
	}else {
		if num == 1{
			fmt.Println("袈裟本无清静，红尘不染性空，幽幽古刹千年钟，都是痴人说梦")
		}
		fmt.Println("读懂《遥远的救世主》：不去讨好生活，生活有时候会反")
	}
}
// 运行结果
开始运行：
当前机器状态： 正常
请输入一个数字:1
程序执行完！
请输入一个数字：
1
袈裟本无清静，红尘不染性空，幽幽古刹千年钟，都是痴人说梦
读懂《遥远的救世主》：不去讨好生活，生活有时候会反
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

实战

package tiaojian

// 条件语句

import "fmt"

func Tiaojian(){
	var a1 int = 1
	var a2 int = 2
	fmt.Printf("a1=%v, a2=%v\n", a1, a2)
	if a1 < a2 {
		fmt.Println("a1 < a2")
	}else{
		fmt.Println("a1 > a2")	
	}
	// 使用scanf 输入一个值
	var pwd string = ""
	fmt.Print("请输入密码：")
	fmt.Scanf("%v", &pwd)
	fmt.Println(a1)
	if pwd == "001"{
		fmt.Println("密码输入正确！！")
		fmt.Println("获取新的技能：重锤火花")
		fmt.Println("经验提升：88")
		fmt.Println("获取金钱：88888888")
	}else{
		fmt.Println("密码输入错误！！")
		fmt.Println("金钱扣除：80")
	}
	// 使用
	fmt.Print("请再输入一个：")
	fmt.Scan(&a1)
	fmt.Println(a1)
}
// 执行结果
运行结果：
当前状态： 19
a1=1, a2=2
a1 < a2
请输入密码：001
1
密码输入正确！！
获取新的技能：重锤火花
经验提升：88
获取金钱：88888888
请再输入一个：20
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

1.2 switch 语句

switch 后是一个表达式（变量、常量、一个有返回值的函数等都可以）
case后面的表达式如果是常量值（字面量）则要求不能重复
case后面的各个值得数据类型必须和switch一致
case后面可以多个值使用逗号分割，比如case 值1,值2……
case后面不需要带break go语言不需要，想要无条件执行下一句需要使用fallthrough
default 语句不是必须的，位置也是可以在任何地方
switch后也可以不带表达式，当作if分支来使用
switch后也可以直接声明/定义一个变量，分号结束，需要使用num:=xxx得方式声明；
switch 穿透利用fallthrough 关键字，如果在case 语句块后增加fallthrough，则会继续执行下一个case

1.1.1 switch-case

语法
其中表达式可以是：一个常量值、变量或者有返回值的函数都可以

switch 表达式 {
    case 值1, 值2:
		语句1
    case 值1, 值2:
		语句2
    case 值1, 值2:
		语句3
	 default:
	    语句4
}
1
2
3
4
5
6
7
8
9
10

实战：switch后面直接大括号

package tiaojian
// switch 语句
import "fmt"

func DemoSwitch(){
	var num int
	fmt.Print("请输入一个num:")
	fmt.Scan(&num)
	switch {
		case num >= 0 && num < 60:
			fmt.Println("还得继续加油！:", num)
			fallthrough
		case num >= 60 && num < 70:
			fmt.Println("恭喜您，及格了！:", num)
		case num >= 70 && num < 80:
			fmt.Println("恭喜您，良好了！:", num)
		case num >= 80 && num < 90:
			fmt.Println("恭喜您，优秀了！:", num)
		default:
			fmt.Println("满分？", num)
	}
}
// 输出结果
开始运行：
当前机器状态： 正常
请输入一个num:12
还得继续加油！: 12
恭喜您，及格了！: 12
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

注意，其中fallthrough 表示无条件执行下一个case，也就是无论下一条语句执行的是true还是false都会执行。
2. 实战：switch 后面跟变量

package tiaiojian
import "fmt"
func SwitchVar{
	var num int 
    fmt.Scan(&num)
     switch num{
         case 60:
           fmt.Println("及格了", num)
         case 80:
           fmt.Println("良好了", num)
	     default:
	       fmt.Println("还能满分么！", num)
     }
}

// 直接固定一个值也是也可以，直接固定60比如
package tiaojian

import "fmt"

func SwitchVar(){
	var num int
	fmt.Scan(&num)
	switch 60{
		case 60:
			fmt.Println("恭喜您，及格了！")
		case 80:
			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
31
32

实战：switch 后是一个表达式（变量、常量、一个有返回值的函数等都可以）

package tiaojian

import "fmt"

func SwitchVar(){
	var num int
	fmt.Scan(&num)
	fmt.Println("测试固定得值")
	switch 60{
		case 60:
			fmt.Println("固定的值60")
		default:
			fmt.Println("没有值")
	}
	const STATUS int = 100
	switch STATUS{
		case 100:
			fmt.Println("满分100！")
		default:
			fmt.Println("没有值")
	}
}
// 结果
测试固定得值
固定的值60

// 定义一个带有返回值的函数
package tiaojian

import "fmt"

func returnInt() int {
	return 70
}

func SwitchVar(){
	var num int
	fmt.Scan(&num)
	switch returnInt(){
		case 70:
			fmt.Println("函数返回值70")
		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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

实战： case后面的表达式如果是常量值（字面量）则要求不能重复
实战： case后面的表达式如果是常量值（字面量）则要求不能重复
实战：case后面可以多个值使用逗号分割，比如case 值1,值2……

switch 70 {
	case 60, 70, 8:
		fmt.Println("固定的值60")
	default:
		fmt.Println("没有值")
	}
1
2
3
4
5
6

实战：switch后也可以不带表达式，当作if分支来使用

switch {
	case num ==1:
		fmt.Println("这是可以当作if语句使用")
}
1
2
3
4

实战：switch后也可以直接声明/定义一个变量，分号结束，需要使用num:=xxx得方式声明；

switch test :=12; {
	case test == 12:
		fmt.Println("这是一个变量值等于12")
	case test > 12:
		fmt.Println("这个变量大于12")
}
1
2
3
4
5
6

1.1.2 总结

switch {} 括号里需要是布尔类型
switch test {}case后面需要是常量
无条件执行下一步使用fallthrough即可

package tiaojian

import "fmt"

func SwitchVar(){
	fmt.Println("------总结------")
	var num1 int =12
	// switch后面不跟值
	switch {
		case num1 == 12:
			fmt.Println("这是12")
		case num1 == 13:
			fmt.Println("这是13")
		default:
			fmt.Println("这是default")
	}
	// switch后面跟变量
	switch num1{
		case 12:
			fmt.Println("这是12")
		case 13:
			fmt.Println("这是13")
		default:
			fmt.Println("这是default")
	}
	// switch后面跟声明变量 相当于 var num2 int 13; switch {}
	switch num2:=13; {
		case num1 == 12:
			fmt.Println("这是12")
		case num2 == 12:
			fmt.Println("这是13")
		default:
			fmt.Println("这是default")
	}
}
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
32
33
34
35

1.3 常见错误

else必须要和中括号的反括号在一行

2.循环语句

2.1 循环语句for

解决的问题
如果有重复的值不断累加计算的话，比如从1+100 那么我要么写100个变量，相加。所以对这种循环可以使用for解决

var a1 int 1
var a2 int 2 
……
var a100 int 100
var sum int = a1+a2+……+a100
1
2
3
4
5

for语法
for 循环是一个循环控制结构，可以执行指定次数的循环。

// Like a C for
for init; condition; post { }

// Like a C while
for condition { }

// Like a C for(;;)
for { }
---------
翻译成中文就是
for 初始化语句；循环条件；后置语句{}


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

实战测试

package tiaojian
// for循环语句
import "fmt"

func DemoFor(){
	for i:=0; i < 10 ;i++{
		fmt.Println(i)
	}
}
输出结果：0 1 2 3 4 5 6 7 8 9
或者

package tiaojian
// for循环语句
import "fmt"

func DemoFor(){
    for i:=0; i < 10 ;i+=2{
        fmt.Println(i)
    }

}
输出结果：0 2 4 6 8
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2.2 For循环功能

for 在Go语言中可以当作while使用，因为Go语言中没有while关键词

for {
	fmt.Println("无限循环")
}
或者
for ;;{
	xxx
}
1
2
3
4
5
6
7

实战测试

package tiaojian
// for循环语句
import (
	"fmt"
	"time"
)

func DemoFor(){
	var count int = 0
	for i:=0; i < 10 ;i+=2{
		fmt.Println(i)
	}
	// 无限循环方法1
	fmt.Println("无限循环方法！")
	for {
		time.Sleep(1 * time.Second)
		fmt.Println("无限循环！1")
		count ++
		if count >=3 {
			break
		}
	}
	// 无限循环方法2
	for ;; {
		time.Sleep(1 * time.Second)
		fmt.Println("无限循环！2")
	}
}
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

2.3 for range遍历函数

简介
range关键字用于迭代数组（Array）、切片（Slice）、字符串（String）、映射（Map）、通道（Channel）等数据结构。它提供了一种简洁的方式来遍历这些数据结构的元素。如果不使用range for就是按照那个字节输出，如果遇到中文就会有问题，因为中英文字节不一样。所以会乱码，使用range就是可以遍历完成的。
可以直接理解为
range xxx 返回值是一个下标和值
index,value = range xxx
实战

package tiaojian

import "fmt"

func DemoForRange(){
	var str string = "hello golang 你好"
	// 这里是按照字节遍历输出的
	for i :=0; i < len(str) ; i++{
		fmt.Printf("%c\n", str[i])
	}
	// 使用range函数
	for index, value := range str{
		fmt.Printf("index：%v, value=%c\n ", index, value)
	}
}
//输出结果
h
e
l
l
o

g
o
l
a
n
g

ä
½
 
å
¥
½
index：0, value=h
 index：1, value=e
 index：2, value=l
 index：3, value=l
 index：4, value=o
 index：5, value=
 index：6, value=g
 index：7, value=o
 index：8, value=l
 index：9, value=a
 index：10, value=n
 index：11, value=g
 index：12, value=
 index：13, value=你
 index：16, value=好
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

3.关键词

3.1 关键词break

简介
break的作用就是跳过循环
实战：实现一个累加，大于等于100就跳出循环

package tiaojian

import "fmt"

func DemoBreak(){
	sum := 0
	for i :=0; i < 100; i++{
		sum += i 
		if sum >= 100{
			fmt.Println("i=", i, "sum=", sum)
			break
		}else{
			fmt.Println("sum=", sum)
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.2 continue关键字

简介跳出本次循环，不影响下一次循环
实战

package tiaojian
// continue作用
import "fmt"

func DemoContinue(){
	for i:=0; i < 5; i ++{
		if i == 3 {
			fmt.Println("跳出本次循环：", i)
			continue
		}
		fmt.Println("i=",i)
	}
}
// 输出结果
开始运行：
当前机器状态： 正常
i= 0
i= 1
i= 2
跳出本次循环： 3
i= 4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3.3 goto关键字

可以转到程序中的指定的行
通常与条件语句搭配使用，可以来实现条件转移
在Go或者c语言程序设计中一般其实是不建议使用goto语句，以免造成程序流程的混乱，曾经在C中出现过goto危机

package tiaojian

// goto语句

import "fmt"

func DemoGoto(){
	fmt.Println("goto01")
	goto title1
	fmt.Println("goto02")
	fmt.Println("goto03")
	title1:
	fmt.Println("goto04")
	fmt.Println("goto05")
	fmt.Println("goto06")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.4 return关键词

用于提前结束函数

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}
1
2
3
4
5
6

返回结果，可以将函数的返回值给调用者

func add(a, b int) int {
    return a + b
}
1
2
3

4.题目

4.1 99乘法表

实现99乘法表

package tiaojian
// 99乘法表
import "fmt"

func Demo99(){
	for i := 1; i <=9; i++{
		for j:=1; j <=i; j++{
			fmt.Printf("%dx%d=%d ", j, i, i*j)
			if i == j{
				println()				
			}
		}
	}
}

// 输出结果
1x1=1
1x2=2 2x2=4
1x3=3 2x3=6 3x3=9
1x4=4 2x4=8 3x4=12 4x4=16
1x5=5 2x5=10 3x5=15 4x5=20 5x5=25
1x6=6 2x6=12 3x6=18 4x6=24 5x6=30 6x6=36
1x7=7 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49
1x8=8 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64
1x9=9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81
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

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

【GO语言卵细胞级别教程】03.条件与循环语句

目录：

【GO语言卵细胞级别教程】03.条件与循环语句

1.条件语句

1.1 if语句

1.1.1 单层if语句

1.1.2 if-else语句

1.1.3 if-else-if 语句

1.1.4 if 嵌套

1.2 switch 语句

1.1.1 switch-case

1.1.2 总结

1.3 常见错误

2.循环语句

2.1 循环语句for

2.2 For循环功能

2.3 for range遍历函数

3.关键词

3.1 关键词break

3.2 continue关键字

3.3 goto关键字

3.4 return关键词

4.题目

4.1 99乘法表