15.Golang流程控制

Leefs 2022-07-05 PM 964℃ 0条

[TOC]

### 前言

![15.Golang流程控制01.png](https://lilinchao.com/usr/uploads/2022/07/2025326434.png)

### 一、概述

流程控制是每种编程语言控制逻辑走向和执行次序的重要部分，流程控制可以说是一门语言的“经脉”。

**流程控制语句有三个作用：**

+ **选择**：根据条件跳转到不同的执行序列；
+ **循环**：根据条件反复执行某个序列；
+ **跳转**：据条件返回到某执行序列。

#### 流程控制语句类型

**Go语言支持如下的几种流程控制语句:**

+ **条件语句**：关键字为if、else和else if。
+ **选择语句**：关键字为switch、case和select。
+ **循环语句**：关键字为for和range。
+ **跳转语句**：关键字为goto。

在具体的应用场景中，为了满足更丰富的控制需求，Go语言还添加了如下关键字： `break` 、 `continue` 和 `fallthrough` 。

### 二、条件语句

Go语言中`if`条件判断的格式如下：

```go
if 条件1 {
  逻辑代码1
} else if  条件2 {
  逻辑代码2
} else if 条件 ... {
  逻辑代码 ...
} else {
  逻辑代码
}
```

如果分支的 `条件语句` 为真，则执行该分支 `{` 和 `}` 之间的代码。

在 Go 中，对于 `{` 和 `}` 的位置有严格的要求，它要求 `else if` (或 `else` ) 和两边的花括号，必须在同一行。

特别注意，即使在 `{` 和 `}` 之间只有一条语句，这两个花括号也是不能省略的。

+ **单分支判断**

只有一个 `if` 为单分支判断：

```go
  score := 65
  if score >= 60 {
      fmt.Println("成绩及格")
  }
  ```

+ **双分支判断**

有 `if` 和一个 `else` 为两分支判断：

```go
  score := 65
  if score >= 60 {
      fmt.Println("成绩及格")
  } else {
      fmt.Println("成绩不及格")
  }
  ```

+ **多分支判断**

有 `if` 、 `else if` 以及 `else` 为多分支判断：

```go
  score := 65
  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 成绩不及格")
  }
  ```

+ **条件语句高级写法**

`if` 还有另外一种写法，它包含一个 `statement` 可选语句部分，该可选语句在条件判断之前运行。它的语法是：

```go
  if statement; condition {
  }
  ```

上面单分支判断的那个例子可以重写如下：

```go
  if score := 65; score >= 60 {
      fmt.Println("成绩及格")
  }
  ```

### 三、选择语句

在 Go **选择语句表达式** 如下：

```go
switch 表达式 {
    case 表达式值1:
        业务逻辑代码1
    case 表达式值2:
        业务逻辑代码2
    case 表达式值3:
        业务逻辑代码3
    case 表达式值 ...:
        业务逻辑代码 ...
    default:
        业务逻辑代码
}
```

`switch` 语句是一个选择语句，用于将 `switch` 后的表达式的值与可能匹配的选项 `case` 后的表达式进行比较，并根据匹配情况执行相应的代码块，执行完匹配的代码块后，直接退出 `switch-case` 。

如果没有任何一个匹配，就会执行 `default` 的代码块。它可以被认为是替代多个 `if-else` 子句的常用方式。

注意：`case` 不允许出现重复项。

```go
grade := "B"
switch grade {
case "A":
    fmt.Println("Your score is between 90 and 100.")
case "B":
    fmt.Println("Your score is between 80 and 90.")
case "C":
    fmt.Println("Your score is between 70 and 80.")
case "D":
    fmt.Println("Your score is between 60 and 70.")
default:
    fmt.Println("Your score is below 60.")
}
```

**运行结果**

```
Your score is between 80 and 90.
```

+ **一个 case 多个条件**

在 Go 中， `case` 后可以接多个条件，多个条件之间是 **或** 的关系，用逗号 `,` 相隔。

```go
  month := 5
  switch month {
  case 1, 3, 5, 7, 8, 10, 12:
      fmt.Println("该月份有 31 天")
  case 4, 6, 9, 11:
      fmt.Println("该月份有 30 天")
  case 2:
      fmt.Println("该月份闰年为 29 天，非闰年为 28 天")
  default:
      fmt.Println("输入有误！")
  }
  ```

**运行结果**

```
  该月份有 31 天
  ```

+ **选择语句高级写法**

`switch` 还有另外一种写法，它包含一个 `statement` 可选语句部分，该可选语句在表达式之前运行。它的语法是：

```go
  switch statement; expression {
  }
  ```

可以将上面的例子改写为：

```go
  switch month := 5; month {
  case 1, 3, 5, 7, 8, 10, 12:
      fmt.Println("该月份有 31 天")
  case 4, 6, 9, 11:
      fmt.Println("该月份有 30 天")
  case 2:
      fmt.Println("该月份闰年为 29 天，非闰年为 28 天")
  default:
      fmt.Println("输入有误！")
  }
  ```

这里 `month` 变量的作用域就仅限于这个 `switch` 内。

+ **switch 后可接函数**

`switch` 后面可以接一个函数，只要保证 `case` 后的值类型与函数的返回值一致即可。

```go
  func getResult(args ...int) bool {
  	//遍历成绩,只要有一门课程成绩小于60就表示考试未通过
  	for _, v := range args {
  		if v < 60 {
  			return false
  		}
  	}
  	return true
  }
  
  func main() {
  	chinese := 88	//语文
  	math := 90		//数学
  	english := 95	//英语
  
  	switch getResult(chinese, math, english) {
  	case true:
  		fmt.Println("考试通过")
  	case false:
  		fmt.Println("考试未通过")
  	}
  }
  ```

+ **无表达式的 switch**

`switch` 后面的表达式是可选的。如果省略该表达式，则表示这个 `switch` 语句等同于 `switch true` ，并且每个 `case` 表达式都被认定为有效，相应的代码块也会被执行。

```go
  score := 65
  switch {
  case score >= 90 && score <= 100:
      fmt.Println("grade A")
  case score >= 80 && score < 90:
      fmt.Println("grade B")
  case score >= 70 && score < 80:
      fmt.Println("grade C")
  case score >= 60 && score < 70:
      fmt.Println("grade D")
  case score < 60:
      fmt.Println("grade E")
  }
  ```

**运行结果**

```
  grade D
  ```

该 `switch-case` 语句相当于 `if-else if-else` 语句。

+ **fallthrough 语句**

正常情况下 `switch-case` 语句在执行时只要有一个 `case` 满足条件，就会直接退出 `switch-case` ，如果一个都没有满足，才会执行 `default` 的代码块。

不同于其他语言需要在每个 `case` 中添加 `break` 语句才能退出。使用 `fallthrough` 语句可以在已经执行完成的 `case` 之后，把控制权转移到下一个 `case` 的执行代码中。

**`fallthrough` 只能穿透一层，不管你有没有匹配上，都要退出了。**

`fallthrough` 语句是 `case` 子句的最后一个语句。如果它出现在了 `case` 语句的中间，编译会不通过。

```go
  func main() {
  	s := "first"
  	switch {
  	case s == "first":
  		fmt.Println("第一")
  		fallthrough
  	case s == "second":
  		fmt.Println("第二")
  	case s != "third":
  		fmt.Println("第三")
  	default:
  		fmt.Println("结尾")
  	}
  }
  ```

**运行结果**

```
  第一
  第二
  ```

### 四、循环语句

**循环语句** 可以用来重复执行某一段代码。在 C 语言中，循环语句有 `for` 、 `while` 和 `do while` 三种循环。但在 Go 中只有 `for` 一种循环语句。

**下面是 `for` 循环语句的四种基本模型：**

```go
// for 接三个表达式
for initialisation; condition; post {
   code
}

// for 接一个条件表达式
for condition {
   code
}

// for 接一个 range 表达式
for range_expression {
   code
}

// for 不接表达式
for {
   code
}
```

**`for` 后面接的这三个表达式，各有各的用途：**

- 第一个表达式(`initialisation`)：初始化控制变量，在整个循环生命周期内，只执行一次；
- 第二个表达式(`condition`)：设置循环控制条件，该表达式值为 `true` 时循环，值为 `false` 时结束循环；
- 第三个表达式(`post`)：每次循环完都会执行此表达式，可以利用其让控制变量增量或减量。

这三个表达式，使用 `;` 分隔。

##### for range表达式

Go语言中可以使用`for range`遍历数组、切片、字符串、map 及通道（channel）。 通过`for range`遍历的返回值有以下规律：

1. 数组、切片、字符串返回索引和值。
2. map返回键和值。
3. 通道（channel）只返回通道内的值。

接下来对每一种模型进行讲解。

- **接一个条件表达式**

下面的例子利用 `for` 循环打印 `0` 到 `3` 的数值：

```go
  num := 0
  for num < 4 {
      fmt.Println(num)
      num++
  }
  ```

- **接三个表达式**

```go
  for num := 0; num < 4; num++ {
      fmt.Println(num)
  }
  ```

该程序的输出和上面的例子是等价的。这里注意一点，在第一个表达式声明的变量 `num` 的作用域只在 `for` 循环里面有效。

- **接一个 range 表达式**

在 Go 中遍历一个可迭代的对象一般使用 `for-range` 语句实现，其中 `range` 后面可以接数组、切片、字符串等， `range` 会返回两个值，第一个是索引值，第二个是数据值。

```go
  str := "Hello GO"
  for index, value := range str{
      fmt.Printf("index %d, value %c\n", index, value)
  }
  ```

**运行结果**

```
  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
  ```

- **不接表达式**

`for` 后面不接表达式就相当于无限循环，当然，可以使用 `break` 语句退出循环。

下面两种无限循环的写法等价，但一般使用第一种写法。

```go
  // 第一种写法
  for {
      code
  }
  // 第二种写法
  for ;; {
      code
  }
  ```

- **break 语句**

`break` 语句用于终止 `for` 循环，之后程序将执行在 `for` 循环后的代码。

```go
  for num := 1; num <= 10; num++ {
      if num % 4 == 0 {
          break
      }
      fmt.Println(num)
  }
  fmt.Println("end")
  ```

**运行结果**

```
  1
  2
  3
  end
  ```

- **continue 语句**

`continue` 语句用来跳出 `for` 循环中的当前循环。在 `continue` 语句后的所有的 `for` 循环语句都不会在本次循环中执行，执行完 `continue` 语句后将会继续执行一下次循环。下面的程序会打印出 `10` 以内的奇数。

```go
  for num := 1; num <= 10; num++ {
      if num % 2 == 0 {
          continue
      }
      fmt.Printf("%d\t",num)
  }
  ```

**运行结果**

```
  1	3	5	7	9	
  ```

### 五、goto(跳转到指定标签)

`goto`语句通过标签进行代码间的无条件跳转。`goto`语句可以在快速跳出循环、避免重复退出上有一定的帮助。Go语言中使用`goto`语句能简化一些代码的实现过程。

**示例**

```go
func main() {
	fmt.Println("first")
	goto label
	fmt.Println("second")
label:
	fmt.Println("third")
}
```

**运行结果**

```
first
third
```

`goto` 语句与标签之间不能有变量声明，否则编译错误。编译下面的程序会报错：

```go
func main() {
	fmt.Println("first")
	goto label
	fmt.Println("second")
	var x int = 0
label:
	fmt.Println("third")
}
```

*附参考原文链接地址*

*http://www.go-edu.cn/2022/05/17/go-11-%E6%B5%81%E7%A8%8B%E6%8E%A7%E5%88%B6/*

标签: Golang基础

非特殊说明，本博所有文章均为博主原创。

如若转载，请注明出处：https://lilinchao.com/archives/2226.html

上一篇 14.Go module介绍

下一篇 16.Golang方法和函数区别

15.Golang流程控制

评论已关闭

栏目分类

标签云

友情链接申请

15.Golang流程控制

评论已关闭

 栏目分类

标签云

友情链接申请

栏目分类

标签云

友情链接申请