Golang之路---02 基础语法——流程控制(if-else , switch-case , for-range , defer)

流程控制

条件语句——if-else

if 条件 1 {
  分支 1
} else if 条件 2 {
  分支 2
} else if 条件 ... {
  分支 ...
} else {
  分支 else
}

注：

1. Golang编译器，对于 { 和 } 的位置有严格的要求，它要求 else if （或 else）和 两边的花括号，必须在同一行。
2. 由于 Golang是强类型，所以要求你条件表达式必须严格返回布尔型的数据（nil 和 0 和 1 都不行）。

eg:

   score:=70
   if score > 90{
      fmt.Println("优秀")
   }else if score >80{
      fmt.Println("良好")
   }else{
      fmt.Println("差")
   }

选择语句——switch-case

switch 表达式 {
    case 表达式1:
        代码块
    case 表达式2:
        代码块
    case 表达式3:
        代码块
    case 表达式4:
        代码块
    case 表达式5:
        代码块
    default:
        代码块
}

eg:

func main() {
  education := "本科"
  switch education{
  case "研究生":
   fmt.Println("是研究生")
  case "本科":
   fmt.Println("是研究生")
  case "高中":
   fmt.Println("是高中生")
  default:
   fmt.Println("学历未达标")
  }
}

1. case后可以接多个条件，多个条件之间是或的关系，用逗号相隔。

 month := 2
  switch month{
  case 3,4,5:
   fmt.Println("春天")
  case 6,7,8:
   fmt.Println("夏天")
  case 9,10,11:
   fmt.Println("秋天")
  default:
   fmt.Println("未知")
  }

2. case后接常量时，常量只能出现一次。
3. switch后可以接函数，只要保证case后的值类型与函数的返回值一致即可。

  score:=90
  switch judge(score){
  case true:
   fmt.Println("成绩合格")
  case false:
   fmt.Println("成绩不合格")
  }

循环语句——for-range

for [condition |  ( init; condition; increment ) | Range]
{
   statement(s);
}

for 后可接三种类型表达式

1. 接一个条件表达式
   eg:

func main() {
   a:=1
   for a<= 5{
      fmt.Println(a)
      a++
   }
}

2. 接三个表达式
   三个表达式之间用;分隔
   第一个表达式：初始化变量
   第二个表达式：设置循环控制条件
   第三个表达式：控制变量的变化

 for a:=1 ; a<=5 ;a++{
      fmt.Println(a)
   }

3. 接一个 range 表达式
   range 后可接数组、切片，字符串等
   由于 range 会返回两个值：索引和数据，若你后面的代码用不到索引，需要使用 _ 表示 。

myarr := [...]string{"apple","orange","pair"}
   for index,fruit := range myarr{
      /*
      0号的水果为apple
      1号的水果为orange
      2号的水果为pair
      */
      fmt.Printf("%d号的水果为%s\n",index,fruit)
   }

   // for _,fruit := range myarr

4. 不接表达式无限循环
   Golang中没有while循环，当不加任何的判断条件时，就相当于你每次的判断都为true。可以使用break来退出循环体，也可以使用continue直接跳到下一循环。

func main() {
    i:=1
   for{
      if i>5{
         break
      }
      //1 2 3 4 5 
      fmt.Printf("%d ",i)
      i++
   }
}

延迟语句——defer

1.延迟调用

defer 的用法很简单，只要在后面跟一个函数的调用，就能实现将这个 xxx 函数的调用延迟到当前函数执行完后再执行。

func testfun(){
   fmt.Println("B")
}

func main() {
  defer testfun()
  fmt.Println("A")
}
/*
A
B
*/

2.变量快照

使用 defer 只是延时调用函数，此时传递给函数里的变量，不应该受到后续程序的影响。

func main() {
  name := "fruit"
  defer fmt.Println(name)
  //后续调用 defer 的时候，仍然使用未重新赋值的变量值，就好在 defer 这里，给所有的这是做了一个快照一样。
  name = "roast chicken"
  fmt.Println(name)
}
/*
roast chicken
fruit
*/

3.多个defer反序调用

多个defer 是反序调用的，有点类似栈一样，后进先出。

func main() {
  name := "fruit"
  defer fmt.Println(name)
  
  name = "roast chicken"
  defer fmt.Println(name)

  name = "cabbage"
  defer fmt.Println(name)
}
/*
cabbage
roast chicken
fruit
*/

4.defer存在的意义

• 释放占用的资源
• 捕捉处理异常
• 输出日志

eg:
若是没有 defer，你可以写出这样的代码

func f() {
    r := getResource()  //0，获取资源
    ......
    if ... {
        r.release()  //1，释放资源
        return
    }
    ......
    if ... {
        r.release()  //2，释放资源
        return
    }
    ......
    if ... {
        r.release()  //3，释放资源
        return
    }
    ......
    r.release()     //4，释放资源
    return
}

使用了 defer 后，代码就显得简单直接，不管你在何处 return，都会执行 defer 后的函数。

func f() {
    r := getResource()  //0，获取资源

    defer r.release()  //1，释放资源
    ......
    if ... {
        ...
        return
    }
    ......
    if ... {
        ...
        return
    }
    ......
    if ... {
        ...
        return
    }
    ......
    return
}