条件语句if

基本形式

  1. if a > b {
  2.     ...
  3. } else {
  4.     ...
  5. }

与其他主要编程语⾔的差异

  • condition 表达式结果必须为布尔值；
  • ⽀持变量赋值
    1. if var declaration; condition {
    2.   ...
    3. }

选择语句 switch

基本形式

  1. switch var {
  2. case condition1: 
  3.     code block1
  4. case condition2: 
  5.     code block2
  6. default: 
  7.     code block3
  8. }

控制语句 - 图1

与其他主要编程语⾔的差异

  1. 条件表达式不限制为常量或者整数；
  2. 单个 case 中，可以出现多个结果选项, 使⽤逗号分隔；
  3. 与 C 语⾔等规则相反， Go 语⾔不需要⽤break来明确退出⼀个 case；如果希望继续执行下一个case，需要使用fallthrough；
  4. 可以不设定 switch 之后的条件表达式，在此种情况下，整个 switch 结构与多个 if…else… 的逻辑作⽤等同；
  5. switch 语句还可用于type-switch来判断某个interface中实际存储的变量类型。

TODO 判断变量类型

一个接口类型的变量 varI 中可以包含任何类型的值，必须有一种方式来检测它的 动态 类型，即运行时在变量中存储的值的实际类型，在执行过程中动态类型可能会有所不同。

varI 必须是一个接口变量，否则编译器会报错：invalid type assertion: varI.(T) (non-interface type (type of varI) on left)

如果转换合法，v 是 varI 转换到类型 T 的值，ok 会是 true；否则 v 是类型 T 的零值，ok 是 false，也没有运行时错误发生。

  1. if v, ok := varI.(T); ok {  // checked type assertion
  2.     Process(v)
  3.     return
  4. }
  5. // varI is not of type T
  1. package main
  3. import "fmt"
  5. func main()  {
  6.     var test interface{}
  7.     test = true
  8.     switch test.(type) {
  9.     case int:
  10.         fmt.Print("整型")
  11.     case string:
  12.         fmt.Print("字符串")
  13.     default:
  14.         fmt.Print("都不是")
  15.     }
  16. }

switch 中含赋值语句和条件

  1. switch os := runtime.GOOS; os {
  2. case "darwin":
  3.     fmt.Println("OS X.”)
  4.     //break
  5. case "linux":
  6.     fmt.Println("Linux.")
  7. default:
  8.     // freebsd, openbsd,
  9.     // plan9, windows...
  10.     fmt.Printf("%s.", os)
  11. }

实现多个 if

  1. switch {
  2. case 0 <= Num && Num <= 3:
  3.     fmt.Printf("0-3")
  4. case 4 <= Num && Num <= 6:
  5.     fmt.Printf("4-6")
  6. case 7 <= Num && Num <= 9:
  7.     fmt.Printf("7-9")
  8. }

循环语句 for

方式1 无限循环

  1. for true {
  2. }
  3. // 简写
  4. for {
  5. }

方式2 条件循环

  1. for init;condition;increase {
  2. }

方式3 遍历切片

  1. a := []string{"a","b","c"}
  2. for key,val := range a {
  3.   fmt.Print(key)
  4.   fmt.Print(val)
  5.   fmt.Print("\n")
  6. }

方式4 while 条件循环

  1. n := 0
  2. for n < 5 {
  3.     n++
  4.     fmt.Println(n)
  5. }

循环体内的变量每次都是重新生成的

  1. package main
  3. import "fmt"
  5. func main() {
  6.     for i := 1; i <= 3; i++ {
  7.         v := 1
  8.         fmt.Println(&v)
  9.     }
  10. }
  12. // result
  13. 0xc420014060
  14. 0xc420014068
  15. 0xc420014080

跳转语句 goto break continue

控制语句 - 图2

  • 这三个语句都可以配合标签使用
  • break和continue配合标签可以跳出多层循环
  • goto是调整位置，与其他两个语句配合标签的结果并不相同

goto 跳转到指定语句

  1. goto One
  2. fmt.Print("middle code")
  3. One:
  4.   fmt.Print("last code")

break 跳出本层循环

  1. func main(){
  2.     for {
  3.         for i := 1; i <= 10; i++ {
  4.             if i < 3 {
  5.                 fmt.Println(i)
  6.             } else {
  7.                 break
  8.             }
  9.         }
  10.     }
  11.     fmt.Println("break")
  12. }

continue 跳出本次循环，进行下一次循环