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

下图展示了程序语言中条件语句的结构：
Go语言 条件语句 - 图1

Go 语言提供的几种条件判断语句

语句 描述
if 语句 if 语句 由一个布尔表达式后紧跟一个或多个语句组成。
if…else 语句 if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。
if 嵌套语句 你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。
switch 语句 switch 语句用于基于不同条件执行不同动作。
select 语句 select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。

⚠️ 注意: Go 没有三目运算符，所以不支持 condition ? expr1 : expr2 形式的条件判断

if 语句

if 语句由布尔表达式后紧跟一个或多个语句组成

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

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

If 在布尔表达式为 true 时，其后紧跟的语句块执行，如果为 false 则不执行。流程图如下：
Go语言 条件语句 - 图2

使用 if 判断一个数变量的大小

  1. package main
  2. import "fmt"
  4. func main() {
  5.    /* 定义局部变量 */
  6.    var a int = 10
  8.    /* 使用 if 语句判断布尔表达式 */
  9.    if a < 20 {
  10.        /* 如果条件为 true 则执行以下语句 */
  11.        fmt.Printf("a 小于 20\n" )
  12.    }
  13.    fmt.Printf("a 的值为 : %d\n", a)
  14. }
  16. /* 
  17. a 小于 20
  18. a 的值为 : 10
  19.  */

if…else 语句

if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行

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

  1. if 布尔表达式 {
  2.    /* 在布尔表达式为 true 时执行 */
  3. } else {
  4.   /* 在布尔表达式为 false 时执行 */
  5. }

If 在布尔表达式为 true 时，其后紧跟的语句块执行，如果为 false 则执行 else 语句块。流程图如下：
Go语言 条件语句 - 图3

使用 if else 判断一个数的大小

  1. package main
  2. import "fmt"
  4. func main() {
  5.    /* 局部变量定义 */
  6.    var a int = 100;
  8.    /* 判断布尔表达式 */
  9.    if a < 20 {
  10.        /* 如果条件为 true 则执行以下语句 */
  11.        fmt.Printf("a 小于 20\n" );
  12.    } else {
  13.        /* 如果条件为 false 则执行以下语句 */
  14.        fmt.Printf("a 不小于 20\n" );
  15.    }
  16.    fmt.Printf("a 的值为 : %d\n", a);
  18. }
  20. /* 
  21. a 不小于 20
  22. a 的值为 : 100 
  23. */

寻找到 100 以内的所有的素数

  1. package main
  3. import "fmt"
  4. func main(){
  5.     // var count,c int   //定义变量不使用也会报错
  6.     var count int =1
  7.     var flag bool
  9.     //while(count<100) {    //go没有while
  10.     for count < 100 {
  11.         count++
  12.         flag = true;
  14.         //注意tmp变量  :=
  15.         for tmp:=2;tmp<count;tmp++ {
  16.             if count%tmp==0{
  17.                 flag = false
  18.             }
  19.         }
  21.         // 每一个 if else 都需要加入括号 同时 else 位置不能在新一行
  22.         if flag == true {
  23.                 fmt.Println(count,"素数")
  24.         }else{
  25.             continue
  26.         }
  27.   }
  28. }

if … else if … else…

语法

  1. if 布尔表达式 {
  2.    /* 在布尔表达式为 true 时执行 */
  3. } else if 布尔表达式 {
  4.   /* 在布尔表达式为 false 时执行 */
  5. }else {
  6.   /* 在布尔表达式为 false 时执行 */
  7. }

示例

  1. package main
  2. import "fmt"
  4. func main() {
  5.     var age int = 23
  6.     if age == 25 {
  7.         fmt.Println("true")
  8.     } else if age < 25 {
  9.         fmt.Println("too small")
  10.     } else {
  11.         fmt.Println("too big")
  12.     }
  13. }
  15. /*
  16. too small
  17. */

if 语句嵌套

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

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

  1. if 布尔表达式 1 {
  2.    /* 在布尔表达式 1 为 true 时执行 */
  3.    if 布尔表达式 2 {
  4.       /* 在布尔表达式 2 为 true 时执行 */
  5.    }
  6. }

