GO学习笔记(6)

六. 流程控制

　　6.1. if...else...

func ifElse() {
    // 1. 语法
    if a := 2; a == 1 {
        fmt.Println(1)
    }else {        // else 必须紧跟在if结束的}后面,不能换行
        fmt.Println(2)
    }
    
    // 2. GO语言不支持三目运算
    // b := a > 0 ? a : 1
}

　　6.2. switch

func switchDemo()  {
    // 在GO语言中,switch分支表达式可以是任意类型
    // 可以省略 break, 默认匹配到后自动结束
    // fallthrough:该关键字可以强制执行后面代码
    score := 80
    switch score {
    case 80:
        fmt.Println("你的分数是", score)
        fallthrough
    case 90:
        fmt.Println("不错呀,你的分数是", score)
    default:
        fmt.Println("默认值,你的分数是", score)
    }
    /** 因为case 80的代码块里有fallthrough,所以执行结果为:
    你的分数是 80
    不错呀,你的分数是 80
     */

    // type-switch: 可以用来判断某个interface变量中实际存储的变的类型
    var a interface{}
    switch a.(type) {
    case int:
        fmt.Println("a 的类型是 int")
    case float32:
        fmt.Println("a 的类型是 float32")
    case string:
        fmt.Println("a 的类型是 string")
    case nil:
        fmt.Println("a 的类型是 nil")
    default:
        fmt.Println("不晓得")
    }
}

　　6.3. select

　　　　6.3.1. select基本使用

func selectDemo() {
    // 1. 每个case都必须是一个通信
    // 2. select随机执行一个可运行的case, 如果没有case可运行, 则阻塞,知道有case可运行
    var c1, c2, c3 chan int
    c1 = make(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")
    }
}

　　　　6.3.2. select经典用法1 (超时判断)

// 超时判断
var resChan = make(chan int)
func test() {
    select {
    case data := <-resChan:
        doData(data)
    case <-time.After(time.Second * 3):
        fmt.Println("request time out")
    }
}
func doData(data int) {
    fmt.Println("doData:", data)
}

　　　　6.3.3. 退出

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

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

　　　　6.3.4. 判断channel是否阻塞

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

　　6.4. 循环

　　　　6.4.1 for

func forDemo() {
    s := "qwerty"

    // 和其他语言类似
    for i, l := 0, len(s); i < l; i++ {
        fmt.Println(i, s[i])
    }
    
    // 和while类似
    l := len(s)
    for l >0{
        fmt.Println(s[l-1])
        l--
    }
    
    // 死循环
    for  {
        fmt.Println(s)
    }
}

　　　　6.4.2.  for...range

func forRange()  {
    a := "qwerty"
    for i, n := range a{
        if n=='e' {
            break
        }
        fmt.Println(i, n)
    }
    for _,n := range a{
        if n == 'e' {
            continue 
        }
        fmt.Println(n)
    }
    for range a{
        fmt.Println(a)
    }
}

 

判断channel是否阻塞