4 流程控制

  • 流程控制是每种语言控制逻辑走向和执行次序的重要部分
  • Go 中有if 和 for, 而switch 和 goto主要是为了简化代码、降低重复代码而生，属于扩展类的流程控制

if else分支结构

if 条件判断的基本写法

  • if 条件判断格式

    • ```go
      if expr1{
      block1
      }else if expr2{
      block2
      }else {
      block3
      }
      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

        * ==注意：==Go 规定，`if`的**左括号**必须与`if expr`放于同一行；**右括号必须与下一个语句在同一行**

      #### if 条件判断特殊写法

      * 可以在 if 表达式前添加一个执行语句，再根据变量值判断

        * 示例：

        * ```go
          package main
          
          import "fmt"
          
          func main() {
          
          	if score := 65; score >= 90 {
          		fmt.Println("A")
          	} else if score > 75 {
          		fmt.Println("B")
          	} else {
          		fmt.Println("C")
          	}
          }

  • 思考：区别可能就是作用域不同

for 循环结构

  • Go 语言中的所有循环类型都可以使用关键字 for 完成

  • 基本格式：

    1
    2
    3
    for 初始语句; 循环条件表达式; 结束语句{
    	循环体
    }

  • 当循环条件表达式 为true 时进行循环，直到为false

  • for 循环的 初始语句 可以被省略，但是分号必须要写

    • for ;i<10;i++

  • for 循环的初始语句和结束语句都可以被省略, 此时不需要分号

    • 类似于C中的关键词while
    • for i<10

无限循环

  • ```
    for {

    循环体

    }

    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

    * 可以通过关键字`break` `goto` `return`  `panic`强制退出循环



    ### for range 键值循环

    * 可以使用 `for range` 遍历 数组、切片、字符串、map以及通道
      * 数组、切片、字符串 返回 `索引`和`值`
      * map 返回`键`和`值`
      * 通道 只返回`通道内的值`



    ### switch case

    * 对大量值进行条件判断

      * ```go
        i := 1
        switch(i){
        	case 1:
        		block1
        	case 2:
        		block2
        	default :
        		block3
        }

  • Go 规定，只能有一个default分支

  • 一个分支可以有多个值，多个case值使用逗号分开

  • case 1, 3, 5:

  • 分支可以使用表达式判断：

    • case age<25:

  • fallthrough语法可以执行满足条件的 case 的下一个 case，为了兼容 C 中的case

    • ```go
      func switchDemo5() {
       s := "a"
 switch {
 case s == "a":
     fmt.Println("a")
     fallthrough
 case s == "b":
     fmt.Println("b")
 case s == "c":
     fmt.Println("c")
 default:
     fmt.Println("...")
 }
      }
      1
      2
      3
      4

      * ```
        a
        b

goto 跳转到指定标签

  • goto通过标签进行代码间的无条件跳转
  • 可以在快速跳出循环、避免重复退出上有一定的帮助
    * 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func gotoDemo2() {
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 设置退出标签
				goto breakTag
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	return
	// 标签
breakTag:
	fmt.Println("结束for循环")
}

break 跳出循环

  • 结束for、switch、select 的代码块

  • 可以在break语句后面添加标签：退出某个标签对应的代码块

    • 标签必须定义在对应的for、switch、select 的代码块上

      • ```go
        func breakDemo1() {
        BREAKDEMO1:
        for i := 0; i < 10; i++ {
    for j := 0; j < 10; j++ {
        if j == 2 {
            break BREAKDEMO1
        }
        fmt.Printf("%v-%v\n", i, j)
    }
}
fmt.Println("...")
        }
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22

              

        ### continue 继续下次循环

        * continue 语句: 结束当前循环，开始下一次循环，仅限在`for`循环内使用

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

          * ```go
            func continueDemo() {
            forloop1:
            	for i := 0; i < 5; i++ {
            		// forloop2:
            		for j := 0; j < 5; j++ {
            			if i == 2 && j == 2 {
            				continue forloop1
            			}
            			fmt.Printf("%v-%v\n", i, j)
            		}
            	}
            }

练习题

  • 编写代码打印 99 乘法表

    • package main

import "fmt"

func main() {
    for i := 1; i <= 10; i++ {
        for j := 1; j <= 10; j++ {
            fmt.Printf("%d * %d = %d ", i, j, i*j)
        }
        fmt.Println()
    }
}