Golang基础-流程控制

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块

控制语句分为三大类：顺序、选择、循环

一、分支结构

if分支结构

单分支

基础语法

if 条件表达式{
    逻辑代码块
}

完整代码：

package main

import "fmt"

// 单分支
func main() {
	// 实现功能：如果口罩库存少于30，提示库存不足
	var count int = 20
	// if 表达式返回结果一定是 true或者 false
	if count < 30 {
		fmt.Println("口罩库存不足")
	}
	
}

双分支

基础语法

if 条件表达式{
    逻辑代码块1
}else{
    逻辑代码块2
}

完整代码：

package main

import "fmt"

// 双分支

func main() {
	// 实现功能：如果口罩库存少于30，提示库存不足;如果大于30，提示库存充足
	var count int = 100

	if count < 30 {
		fmt.Println("库存不足")
	} else {
		fmt.Println("库存充足")
	}
}

多分支

基础语法

if 条件表达式1 {
    逻辑代码块1
}else if 条件表达式2{
    逻辑代码块2
}
…………
else{
    逻辑代码块n
}

完整代码：

package main

import "fmt"

// 多分支

func main() {
	// 实现功能：根据学生给出的分数，判断学生等级
	// A：>=90，B：>=80，C：>=70，D：>=60，E：<60
	
	// 定义成绩变量 score
	var score float32
	// 提示用户输入
	fmt.Print("请输入分数：")
	// 使用 Scanln 接收用户输入的数据
	fmt.Scanln(&score)
	// if语句判断
	if score >= 90 {
		fmt.Println("你的成绩等级为 A")
	} else if score >= 80 {
		fmt.Println("你的成绩等级为 B")
	} else if score >= 70 {
		fmt.Println("你的成绩等级为 C")
	} else if score >= 60 {
		fmt.Println("你的成绩等级为 D")
	} else {
		fmt.Println("你的成绩等级为 E")
	}
}

switch

基本语法

switch 表达式{
     case 值1,值2,……
         语句块1
     case 值3,值4,……
         语句块2
     default:
         语句块
}

完整代码：

package main

import "fmt"

func main() {
	// switch 分支

	// 实现功能：根据学生给出的分数，判断学生等级
	// A：>=90，B：>=80，C：>=70，D：>=60，E：<60

	var score int = 87
	// 根据分数判断等级
	switch score / 10 {
	case 10:
		fmt.Println("你的成绩等级为 A")
	case 9:
		fmt.Println("你的成绩等级为 A")
	case 8:
		fmt.Println("你的成绩等级为 B")
	case 7:
		fmt.Println("你的成绩等级为 C")
	case 6:
		fmt.Println("你的成绩等级为 D")
	case 5:
		fmt.Println("你的成绩等级为 E")
	case 4:
		fmt.Println("你的成绩等级为 E")
	case 3:
		fmt.Println("你的成绩等级为 E")
	case 2:
		fmt.Println("你的成绩等级为 E")
	case 1:
		fmt.Println("你的成绩等级为 E")
	case 0:
		fmt.Println("你的成绩等级为 E")
	default:
	    fmt.Println("成绩有误")

	}
}

二、循环结构

for循环

基础语法

for (初始表达式;布尔表达式;迭代因子){
     循环体
}

for 循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构

完整代码：

package main

import "fmt"

func main() {
	// 实现功能：求和：1+2+3+4+5

	// 定义一个相加和的变量
	var sum int
	// i := 1  // 初始化表达式
	// i < 6   // 布尔表达式
	// i++ 	   // 迭代因子
	for i := 1; i < 6; i++ {
		fmt.Printf("i的值为: %v\n", i)
		sum += i
	}
	fmt.Printf("总和为: %v\n", sum)

}
/*
运行结果:
    i的值为: 1
    i的值为: 2
    i的值为: 3
    i的值为: 4
    i的值为: 5
    总和为: 15
*/

// 注意事项：for的初始表达式，不能使用var定义变量，需要使用 :=

格式灵活

package main

