if else、switch、for的特点是什么

流程控制是计算机运算领域的用语，意指在程序运行时，个别的指令（或是陈述、子程序）运行或求值的顺序。不论是在声明式编程语言或是函数编程语言中，都有类似的概念。

if-else

if-else特点：

条件语句不需要使用小括号()包起来;

花括号{}必须有，并且左花括号{必须和if或else在同一行;

在if之后，条件语句之前可以添加变量初始化语句，使用;分隔。

package main

import "fmt"func main() {
   if 7%2 == 0 {
       fmt.Println("7 is even")
   } else {
       fmt.Println("7 is odd") // 7 is odd
   }

   if 8%4 == 0 {
       fmt.Println("8 is divisible by 4") // 8 is divisible by 4
   }

   if num := 9; num "is negative")
   } else if num "has 1 digit") // 9 has 1 digit
   } else {
       fmt.Println(num, "has multiple digits")
   }
}

switch

switch特点：

左花括号 { 必须和 switch 在同一行;

条件表达式不限制常量或者整数;

switch 后可添加变量初始化语句，使用 ; 分割;

可以不设定条件表达式，在此种情况下，整个 switch 结构与多个 if-else 的逻辑作用等同;

单个 case 中可以出现多个结果选项;

在 case 中添加 fallthrough 关键字，会继续执行紧跟的下一个 case，不需要判断 case 的条件语句;

switch 支持 default 语句，当所有 case 都不满足时，执行 default 语句。

package main

import (
   "fmt"   "time")

func main() {
   i := 2
   fmt.Print("write ", i, " as ")
   switch i {
   case 1:
       fmt.Println("one")
   case 2:
       fmt.Println("two") // write 2 as two
       fallthrough
   case 3:
       fmt.Println("three") // three
   case 4, 5, 6:
       fmt.Println("four, five, six")
   }

   switch num := 9; num {
   case 1:
       fmt.Println("one")
   default:
       fmt.Println("nine") // nine
   }

   switch time.Now().Weekday() {
   case time.Saturday, time.Sunday:
       fmt.Println("it's the weekend")
   default:
       fmt.Println("it's a weekday") // it's a weekday
   }

   t := time.Now()
   switch {
   case t.Hour() s before noon")
   default:
       fmt.Println("it's after noon") // it's after noon
   }
}

for

for特点：

条件表达式不需要使用小括号 () 包起来;

花括号 {} 必须有，并且左花括号 { 必须和 for 在同一行;

支持 continue 和 break。

package main

import (
   "fmt")

func main() {
   i := 1
   // 只有条件
   for i for j := 7; j for {
       fmt.Println("loop")
       break   }

   // 遍历数组
   a := [...]int{10, 20, 30, 40}
   for i := range a {
       fmt.Println(i)
   }
   for i, v := range a {
       fmt.Println(i, v)
   }

   // 遍历切片
   s := []string{"a", "b", "c"}
   for i := range s {
       fmt.Println(i)
   }
   for i, v := range s {
       fmt.Println(i, v)
   }

   // 遍历字典
   m := map[string]int{"a": 10, "b": 20, "c": 30}
   for k := range m {
       fmt.Println(k)
   }
   for k, v := range m {
       fmt.Println(k, v)
   }
}

goto，break，continue

goto 特点：

只能在函数内跳转，需要配合标签一起使用;

不能跳过内部变量声明语句;

只能跳到同级作用域或者上层作用域内，不能跳到内部作用域内。

package main

import (
   "fmt")

func main() {
   // 跳出循环
   for i := 0; ; i++ {
       if i == 2 {
           goto L1
       }
       fmt.Println(i)
   }
L1:
   fmt.Println("Done")

   // 跳过变量声明，不允许
   //  goto L2
   //  j := 1
   // L2:
}

break 特点：

单独使用，用于跳出 break 当前所在的 for、 switch、 select 语句的执行;

和标签一起使用，用于跳出标签所标识的 for、 switch、 select 语句的执行，可用于跳出多重循环，但标签和 break 必须在同一个函数内。

package main

import (
   "fmt")

func main() {
   // break 跳转到标签处，然后跳过 for 循环
L3:
   for i := 0; ; i++ {
       for j := 0; ; j++ {
           if i >= 2 {
               break L3
           }
           if j > 4 {
               break           }
           fmt.Println(i, j)
       }
   }
}

continue 特点：

单独使用，用于跳出 continue 当前所在的 for 循环的本次迭代;

和标签一起使用，用于跳出标签所标识的 for 语句的本次选代，但标签和 continue 必须在同一个函数内。

package main

import (
   "fmt")

func main() {
   // continue 跳转到标签处，然后执行 i++
L4:
   for i := 0; ; i++ {
       for j := 0; j if i > 4 {
               break L4
           }
           if i >= 2 {
               continue L4
           }
           if j > 4 {
               continue           }
           fmt.Println(i, j)
       }
   }
}

除此之外，还有 break 和 continue，都可以搭配循环语句和跳转语句使用。跳转语句在某些场景下会非常实用，但也很容易出现一些莫名其妙的问题，所以使用起来要更谨慎些。