Go 语言条件语句

条件语句需要开发者通过指定一个或多个条件，并通过测试条件是否为 true 来决定是否执行指定语句，并在条件为 false 的情况在执行另外的语句。

Go 语言提供了以下几种条件判断语句：

注意：Go 没有三目运算符，所以不支持 ?: 形式的条件判断。

一、if语句

if 条件表达式 {    
    执行语句块
}

go语言if后面的条件表达式不必用括号括起来，但后面的大括号是必需的。

package main

import (
    "fmt"
    "math"
)

func sqrt(x float64) string {
    if x < 0 {
        return sqrt(-x) + "i"
    }
    return fmt.Sprint(math.Sqrt(x))
}

func main() {
    fmt.Println(sqrt(2), sqrt(-4))
}

if还有一个强大的地方就是条件表达式那里允许声明一个变量，这个变量的作用域只在该条件逻辑块内，其他地方不起作用。

例子：

package main

import "fmt"

func main() {
    if age := 18; age > 9 {
        fmt.Println("Hello, Gozww!")
    }
}

二、if-else语句

if 条件表达式 {
    执行代码块1
} else {
    执行代码块2
}

说明：当条件表达式为true时，执行代码块1，否则执行代码块2

例子：

package main

import "fmt"

func main() {
    if age := 19; age > 18 {
        fmt.Println("年龄大于18岁")
    } else {
        fmt.Println("年龄小于18岁")
    }
}

三、if-else if-...=else

if 条件表达式1 {
    执行代码块1
} else if 条件表达式2 {
    执行代码块2
}
...
esle {
    执行代码块n
}

说明：先判断表达式1，若为true则执行代码块1，否则判断表达2，若表达式2位true，则执行代码块2，否则以此类推，若所有表达式都不成立，则执行代码块n。

使用细节：

1. else不是必须的

2. 多分支只能有一个执行入口

package main

import "fmt"

func main() {
    if age := 19; age > 18 {
        fmt.Println("年龄大于18岁")
    } else if  age > 15{
        fmt.Println("年龄大于15岁")
    } else if age > 10 {
        fmt.Println("年龄大于10岁")
    } else {
        fmt.Println("年龄太小")
    }
}

输出结果：

年龄大于18岁

四、if 嵌套语句

if 或 else if 语句中可以嵌入一个或多个 if 或 else if 语句。

Go 编程语言中 if...else 语句的语法如下：

if 条件表达式 1 {
   /* 在条件表达式 1 为 true 时执行 */
   if 条件表达式 2 {
      /* 在条件表达式 2 为 true 时执行 */
   }
}

示例代码

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 100
   var b int = 200
 
   /* 判断条件 */
   if a == 100 {
       /* if 条件语句为 true 执行 */
       if b == 200 {
          /* if 条件语句为 true 执行 */
          fmt.Printf("a 的值为 100 ， b 的值为 200\n" );
       }
   }
   fmt.Printf("a 值为 : %d\n", a );
   fmt.Printf("b 值为 : %d\n", b );
}

输出结果：

a 的值为 100 ， b 的值为 200
a 值为 : 100
b 值为 : 200

五、switch 语句

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

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

switch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough 。

Go 编程语言中 switch 语句的语法如下：

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

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

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

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

输出结果：

优秀!
你的等级是 A

六、type-switch 语句

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

package main

import "fmt"

func main() {
  //引入空接口
   var x interface{}
    
  //判断接口类型。  注意type 只能搭配switch 使用。如果想单独使用输出数据类型，需要使用反射
   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>

fallthrough

使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。

package main

import "fmt"

func main() {

    switch {
    // 因为是false，所以不会执行此段语句。即使写了fallthrough也不会生效
    case false:
            fmt.Println("1、case 条件语句为 false")
            fallthrough
    //因为条件是true，所以会执行此段语句。fallthrough会生效。下一条语句，不管结果是否为true都会执行  
    case true:
            fmt.Println("2、case 条件语句为 true")
            fallthrough
    //由于上一条语句里的fallthrough生效，所以此段会执行，此段里的fallthrough会生效 
    case false:
            fmt.Println("3、case 条件语句为 false")
            fallthrough
    //由于上一段的fallthrough，所以，此段会被执行。由于此段没有fallthrough，所以，下一段不会执行。switch  语句结束
    case true:
            fmt.Println("4、case 条件语句为 true")
    case false:
            fmt.Println("5、case 条件语句为 false")
            fallthrough
    default:
            fmt.Println("6、默认 case")
    }
}

输出结果：

2、case 条件语句为 true
3、case 条件语句为 false
4、case 条件语句为 true

七、select 语句

select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。

select 随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行的。

Go 编程语言中 select 语句的语法如下：

select {
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s);
    /* 你可以定义任意数量的 case */
    default : /* 可选 */
       statement(s);
}

以下描述了 select 语句的语法：

• 每个 case 都必须是一个通信

• 所有 channel 表达式都会被求值

• 所有被发送的表达式都会被求值

• 如果任意某个通信可以进行，它就执行，其他被忽略。

• 如果有多个 case 都可以运行，Select 会随机公平地选出一个执行。其他不会执行。

  否则：

1. 如果有 default 子句，则执行该语句。

2. 如果没有 default 子句，select 将阻塞，直到某个通信可以运行；Go 不会重新对 channel 或值进行求值。

package main

import "fmt"

func main() {
   var c1, c2, c3 chan int
   var i1, i2 int
   select {
      case i1 = <-c1:
         fmt.Printf("received ", i1, " from c1\n")
      case c2 <- i2:
         fmt.Printf("sent ", i2, " to c2\n")
      case i3, ok := (<-c3):  // same as: i3, ok := <-c3
         if ok {
            fmt.Printf("received ", i3, " from c3\n")
         } else {
            fmt.Printf("c3 is closed\n")
         }
      default:
         fmt.Printf("no communication\n")
   }    
}

输出结果:

no communication