Go语言入门之流程控制简述

Go语言入门之流程控制简述

1.if语句

if语句和其他语言一样，只不过go语言的if不需要用括号包裹

if 语句的分支代码块的左大括号与 if 关键字在同一行上，这是 go 代码风格的统一要求

简单实例：

func main() {
    // 猜数字
    a := 2
	if a > 0 {
		if a > 3 {
			fmt.Println("数字过大")
		} else if a == 1 {
			fmt.Println("再大一点")
		} else if a == 2 {
			fmt.Println("再大一点")
		} else if a == 3 {
			fmt.Println("猜对了")
		}
	} else {
		fmt.Println("数字过小")
	}
}
// 输入的是2，输出的结果是：再大一点

if语句的特殊写法

if 条件判断还有一种特殊的写法，可以在 if 表达式之前添加一个执行语句，再根据变量值进行判断

// 特殊写法，这种写法将a的作用范围限制在if表达式中
if a := 10; a >5 {
    fmt.Println(a)
    return
}

2.for语句

go语言只支持for循环，没有while

（1）for语句的7种用法

第一种：普通写法

sum := 0
for i := 0; i < 10; i++ {
    sum += i
}

第二种：无限循环

for{
    // 无限循环代码块
}

第三种：for后只写条件

n := 0
// for后面只加条件 
for n < 3 {
		n++
}
fmt.Println(n)

第四种：for range 遍历切片

var slice []int = []int{1, 2, 3, 4, 5}
// for range循环切片或数组
for index, value := range slice {
	fmt.Printf("index:%d,value:%d \n", index, value)
}

第五种：for range 遍历字符串和整数

// 可以循环字符串 字符串底层为一个byte切片
// 字符串大小为16字节，其有一个指针和int型长度组成
for _, j := range "zhangsan" {
	fmt.Printf("%c \n", j)
}

// for range还可以遍历整数
for i := range 5 {
	fmt.Printf("%d", i+1)
}
// 打印结果：12345

第六种：遍历map

// 循环map
mmap := map[int]string{
	11: "hh",
	22: "ff",
	33: "ww",
}
for key, value := range mmap {
	fmt.Println(key, value)
}

第七种：for range 遍历channel

// 循环channel
chnl := make(chan int)
go func() {
	chnl <- 100
	chnl <- 1000
	chnl <- 10000
	chnl <- 100000
	close(chnl)
}()
for i := range chnl {
	fmt.Println(i)
}

（2）for语句的4种结束方法

第一种：return

func main() {
	step := 2
	for step > 0 {
		step--
		fmt.Println(step)
		//执行一次就结束了
		return
	}
	//不会执行
	fmt.Println("结束之后的语句....")
}

第二种：break

注意：go语言中break只能跳出一层for循环

func main() {
	step := 2
	for step > 0 {
		step--
		fmt.Println(step)
		//跳出循环,还会继续执行循环外的语句
		break
	}
	//会执行
	fmt.Println("结束之后的语句....")
}

第三种：panic

func main() {
	step := 2
	for step > 0 {
		step--
		fmt.Println(step)
		//报错了，直接结束
		panic("出错了")
	}
	//不会执行
	fmt.Println("结束之后的语句....")
}

第四种：goto

func main() {
	for x := 0; x < 10; x++ {
		if x == 2 {
			// 跳转到标签
			goto breakHere
		}
	}
	// 手动返回, 避免执行进入标签
	return
	// 标签
breakHere:
	fmt.Println("done")
}

3.switch语句

Go语言的switch同其他语言的差不多，使用 switch 语句可方便地对大量的值进行条件判断。

switch 分支表达式可以是任意类型，不限于常量。可省略 break，默认自动终止。

switch后如果没有表达式会对第一个true进行匹配

例子如下：

    // 成绩判定
    grade := "B"
    // 输入90
	var score int = 90

	switch score {
	case 90:
		grade = "A"
	case 80:
		grade = "B"
	case 50, 60, 70:
		grade = "C"
    // 无论 default出现在什么位置，它只会在所有case都没有匹配上的情况下才会被执行
	default:
		grade = "D"
	}
	fmt.Println(grade)

//结果是：A

注意：

Go里面switch默认相当于每个case最后带有break

匹配成功后不会自动向下执行其他case，而是跳出整个switch

如果需要执行完一个case之后，进入下一个case不跳出swtich

这就需要用到fallthrough，无论如何都会进入下个case

a := "hello"
	switch {
	case a == "hello":
		fmt.Print("hello ")
		fallthrough
	case a == "world":
		fmt.Println("world")
	}
//打印结果：hello world

4.goto语句

goto 语句通过标签进行代码间的无条件跳转

goto 语句可以实现快速跳出循环、避免重复退出

因此 goto 语句能简化一些代码的实现过程

func main() {
	if 20 > 10 {
		goto GotoTag1
	}
	return
GotoTag1:
	fmt.Println("tag1")
	if 10 > 5 {
		goto GotoTag2
	}
	return
GotoTag2:
	fmt.Println("tag2")
}

5.break语句

break 语句可以结束 for、switch 和 select 的代码块

break 语句还可以在语句后面添加标签，表示退出某个标签对应的代码块

标签要求必须定义在对应的 for、switch 和 select 的代码块上。

func main() {
OuterLoop:
    for i := 0; i < 2; i++ {
        for j := 0; j < 5; j++ {
            switch j {
            case 2:
                fmt.Println(i, j)
                break OuterLoop
            case 3:
                fmt.Println(i, j)
                break OuterLoop
            }
        }
    }
}

6.continue语句

continue 语句可以结束当前循环，开始下一次的循环迭代过程

仅限在 for 循环内使用

在 continue 语句后添加标签时，表示开始标签对应的循环

func main() {
OuterLoop:
    for i := 0; i < 2; i++ {
        for j := 0; j < 5; j++ {
            switch j {
            case 2:
                fmt.Println(i, j)
                continue OuterLoop
            }
        }
    }
}