九、程序的流程结构（if分支语句，Switch分支，for循环）

一、程序的流程结构

程序的流程控制结构一共有三种：顺序结构，选择结构，循环结构。

顺序结构：从上向下，逐行执行。

选择结构：条件满足，某些代码才会执行。0-1次

​ 分支语句：if，switch，select

循环结构：条件满足，某些代码会被反复的执行多次。0-N次

​ 循环语句：for

二、条件语句

If语句

语法格式：

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

if 布尔表达式 {
   /* 在布尔表达式为 true 时执行 */
} else {
  /* 在布尔表达式为 false 时执行 */
}

if 布尔表达式1 {
   /* 在布尔表达式1为 true 时执行 */
} else if 布尔表达式2{
   /* 在布尔表达式1为 false ,布尔表达式2为true时执行 */
} else{
   /* 在上面两个布尔表达式都为false时，执行*/
}

示例代码：

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 10
 
   /* 使用 if 语句判断布尔表达式 */
   if a < 20 {
       /* 如果条件为 true 则执行以下语句 */
       fmt.Printf("a 小于 20\n" )
   }
   fmt.Printf("a 的值为 : %d\n", a)
}

如果其中包含一个可选的语句组件(在评估条件之前执行)，则还有一个变体。它的语法是

if statement(初始化语句); condition(判断条件) {  
}

if condition{
    
}

示例代码：

package main

import (  
    "fmt"
)

func main() {  
    if num := 10; num % 2 == 0 { //checks if number is even
        fmt.Println(num,"is even") 
    }  else {
        fmt.Println(num,"is odd")
    }
}
//输出结果
10 is even

需要注意的是，num的定义在if里，那么只能够在该if…else语句块中使用，否则编译器会报错的。

switch语句：“开关”

• switch是一个条件语句，它计算表达式并将其与可能匹配的列表进行比较，并根据匹配执行代码块。它可以被认为是一种惯用的方式来写多个if else子句。

• switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上直下逐一测试，直到匹配为止。

• switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加break（跟java不同）。

• 而如果switch没有表达式，它会匹配true

• Go里面switch默认相当于每个case最后带有break，匹配成功后不会自动向下执行其他case，而是跳出整个switch, 但是可以使用fallthrough强制执行后面的case代码。

• 变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。

• 同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3

  package main
  
  import (
  	"fmt"
  )
  
  func main() {
  	var grade string = "B"
  	var marks int = 90
  
  	switch marks {
  	case marks:
  		grade = "A"
  	case 80:
  		grade = "B"
  	case 50, 60, 70:
  		grade = "C" //case 后可以由多个数值
  	default:
  		grade = "D"
  	}
  
  	//表达式被省略，则被认为是switch true，并且每个case表达式都被计算为true
  	switch {
  	case grade == "A":
  		fmt.Printf("优秀!\n")
  	case grade == "B", grade == "C":
  		fmt.Printf("良好\n")
  	case grade == "D":
  		fmt.Printf("及格\n")
  	case grade == "F":
  		fmt.Printf("不及格\n")
  	default:
  		fmt.Printf("差\n")
  	}
  	fmt.Printf("你的等级是 %s\n", grade)
  
  	//如需贯通后续的一个case，就添加fallthrough，只能是某个case的最后一行 ，写在最后一个case也会报错
  	switch x := 5; x {
  	default:
  		fmt.Println(x)
  	case 5:
  		x += 10
  		fmt.Println(x)
  		fallthrough
  	case 6:
  		x += 20
  		fmt.Println(x)
  		fallthrough
  	case 7:
  		x += 30
  		fmt.Println(x)
  		fallthrough
  	case 8:
  		x += 40
  		fmt.Println(x)
  	}
  }
  //输出结果
  优秀!
  你的等级是 A
  15
  35
  65
  105
  

• switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。

  package main
  
  import "fmt"
  
  func main() {
     var x interface{}
       
     switch i := x.(type) {
        case nil:	  
           fmt.Printf(" x 的类型 :%T",i)                
        case int:	  
           fmt.Printf("x 是 int 型")                       
        case float64:
           fmt.Printf("x 是 float64 型")           
        case func(int) float64:
           fmt.Printf("x 是 func(int) 型")                      
        case bool, string:
           fmt.Printf("x 是 bool 或 string 型" )       
        default:
           fmt.Printf("未知型")     
     }   
  }
  //输出结果
  x 的类型 :<nil>
  

for循环

• 程序的流程控制结构一共有三种：

  • 顺序结构：代码从上向下逐行的执行；
  • 选择结构：条件满足，某些代码才会被执行。0-1次；
  • 循环结构：条件满足，某些代码会被反复的多次执行。0-n次。

• 语法结构：

  • for init; condition; post { }（跟Java类似）

  • package main
    
    import (  
        "fmt"
    )
    
    func main() {  
        for i := 1; i <= 10; i++ {
            fmt.Printf(" %d",i)
        }
    }