import "fmt"

func main(){
    i := 1 // 初始化表达式
    for i < 5 { // 布尔表达式
        fmt.Println("Hello,Golang!")
        i++ // 迭代
    }
}

死循环

package main

import "fmt"

func main(){
    // 方式1
    for {
        fmt.Println("Hello,Golang")
    }
    // 方式2
    for ;; {
        fmt.Println("Hello,Golang")
    }
}

for range循环

for range 结构是Go语言特有的一种的迭代结构，在许多情况下都非常有用

for range 可以遍历数组、切片、字符串、map 及通道

for range 语法上类似于其它语言中的 foreach 语句，一般形式为：

for key,value range coll{
  ...
}

完整代码

package main

import (
	"fmt"
)

func main() {
	// 定义一个字符串
	var str string = "Hello,Golang"

	// 普通for循环: 按照字节遍历输出
	for i := 0; i < len(str); i++ {
		fmt.Printf("%c\n", str[i])
	}

	// for range 循环：对str进行遍历，
	// 遍历的每个索引值被k接收
	// 每个结果的具体数值被v接收
	for k, v := range str {
		fmt.Printf("K的值为: %v\n", k)
		fmt.Printf("V的值为: %c\n", v)
	}
}

三、关键字

break

package main

import "fmt"

func main() {
	// 求1-100的和，当和第一次超过300的时候停止程序
	var sum int = 0
	for i := 1; i <= 100; i++ {
		sum += i
		fmt.Println(sum)
		if sum >= 300 {
			// 跳出当前循环
			break
		}
	}
	fmt.Println("End……")

}

1.switch分支中,每个case分支后都用break结束当前分支,在go语言中break可以省略不写

2.break可以结束正在执行的循环

双重循环

break 结束离它最近的循环

package main

import "fmt"

func main() {
	// 双重循环
	for i := 1; i <= 5; i++ {
		for j := 2; j <= 4; j++ {
			fmt.Printf("i: %v , j: %v\n", i, j)
			if i == 2 && j == 2 {
				break
			}
		}
	}
}

标签的使用：

package main

import "fmt"

func main() {
	// 双重循环
lable2: // 定义标签
	for i := 1; i <= 5; i++ {
		//lable1:
		for j := 2; j <= 4; j++ {
			fmt.Printf("i: %v , j: %v\n", i, j)
			if i == 2 && j == 2 {
				break lable2  // 跳转到标签 lable2，结束外层循环
			}
		}
	}
}

continue

结束本次循环，继续下一次循环

package main

import "fmt"

func main() {
	// 输出 1-100中被6整除的数字

	// 方式1：
	for i := 1; i <= 100; i++ {
		if i%6 == 0 {
			fmt.Println(i)
		}
	}
	// 方式2：
	for i := 1; i <= 100; i++ {
		if i%6 != 0 {
			continue // 结束本次循环，继续下一次循环
		}
		fmt.Println(i)
	}
}

goto

Golang 中 goto 语句可以无条件地转移到程序中指定的行

goto 语句通常与条件语句配合使用。可以用来实现条件转移

在 Go 程序中一般不建议使用 goto 语句，以免造成程序流程的混乱

package main

import "fmt"

func main() {
	fmt.Println("Hello,goto1!")
	goto label1
	fmt.Println("Hello,goto2!")
	fmt.Println("Hello,goto3!")
	fmt.Println("Hello,goto4!")
	fmt.Println("Hello,goto5!")
	fmt.Println("Hello,goto6!")
	label1:
	fmt.Println("Hello,goto7!")
	fmt.Println("Hello,goto8!")

}

// 运行结果：
//    Hello,goto1!
//    Hello,goto7!
//    Hello,goto8!

return

结束当前函数

package main

import "fmt"

func main() {

	for i := 1; i <= 100; i++ {
		fmt.Println(i)
		if i == 20 {
			return // 结束当前函数
		}
	}

	fmt.Println("End……")
}
/*
运行结果：
    1
    2
    3
    4
    ……
    20
*/