Go 中的条件语句（if,swith,select）Go 的条件语句 Go 的if else 模版：注意： else

Go 的条件语句

Go 的if else

模版：

if condition {
    // do something
}

if condition {
    // do something
} else {
    // do something
}

if condition1 {
    // do something
} else if condition2 {
    // do something else
}else {
    // catch-all or default
}

注意：

else if 分支的是没有限制的，但是为了代码的尅地形，还是不要在if 后面加太多的 else if 结构，如果必须使用这种形式，尽可能把吸纳满足的条件放在前面。
关键字 if 和 else 之后的做大括号 { 必须和关键字在同一行，如果你使用了 else if 结构，则前面的代码块的右大括号} 必须和else if 关键字在同一行，这两条规则都是被编译器强制规定的。
在使用gofmt 格式化代码之后，每个分支内的代码都会缩进4个或8个空格，或者1个Tab ，并且右大括号} 与对应的if关键字垂直对齐。
在有些情况下，条件语句两侧的括号可以省略，当条件比较复杂的时候，则可以使用括号让代码更易读，在使用 &&，||，！ 时可以使用括号来提升某个运算优先级，并提高代码的可读性。

一种特殊的写法

if 还有一种特殊的写法，可以在 if 表达式之前加一个执行yuju,执行Connet 后，将错误保存到err 变量中。
err!=nil 才是if 的判断表达式，当 err 不为空时，打印错误并返回。
这种写法可以将返回值与判断结果放在一行进行处理，而且返回值的作用范围被限制在 if 、else 语句组合中。

Tip: 在编程中，变量的作用范围越小，所造成的问题可能性越小，每一个变量代表一个状态，有状态的地方，状态就会被修改，函数的局部变量只会影响一个函数的执行，但全局变量可能会影响所有代码的执行状态，因此限制变量的作用范围对代码的稳定性有很大的帮助。

Go 的switch语句

switch 语法

① switch 执行规则

switch 语句在满足不同条件时执行不同的动作，每个 case 分支都是唯一的，从上到下逐一测试，直到匹配为止，（遇到匹配后则跳出，不再执行后面的语句）

switch 语句执行的过程中从上至下。直到找到匹配项。switch默认情况下 case 匹配项后，自带break 语句（所以我们不需要显式的写break）,匹配成功后就不会再执行其他 case ,如果我们需要匹配到后面的 case 可以使用 fallthrough

不同的 case 之间不需要使用 break 分隔，Go 默认每一个case 之后都有一个break （只是没有写出来），Go 只会执行一个 case。如果想要执行多个 case，需要使用 fallthrough 关键字。

② switch 语法

switch var1(变量) {
    case value1:
        ...
    case value2:
        ...
    default:
        ...
}

var1 是一个变量,可是任何数据类型，值val1 和 val2 是同类型的任意值。数据类型不限，但是必须是相同的类型；或者最终结果为相同类型的表达式。
多条件匹配：在一个 case 语句下可以同时测试多个可能符合条件的值，使用逗号分割他们。

case value1, value2, value3：

Tyoe Switch

switch 语句可以用于type-switch来判断某个 interface 变量中实际存储的变量类型。
语法如下:

switch x.(type){
    case type:
       statement(s);      
    case type:
       statement(s); 
    /* 你可以定义任意个数的case */
    default: /* 可选 */
       statement(s);
}

例子：

package main

import "fmt"

func main() {
	var x interface{}

	switch i := x.(type) { // 带初始化语句
	case nil:
		fmt.Printf("x 的类型 :%T\r\n", 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("未知型")
	}
}

输出结果：x 的类型 :<nil>

fallthrough

使用 fallthrough 会强制执行后面一句 case 语句下的结构体：不会判断下一条 case 的表达式是否为 true ，而是直接执行

package main

import "fmt"

func main() {

	switch {
	case false:
		fmt.Println("1、case 条件语句为 false")
		fallthrough
	case true:      //匹配，从这里开始进入case
		fmt.Println("2、case 条件语句为 true")
		fallthrough
	case false:     //这一句被强制执行
		fmt.Println("3、case 条件语句为 false")
		fallthrough
	case true:      //这一句被强制执行，执行结束后由于没有fallthrough，默认break跳出
		fmt.Println("4、case 条件语句为 true")
	case false:
		fmt.Println("5、case 条件语句为 false")
		fallthrough
	default:
		fmt.Println("6、默认 case")
	}
}

输出结果：

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

Go 中的select 语句

select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。

select 随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行的。

语法

select {
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s);
    /* 你可以定义任意数量的 case */
    default : /* 可选 */
       statement(s);
}

注意：

每个case 都必须是一个通信
所有channel表达式都会被求值
所有被发送的表达式都会被求值
如果任意个通信可以进行，他就执行，其他被忽略
如果有多个case都可以运行，Select 会随机公平的选出一个执行，其他的不会执行。
没有case 可以运行的情况下，如果有default子句，则执行该语句。如果没有default子句，select 将阻塞，直到某个通信可以运行；Go 不会重新对channel或者值进行求值。

例子：

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 c1\n")
	case c2 <- i2:
		fmt.Printf("sent ", i2, " to c2\n")
	case i3, ok := (<-c3): // same as: i3, ok := <-c3
		if ok {
			fmt.Printf("received ", i3, " from c3\n")
		} else {
			fmt.Printf("c3 is closed\n")
		}
	default:
		fmt.Printf("no communication\n")
	}
}

输出结果：no communication

select 的典型用法

超时判断：

//比如在下面的场景中，使用全局resChan来接受response，如果时间超过3S,resChan中还没有数据返回，则第二条case将执行
var resChan = make(chan int)
// do request
func test() {
    select {
    case data := <-resChan:
        doData(data)
    case <-time.After(time.Second * 3):
        fmt.Println("request time out")
    }
}

func doData(data int) {
    //...
}

退出

//主线程（协程）中如下：
var shouldQuit=make(chan struct{})
fun main(){
    {
        //loop
    }
    //...out of the loop
    select {
        case <-c.shouldQuit:
            cleanUp()
            return
        default:
        }
    //...
}

//再另外一个协程中，如果运行遇到非法操作或不可处理的错误，就向shouldQuit发送数据通知程序停止运行
close(shouldQuit)

判断channel是否阻塞

//在某些情况下是存在不希望channel缓存满了的需求的，可以用如下方法判断
ch := make (chan int, 5)
//...
data：=0
select {
case ch <- data:
default:
    //做相应操作，比如丢弃data。视需求而定
}

Go 中的 条件语句（if,swith,select）