if else(分支结构)

if条件判断基本写法

  1. if 表达式1 {
  2.     分支1
  3. } else if 表达式2 {
  4.     分支2
  5. } else{
  6.     分支3
  7. }

if条件判断特殊写法

if条件判断还有一种特殊的写法，可以在 if 表达式之前添加一个执行语句，再根据变量值进行判断，举个例子：

  1. func ifDemo2() {
  2.     if score := 65; score >= 90 {
  3.         fmt.Println("A")
  4.     } else if score > 75 {
  5.         fmt.Println("B")
  6.     } else {
  7.         fmt.Println("C")
  8.     }
  9. }
  1. package main
  3. import "fmt"
  5. // if 判断
  6. func main() {
  7.     //     var sc = 70
  8.     //     if sc >= 90 {
  9.     //         fmt.Println("A")
  10.     //     } else if sc <= 90 {
  11.     //         fmt.Println("B")
  12.     //     } else {
  13.     //         fmt.Println("C")
  14.     //     }
  15.     // }
  17.     // if 判断的特殊写法
  19.     if sc := 70; sc >= 90 {
  20.         fmt.Println("A")
  21.     } else if sc <= 90 {
  22.         fmt.Println("B")
  23.     } else {
  24.         fmt.Println("C")
  25.     }
  26. }

for(循环结构)

Go 语言中的所有循环类型均可以使用for关键字来完成。

for循环的基本格式如下：

  1. for 初始语句;条件表达式;结束语句{
  2.     循环体语句
  3. }

条件表达式返回true时循环体不停地进行循环，直到条件表达式返回false时自动退出循环。

  1. func forDemo() {
  2.     for i := 0; i < 10; i++ {
  3.         fmt.Println(i)
  4.     }
  5. }

for循环的初始语句可以被忽略，但是初始语句后的分号必须要写，例如：

  1. func forDemo2() {
  2.     i := 0
  3.     for ; i < 10; i++ {
  4.         fmt.Println(i)
  5.     }
  6. }

for循环的初始语句和结束语句都可以省略，例如：

  1. func forDemo3() {
  2.     i := 0
  3.     for i < 10 {
  4.         fmt.Println(i)
  5.         i++
  6.     }
  7. }

无限循环

  1. func demo1() {
  2.     for {
  3.         fmt.Println("wuhu ")
  4.     }
  5. }

for循环可以通过 break、goto、return、panics语句强制退出循环。

break(跳出循环)

  1. func demo1() {
  2.     for i := 0; i < 5; i++ {
  3.         fmt.Println(i)
  4.         if i == 3 {
  5.             break
  6.         }
  7.     }
  8. }

continue(跳过本次循环，执行下一次)

  1. func demo1() {
  2.     for i := 0; i < 5; i++ {
  3.         if i == 3 {
  4.             continue
  5.         }
  6.         fmt.Println(i)
  7.     }
  8. }

for range 循环

Go语言中可以使用for range遍历数组、切片、字符串、map 及通道（channel）。 通过for range遍历的返回值有以下规律：

  1. 数组、切片、字符串返回索引和值。
  2. map返回键和值。
  3. 通道（channel）只返回通道内的值。

    switch case循环

    使用switch语句可方便地对大量的值进行条件判断。一个分支可以有多个值，多个case值中间使用英文逗号分隔。
    1. func switch_demo() {
    2.  num := 123
    3.  switch num {
    4.  case 1, 3, 5, 7, 9:
    5.      fmt.Println("奇数")
    6.  case 2, 4, 6, 8:
    7.      fmt.Println("偶数")
    8.  default:
    9.      fmt.Println(num)
    10.  }
    11. }
    Go语言规定每个switch只能有一个default分支。

分支还可以使用表达式，这时候switch语句后面不需要再跟判断变量。

  1. func switch_demo() {
  2.     age := 30
  3.     switch {
  4.     case age < 25:
  5.         fmt.Println("好好学习吧")
  6.     case age > 25 && age < 35:
  7.         fmt.Println("好好工作吧")
  8.     case age > 60:
  9.         fmt.Println("好好享受吧")
  10.     default:
  11.         fmt.Println("活着真好")
  12.     }
  13. }

fallthrough语法可以执行满足条件的case的下一个case，是为了兼容C语言中的case设计的。

goto语句通过标签进行代码间的无条件跳转。goto语句可以在快速跳出循环、避免重复退出上有一定的帮助。Go语言中使用goto语句能简化一些代码的实现过程。 例如双层嵌套的for循环要退出时：

练习

  • 99乘法表
    1. func x() {
    2.   for i := 1; i < 10; i++ {
    3.       for j := 1; j <= i; j++ {
    4.           fmt.Printf("%d * %d = %-2d ", j, i, i*j)
    5.       }
    6.       fmt.Println()
    7.   }
    8. }