你可以以同样的方式在 if 语句中嵌套 else if…else 语句

  1. package main
  2. import "fmt"
  4. func main() {
  5.    /* 定义局部变量 */
  6.    var a int = 100
  7.    var b int = 200
  9.    /* 判断条件 */
  10.    if a == 100 {
  11.        /* if 条件语句为 true 执行 */
  12.        if b == 200 {
  13.           /* if 条件语句为 true 执行 */
  14.           fmt.Printf("a 的值为 100 ， b 的值为 200\n" );
  15.        }
  16.    }
  17.    fmt.Printf("a 值为 : %d\n", a );
  18.    fmt.Printf("b 值为 : %d\n", b );
  19. }
  21. /* 
  22. a 的值为 100 ， b 的值为 200
  23. a 值为 : 100
  24. b 值为 : 200 
  25. */

switch 语句

switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止 switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break。 switch 默认情况下 case 最后自带 break 语句，默认只会执行匹配到的那个 case,匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough

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

  1. switch val1 {
  2.     case val1:
  3.         ...
  4.     case val2:
  5.         ...
  6.     default:
  7.         ...
  8. }

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

  1. switch{
  2.     case 1,2,3,4:
  3.      ...
  4.     default:
  5.      ...
  6. }

image.png/

  1. package main
  2. import "fmt"
  4. func main() {
  5.    /* 定义局部变量 */
  6.    var grade string = "B"
  7.    var marks int = 90
  9.    switch marks {
  10.       case 90: grade = "A"
  11.       case 80: grade = "B"
  12.       case 50,60,70 : grade = "C"
  13.       default: grade = "D"  
  14.    }
  16.    switch {
  17.       case grade == "A" :
  18.          fmt.Printf("优秀!\n" )     
  19.       case grade == "B", grade == "C" :
  20.          fmt.Printf("良好\n" )      
  21.       case grade == "D" :
  22.          fmt.Printf("及格\n" )      
  23.       case grade == "F":
  24.          fmt.Printf("不及格\n" )
  25.       default:
  26.          fmt.Printf("差\n" );
  27.    }
  28.      fmt.Printf("你的等级是 %s\n", grade );      
  29. }
  31. /* 
  32. 优秀!
  33. 你的等级是 A
  34.  */

Type Switch

switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。Type Switch 语法格式如下：

  1. switch x.(type){
  2.     case type:
  3.        statement(s);      
  4.     case type:
  5.        statement(s); 
  6.     /* 你可以定义任意个数的case */
  7.     default: /* 可选 */
  8.        statement(s);
  9. }
  1. package main
  2. import "fmt"
  4. func main() {
  5.    var x interface{}
  7.    switch i := x.(type) {
  8.       case nil:   
  9.          fmt.Printf(" x 的类型 :%T",i)                
  10.       case int:   
  11.          fmt.Printf("x 是 int 型")                       
  12.       case float64:
  13.          fmt.Printf("x 是 float64 型")           
  14.       case func(int) float64:
  15.          fmt.Printf("x 是 func(int) 型")                      
  16.       case bool, string:
  17.          fmt.Printf("x 是 bool 或 string 型" )       
  18.       default:
  19.          fmt.Printf("未知型")     
  20.    }   
  21. }
  23. /*  
  24. x 的类型 :<nil> 
  25. */

fallthrough

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

  1. package main
  2. import "fmt"
  4. func main() {
  6.     switch {
  7.     case false:
  8.             fmt.Println("1、case 条件语句为 false")
  9.             fallthrough
  10.     case true:
  11.             fmt.Println("2、case 条件语句为 true")
  12.             fallthrough
  13.     case false:
  14.             fmt.Println("3、case 条件语句为 false")
  15.             fallthrough
  16.     case true:
  17.             fmt.Println("4、case 条件语句为 true")
  18.     case false:
  19.             fmt.Println("5、case 条件语句为 false")
  20.             fallthrough
  21.     default:
  22.             fmt.Println("6、默认 case")
  23.     }
  24. }
  26. /* 
  27. 2、case 条件语句为 true
  28. 3、case 条件语句为 false
  29. 4、case 条件语句为 true
  30. */

break

如果想要执行多个 case，需要使用 fallthrough 关键字，也可用 break 终止

  1. switch{
  2.     case 1:
  3.     ...
  4.     if(...){
  5.         break
  6.     }
  7.     fallthrough // 此时switch(1)会执行case1和case2，但是如果满足if条件，则只执行case1
  9.     case 2:
  10.     ...
  12.     case 3:
  13.      ...
  15.     default:
  16.      ...
  17. }

经典案例

  1. package main
  2. import (
  3.     "fmt"
  4. )
  6. func main() {
  7.     a := 1
  8.     switch a {
  9.     case 0:
  10.         fmt.Println("a = 0 ")
  11.     case 1:
  12.         fmt.Println("a = 1")
  13.     default:
  14.         fmt.Println("Unknown")
  15.     }
  16. }
  18. /* 
  19. 运行结果
  20. a = 1 
  21. */

