Go语言 流程控制

Go语言

5. 流程控制

5.1 if判断

if 表达式1 {
    
    分支1
} else if 表达式2 {
    
    分支2
} else {
    
    分支3
}

【注意】可以只存在表达式1，else if和else语句都是可选的。

【注意】表达式后跟的左括号必须与表达式放在同一行中，否则程序在编译时将会触发错误，导致程序编译无法通过。else if和else语句后跟的左括号也必须和对应表达式处在同一行。

package main

import "fmt"

func main() {
    
   a := 101
   if a > 100 {
    
      fmt.Println(a, "> 100")
   } else if a == 100 {
    
      fmt.Println(a, "= 100")
   } else {
    
      fmt.Println(a, " < 100")
   }
}

if还有一种较为常见的写法，就是在if的表达式前添加一个语句，使用变量接收语句返回的值，通过对该变量的判断再选择执行的分支。

package main

import (
   "fmt"
   "runtime"
)

func main() {
    
   if num := runtime.NumCPU(); num >= 1 {
    
      fmt.Println("程序使用的CPU核数为：", num)
   }
}

由于是在if表达式前定义num变量，num变量的作用域仅限于该分支中。

5.2 循环控制

5.2.1 for循环

Go语言中的循环逻辑通过for关键字实现。不同于其他编程语言，Go语言没有while关键字，不存在while循环。

for 初始语句;条件表达式;赋值表达式 {
    
    循环体
}

package main

import "fmt"

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

5.2.2 break跳出循环

break语句可以用来结束for循环，而且可以在语句后面添加标签，表示退出标签对应的代码块逻辑。

注意：break语句如果不带标签，则默认跳出最内层的for循环。

package main

import "fmt"

func main() {
    
   i := 1
   for {
    
      for {
    
         if i > 5 {
    
            fmt.Println("跳出内层循环")
            break
         }
         fmt.Println(i)
         i++
      }
      fmt.Println("跳出外层循环")
      break
   }
}

也可以使用带标签的break语句，直接跳出最外层的for循环。

package main

import "fmt"

func main() {
    
   i := 1
OuterLoop:
   for {
    
      for {
    
         if i > 5 {
    
            break OuterLoop //跳出OutLoop标签对应的循环
         }
         fmt.Println(i)
         i++
      }
   }
}

5.2.3 continue继续循环

continue语句可以立即结束当前循环体中的逻辑，开始下一次循环。和break语句类似，continue语句后也可跟标签，表示开始标签所对应的循环。

package main

import "fmt"

func main() {
    
OuterLoop:
   for i := 0; i < 2; i++ {
    
      for j := 0; j < 3; j++ {
    
         if j == 1 {
    
            fmt.Println(i, j)
            continue OuterLoop
         }
      }
   }
}

5.3 switch分支

switch语句的执行过程从上至下，直到找到匹配项，匹配项后面也不需要再加break。
每一个switch语句只能包含一个可选的default分支，若没有找到匹配项，会默认执行default分支中的代码块。

switch var1 {
     
    case value1:
    	代码块1
    case value2:
 		代码块2
    default:
    	代码块3
}

变量var1可以是任何类型，但value1和value2必须是相同的类型或最终结果为相同类型的表达式。每个case分支后可跟多个可能符合条件的值，使用逗号分隔它们，例如：case value1,value2,value3。

package main

import "fmt"

func main() {
    
   switch 1 + 1 {
    
   case 1:
      fmt.Println(" 1 + 1 = 1")
   case 2:
      fmt.Println("1 + 1 = 2")
   case 3:
      fmt.Println("1 + 1 = 3")
   default:
      fmt.Println("1 + 1不等于1或2或3")
   }
}

默认情况下，switch匹配成功后就不会执行后续其他case，如果我们需要无条件强制执行后面的 case，可以使用fallthrough关键字。

package main

import "fmt"

func main() {
    
   switch {
    
   case false: //false肯定不执行
      fmt.Println("case1 为 false")
      fallthrough
   case true:
      fmt.Println("case2 为 true")
      fallthrough //这里加上了fallthrough，下一个必定执行
   case false:
      fmt.Println("case3 为 false")
      fallthrough
   default:
      fmt.Println("默认 case")
   }
}

5.4 goto跳转

goto语句用于代码间的无条件跳转。

goto 标签

package main

import "fmt"

func main() {
    
   fmt.Println("Hello")
   goto sign
   fmt.Println("无效代码")
sign:
   fmt.Println("world")
}

5.6 知识拓展

5.6.1 斐波那契数列

package main

import "fmt"

func fibonacci(n int) (res int) {
    
   switch n {
    
   case 1:
      return 1
   case 2:
      return 1
   default:
      return fibonacci(n-2) + fibonacci(n-1)
   }
}
func main() {
    
   n := 6
   fmt.Printf("斐波那契数列第%d项的值为%d", n, fibonacci(n))
}

5.6.2 循环嵌套

for (初始语句;条件表达式;赋值表达式)
{
    
    循环体
    for(初始语句;条件表达式;赋值表达式)
    {
    
        循环体
    }
}

数字金字塔

package main

import "fmt"

func pyramid(n int) {
    
   //n总层数
   for i := 1; i <= n; i++ {
    
      for j := 1; j <= n-i; j++ {
    
         fmt.Print(" ")
      }
      for k := 1; k <= 2*i-1; k++ {
    
         fmt.Print("*")
      }
      fmt.Println()
   }
}

func main() {
    
   n := 9
   pyramid(n)
}