Go的流程控制语句

Go的流程控制语句 Go的流程控制语句 for

Go 只有一种循环结构：for 循环。
和 C、Java、Javascript 之类的语言不同，Go 的 for 语句后面的三个构成部分外没有小括号（）

package main

import "fmt"
   //寻常for循环
func main() {
   sum := 0
   for i := 0; i <= 10; i++ {
      sum += i
   }
   fmt.Println(sum)
}

while

package main

import "fmt"
   //while
func main() {
   sum := 1

   //法一
   for ; sum <= 10; {
      sum += sum
   }
   fmt.Println(sum)


   // 法二 更像 While 语句形式
   for sum <= 10{
      sum += sum
   }
   fmt.Println(sum)
}

For-each range

这种格式的循环可以对字符串、数组、切片等进行迭代输出元素。

package main

import "fmt"

func main() {
   strings := []string{"google","runoob"}
   for i,s := range strings{
      fmt.Println(i,s)
   }

   numbers := [6]int{1, 2, 3, 5}
   for i,x:= range numbers{
      fmt.Printf("第%d位x的值 = %dn",i,x)
   }
}

if

​ Go 的 if 语句与 for 循环类似，表达式外无需小括号 ( ) ，而大括号 { } 则是必须的。

package main

import "fmt"

func main() {
   
   var a int = 10

   
   if a < 20 {
      
      fmt.Printf("a 小于 20n" )
   }
   fmt.Printf("a 的值为 : %dn", a)
}

switch

switch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case.

如果我们需要执行后面的 case，可以使用 fallthrough 。

package main

import "fmt"

func main() {
   test5()
}
//switch
func test3() {
   
   var grade string = "B"
   var marks int = 90

   switch marks {
   case 90: grade = "A"
   case 80: grade = "B"
   case 50,60,70 : grade = "C"
   default: grade = "D"
   }

   switch {
   case grade == "A" :
      fmt.Printf("优秀!n" )
   case grade == "B", grade == "C" :
      fmt.Printf("良好n" )
   case grade == "D" :
      fmt.Printf("及格n" )
   default:
      fmt.Printf("不及格n" )
   }
   fmt.Printf("你的等级是 %sn", grade )
}

//Type Switch
func test4() {
      //interface：一个空类型
   var x interface{}

   switch i := x.(type) {
   case nil:
      fmt.Printf(" x 的类型 :%T",i)
   case int:
      fmt.Printf("x 是 int 型")
   case float64:
      fmt.Printf("x 是 float64 型")
   case func(int) float64:
      fmt.Printf("x 是 func(int) 型")
   case bool, string:
      fmt.Printf("x 是 bool 或 string 型" )
   default:
      fmt.Printf("未知型")
   }
}
//fallthrough
//如果 case 带有 fallthrough，程序会继续执行下一条 case，且它不会去判断下一个 case 的表达式是否为 true。
//但是下面的6并没有输出
//说明default不受fallthrough管
func test5() {

   switch {
   case false:
      fmt.Println("1、case 条件语句为 false")
      fallthrough
   case true:
      fmt.Println("2、case 条件语句为 true")
      fallthrough
   case false:
      fmt.Println("3、case 条件语句为 false")
      fallthrough
   case true:
      fmt.Println("4、case 条件语句为 true")
   case false:
      fmt.Println("5、case 条件语句为 false")
      fallthrough
   default:
      fmt.Println("6、默认 case")
   }
}

select

select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信 *** 作，要么是发送要么是接收。
select 随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行。

chan:
chan又称之为通道，形式类似于管道，内容从一头被送进去，从另一头被读取出来。
定义通道时，需要指定数据类型，就是只允许这个指定数据类型的变量通过这个通道
golang中在初始化通道类型变量时，可以将通道分为两种情况，一种是带缓冲的通道，另一种是不带缓冲的通道。

package main

import "fmt"

func main() {
   var c1, c2, c3 chan int
   var i1, i2 int
   select {
   case i1 = <-c1:
      fmt.Printf("received ", i1, " from c1n")//接收
   case c2 <- i2:
      fmt.Printf("sent ", i2, " to c2n")//发送
   case i3, ok := (<-c3):  // same as: i3, ok := <-c3
      if ok {
         fmt.Printf("received ", i3, " from c3n")//接收
      } else {
         fmt.Printf("c3 is closedn")
      }
   default:
      fmt.Printf("no communicationn")
   }
}

break

可使用标记

package main

import "fmt"

func main() {

   // 不使用标记
   fmt.Println("---- break ----")
   for i := 1; i <= 3; i++ {
      fmt.Printf("i: %dn", i)
      for i2 := 11; i2 <= 13; i2++ {
         fmt.Printf("i2: %dn", i2)
         break  //只跳出了一个循环
      }
   }

   // 使用标记
   fmt.Println("---- break label ----")
re:    //标记！
   for i := 1; i <= 3; i++ {
      fmt.Printf("i: %dn", i)
      for i2 := 11; i2 <= 13; i2++ {
         fmt.Printf("i2: %dn", i2)
         break re   //回到标记处
      }
   }
}