Go语言入门[三] 条件和循环

条件语句

if…else

• Go语言提供了和其它语言类似的if..else语句，语法结构不同的是，Go语言中和条件相关的语句都不需要括号进行标识（当然如果是为了改变运算的优先级顺序，那就另当别论）

package main

import "fmt"

func main() {
    a := 10
    if a > 10 {
        fmt.Println("a大于10")
    } else if (a < 10) { //加上括号也可以，但是IDE一般建议去掉括号
        fmt.Println("a小于10")
    } else {
        fmt.Println("a的值等于", a)
    }
}

• Go语言还为if...else的使用提供了另一种便利，我们可以在条件表达式之前再写一个任意的表达式，两个表达式之间用;号隔开

package main

import "fmt"

func main() {
    a := 3
    if b := Sum(1,2); a > 10 {
        fmt.Println("a大于10")
        fmt.Println(b)
    } else if (a < 10) {
        fmt.Println("a小于10")
        fmt.Println(b)
    } else {
        fmt.Println("a的值等于", a)
        fmt.Println(b)
    }
    //这里超出了b的作用域，会报编译错误
    //fmt.Println(b)
}
func Sum(x int,y int) int {
    return x+y
}

• 运行结果如下所示

$ go run hello.go
a小于10
3

• 值得注意的是，在前面的表达式中我们还把Sum(1,2)的值赋给了b这个变量，而这个变量的作用域 只包含整个if..else 表达式，如果在代码块之外，会报错。

switch…case

• Go对switch...case 的功能进行了进一步的完善和扩展。switch后可以不接条件表达式，case也比C++/C更加强大，无需是一个固定的值，每一个case后都是一个独立的代码块，执行后会直接跳出switch，无需手写break。理论来说，任何if...else都可以完美改写为switch..case的形式。

package main

import "fmt"

func main() {
    a := 3
    switch {

    }
    switch a {
    case 1:
        fmt.Println("one")
    case 2,20,22,220:
        fmt.Println("two")
    case 3,4,5,6,7,8,9:
        fmt.Println("three")
    default:
        fmt.Println("default")
    }
}

• default后跟的语句相当于多重if...else最后的一个else，当所有case都不匹配时，执行default代码块里的内容

• 从以上的代码可以看出，case后可以跟不只一个条件，但case后接的值也要跟switch后表达式的值匹配，这一切都依赖于Go语言的类型推导。如果我们新建了一个case false:就会报编译错误，因为Go推导出false的类型是bool，和a所在的int不匹配

• Type Switch：我们也可以使用switch语句，来判断对应变量的类型是否匹配

package main

import "fmt"

func main() {
   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("未知型")     
   }   
}

• 运行结果

$ go run hello.go
x 的类型 :<nil>

• 这里需要的interface我们将在后文讲述，这里仅作示例使用

• 如果我们想一个case 判断成功后，直接执行其下的所有语句该怎么办？Go语言为我们提供了这样一个关键字：fallthrough。如果该case匹配成功，在遇到fallthrough会执行下面所有的case，而不会判断case是否匹配

package main

import "fmt"

func main() {

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

• 运行结果如下所示

2、case 条件语句为 true
3、case 条件语句为 false
4、case 条件语句为 true

• 值得注意的是，这里的default语句并没有被执行。fallthrough执行的语句不包括default，它执行的顺序也与在switch...case里的书写顺序无关。无论default放在开头还是句尾，它一定是switch...case中最后执行的语句。

select

• select只用于Go中的通道操作，每一个case其后必须跟上一个通道操作,发送/接收其一。

• 此部分详情移转后文与通道相关内容。

循环语句

• Go中减少了循环语句的关键字。与其它语言的for/while并存不同，Go直接删去了while/do..while，只保留for来应付所有形式的循环使用情况。虽然变少了，但是也变强了。

package main

import "fmt"

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

• 普通的用法仍然是经典的三段式：表达式；条件表达式；末尾循环体。但如果我们想实现while的效果，只需要保留一个条件即可

package main

import "fmt"

func main() {
	i := 0
	for i < 10 { //和其它语言中的while(i<10)一致
		fmt.Println(i)
		i++
	}
}

• 书写死循环体则更简单，其它语言中大抵得书写成for(;;)或while(true)的形式，Go中则直接可以略去任何条件表达式，直接表示死循环。同时，对于跳出循环和控制循环的进行，Go提供了break，continue和goto三个关键字。goto的应用场景较少这里略过，只演示前两个关键字的用法。

package main

import "fmt"

func main() {
	a := 0
	LOOP:
	for {
		for {
			fmt.Println(a)
			a++
			if a >= 10 {
				break LOOP //跳出循环至LOOP所在的层级
			}else{
				continue
			}
		}
	}
}