switch后带初始化表达式

支持一个初始化表达式（可以是并行方式），右侧需跟分号

  1. package main
  2. import (
  3.     "fmt"
  4.     "strconv"
  5. )
  8. func main() {
  9.     var a string ="100"
  11.     switch ascapegoat, _ := strconv.ParseInt(a, 10, 64);{
  12.     case ascapegoat>90:
  13.             fmt.Println("优秀")
  14.     case ascapegoat>80:
  15.             fmt.Println("良好")
  16.     case ascapegoat>70:
  17.             fmt.Println("中上")
  18.     case ascapegoat>=60:
  19.             fmt.Println("及格")
  20.     case ascapegoat<60:
  21.             fmt.Println("丢人")
  22.     default:
  23.             fmt.Println("系统出错")
  24.     }
  25. }
  28. /* 
  29. string到int
  30. int,err:=strconv.Atoi(string)
  32. string到int64
  33. int64, err := strconv.ParseInt(string, 10, 64)
  35. int到string
  36. string:=strconv.Itoa(int)
  38. int64到string
  39. string:=strconv.FormatInt(int64,10) 
  40. */
  43. /* 
  44. 优秀
  45. */

switch后不带任何条件与表达式

可以使用任何类型或表达式作为条件语句；
不需要写break，一旦条件符合自动终止；
若希望继续执行下一个case，需使用fallthrough语句

  1. package main
  2. import (
  3.     "fmt"
  4. )
  6. func main() {
  7.     var a = 8
  9.     switch {
  10.     case a >= 0:
  11.         fmt.Println("a >= 0 ")
  12.         fallthrough
  13.     case a >= 5:
  14.         fmt.Println("a >= 5")
  15.         fallthrough
  16.     default:
  17.         fmt.Println("Unknown")
  18.     }
  19. }
  21. /* 
  22. a >= 0 
  23. a >= 5
  24. Unknown
  25. */

select 语句

select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收 select 随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行的

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

  1. select {
  2.     case communication clause  :
  3.        statement(s);      
  4.     case communication clause  :
  5.        statement(s);
  6.     /* 你可以定义任意数量的 case */
  7.     default : /* 可选 */
  8.        statement(s);
  9. }

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

  • 每个 case 都必须是一个通信
  • 所有 channel 表达式都会被求值
  • 所有被发送的表达式都会被求值
  • 如果任意某个通信可以进行，它就执行，其他被忽略。
  • 如果有多个 case 都可以运行，Select 会随机公平地选出一个执行。其他不会执行。否则：
    1. 如果有 default 子句，则执行该语句
    2. 如果没有 default 子句，select 将阻塞，直到某个通信可以运行；Go 不会重新对 channel 或值进行求值 ```go 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 /

  2. select 会循环检测条件，如果有满足则执行并退出，否则一直循环检测
  3. ```go
  4. package main
  5. import (
  6.     "fmt"
  7.     "time"
  8. )
  10. func Chann(ch chan int, stopCh chan bool) {
  11.    //  var i int = 10
  12.     for j := 0; j < 10; j++ {
  13.         ch <- j
  14.         time.Sleep(time.Second)
  15.     }
  16.     stopCh <- true
  17. }
  20. func main() {
  21.     ch := make(chan int)
  22.     c := 0
  23.     stopCh := make(chan bool)
  25.     go Chann(ch, stopCh)
  27.     for {
  28.         select {
  29.         case c = <-ch:
  30.             fmt.Printf("C = <-ch Recvice %d\n", c)
  31.             fmt.Println("channel")
  32.         case s := <-ch:
  33.             fmt.Printf("S := <-ch Receive %d\n", s)
  34.         case _ = <-stopCh:
  35.             goto end
  36.         }
  37.     }
  38. end:fmt.Println("程序运行结束")
  39. }
  40. /* 
  41. S := <-ch Receive 0
  42. C = <-ch Recvice 1
  43. channel
  44. S := <-ch Receive 2
  45. C = <-ch Recvice 3
  46. channel
  47. C = <-ch Recvice 4
  48. channel
  49. S := <-ch Receive 5
  50. C = <-ch Recvice 6
  51. channel
  52. S := <-ch Receive 7
  53. C = <-ch Recvice 8
  54. channel
  55. S := <-ch Receive 9
  56. 程序运行结束
  57. */