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

流程控制

条件语句------if-else

go 复制代码

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

注：

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

eg:

go 复制代码

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

选择语句------switch-case

go 复制代码

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

eg:

go 复制代码

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

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

go 复制代码

 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("未知")
  }

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

go 复制代码

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

循环语句------for-range

go 复制代码

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

for 后可接三种类型表达式

接一个条件表达式
eg:

go 复制代码

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

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

go 复制代码

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

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

go 复制代码

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

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

go 复制代码

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

延迟语句------defer

1.延迟调用

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

go 复制代码

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

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

2.变量快照

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

go 复制代码

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

3.多个defer反序调用

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

go 复制代码

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，你可以写出这样的代码

go 复制代码

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 后的函数。

go 复制代码

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

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