Go语言之分支结构（十一）

Go语言分支结构

一、程序的流程结构

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

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

• 选择结构：条件满足，某些代码才会执行。0-1次
  分支语句：if，switch，select

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

二、条件语句

1.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)
}

2.if变体语句

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

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")
    }
}

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

3.switch语句 ( 开关语句 ）

什么是switch语句？

1.switch是一个条件语句，
它计算表达式并将其与可能匹配的列表进行比较，并根据匹配执行代码块。

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

3.switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加break。

4.而如果switch没有表达式，它会默认匹配true

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

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

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

switch var1 {
    case val1:
        ...
    case val2:
        ...
    case val3,val4:
    	...
    default:
        ...
}

switch语句的语法格式：

1.switch语法格式：
	switch 变量{
		case 数值1：分支1
		case 数值2：分支2
		...
		default：
			最后一个分支
	}		

2.省略switch后的变量，相当于直接作用在true上
	switch{//true
	case true:
	case false:
	}

3.case后可以同时跟随多个数值
	switch 变量{
	case 数值1，数值2，数值3：
	case 数值4，数值5：
	}

4.switch后可以多一条初始化语句
	switch 初始化语句;变量{
	}

示例代码：

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   // 定义在main函数当中，是局部变量
   var grade string = "B"
   var marks int = 90

   switch marks {
      case 90: grade = "A"
      case 80: grade = "B"
      case 50,60,70 : grade = "C"  //case 后可以由多个数值
      default: grade = "D"  
   }

   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 );      
}

注意事项

switch可以作用在其他类型上，case后的数值必须和switch作用的变量类型一致
case是无序的
case后的数值是唯一的(duplicate case 3 in switch)
default语句是可选的操作

4.fallthrough

如需贯通后续的case，就添加fallthrough

解释：因为每个case自带break语句，所以如果在执行完一个case语句后，还想执行后面case的语句，就需要使用fallthrouth

示例代码：

package main

import (
	"fmt"
)

type data [2]int

func main() {
	switch x := 5; x {
	default:
		fmt.Println(x)
	case 5:
		x += 10
		fmt.Println(x)
		fallthrough
	case 6:
		x += 20
		fmt.Println(x)
	}
}

执行结果：
15
35

注意事项：
switch的注意事项

1. case后的常量值不能重复
2. case后可以有多个常量值
3. fallthrough应该是某个case的最后一行。如果它出现在中间的某个地方，编译器就会抛出错误。

5.Type Switch

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>