Go流程结构（if）

一、程序的流程结构

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

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

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

分支语句：if，switch，select

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

循环语句：for

二、条件语句

2.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.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语句块中使用，否则编译器会报错的。

2.3 switch语句：“开关”

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

switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上直下逐一测试，直到匹配为止。 switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加break。

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

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

变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。 您可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。

 switch var1 {
     case val1:
         ...
     case val2:
         ...
     default:
         ...
 }

示例代码：

package main

import "fmt"

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

2.4 fallthrough

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

package main

import "fmt"

func main() {
	/*
	switch中的break和fallthrough语句
	break：可以使用在switch中，也可以使用在for循环中
		强制结束case语句，从而结束switch分支

	fallthrough：用于穿透switch
		当switch中某个case匹配成功之后，就执行该case语句
		如果遇到fallthrough，那么后面紧邻的case，无需匹配， 执行穿透执行。

		fallthrough应该位于某个case的最后一行
	 */
	  n := 2
	switch n {
	case 1:
		fmt.Println("我是熊大")
		fmt.Println("我是熊大")
		fmt.Println("我是熊大")
	case 2:
		fmt.Println("我是熊二")
		fmt.Println("我是熊二")
		break //用于强制结束case，意味着switch被强制结束
		fmt.Println("我是熊二")
	case 3:
		fmt.Println("我是光头强")
		fmt.Println("我是光头强")
		fmt.Println("我是光头强")
	}

	fmt.Println("-----------------")
	m := 2
	switch m {
	case 1:
		fmt.Println("第一季度。。")
	case 2:
		fmt.Println("第二季度。。")
		fmt.Println("...")
		fallthrough
	case 3:
		fmt.Println("第三季度。。")
		fallthrough
	case 4:
		fmt.Println("第四季度。。")

	}
	fmt.Println("main...over...")
}

case中的表达式是可选的，可以省略。如果该表达式被省略，则被认为是switch true，并且每个case表达式都被计算为true，并执行相应的代码块。

示例代码：

 package main
 ​
 import (
     "fmt"
 )
 ​
 func main() {
     num := 75
     switch { // expression is omitted
     case num >= 0 && num <= 50:
         fmt.Println("num is greater than 0 and less than 50")
     case num >= 51 && num <= 100:
         fmt.Println("num is greater than 51 and less than 100")
     case num >= 101:
         fmt.Println("num is greater than 100")
     }
 ​
 }

switch的注意事项

1. case后的常量值不能重复

2. case后可以有多个常量值

3. fallthrough应该是某个case的最后一行。如果它出现在中间的某个地方，编译器就会抛出错误。

2.5 Type Switch

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

 switch x.(type){
     case type:
        statement(s);
     case type:
        statement(s);
     /* 你可以定义任意个数的case */
     default: /* 可选 */
        statement(s);
 }

 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>