6 Go外壳：分支与循环

2019-07-05 本文已影响9人 GoFuncChan

一、分支结构

1.if语句

go的if语句有如下特征：

条件表达式必须结果为布尔类型
声明语句/条件表达式不带小括号
代码块的左花括号必须紧随条件表达式
条件表达式前支持声明语句，以分号相隔

基本结构:

if optionalStatement1;booleanExpression1 {
    //block1
}else if optionalStatement1;booleanExpression1 {
    //block2
}else {
    //block3
}

示例：


//基本条件判断语句
if a > 100 {
    fmt.Println("a大于100")
} else if a <= 100 || a >= 50 {
    fmt.Println("a在50-100之间")
} else {
    fmt.Println("a小于50")
}

//经典用法
if a:=compute(); a<0 {
    fmt.Println("a<0")
}else{
    fmt.Println("a>=0")
}

2.switch表达式开关

switch语句特征：

支持多声明语句，用分号相隔
声明语句不带小括号
代码块的左花括号必须紧随条件表达式
支持case子句合并
支持可选default语句
case子句不会自动向下贯穿，因此没有必要break，如需case向下贯穿，只需使用fallthrough语句
如果case或default中出现break，则switch会立即跳出，控制权移交到switch后面的程序体
如果break语句声明了一个标签，控制权会移交到标签处最里层的for、switch或select语句

基本结构：

switch optionalStatement1;optionalStatement2 {
    case expressionList1:
        //block1 [fallthrough/break LABEL]
    case expressionListN:
        //blockN [fallthrough/break LABEL]
    default:
        //blockD
}

示例：

//选择switch:条件表达式的结果落在多个不同的孤立值上
switch a {
case 1:
    fmt.Println("666")
case 2:
    fmt.Println("not bad")
default:
    fmt.Println("undefind")
}

//选择switch：合并相同case
switch a {
case 1, 2, 3:
    fmt.Println("666")
case 4, 5, 6:
    fmt.Println("oh no!")
default:
    fmt.Println("bull shit")

}

//选择switch：判断参数下移到case
switch {
case a > 100:
    fmt.Println("a大于100")
case a <= 100 || a >= 50:
    fmt.Println("a在50-100之间")
case a < 50:
    fmt.Println("a小于50")

}

//经典用法：
//1.隐藏接收变量，只需一个声明语句
//2.使用逗号，不用fallthrough
switch Suffix(file) {
    case ".gz":
        return GzipFileList(file)
    case ".tar",".tar.gz",".tgz":
        retrun TarFileList(file)
    case ".zip":
        return ZipFileList(file)
}

3.switch类型开关

switch类型开关也为go语言特有，用于不知类型的情况下，对多种类型做类型断言的情况。所谓类型开关基于类型断言。

类型断言

如果我们一开始知道类型，就用类型断言

用法：

resultOfType ,boolean := exoression.(Type) //此为安全的类型断言
resultOfType := expression.(Type) //此为非安全类型断言，失败时panic

示例：

var a interface{} = 11
var b interface{} = []string{"go","func","chan"}

//非安全的类型断言
c := a.(int) //如出错，则直接panic，不建议这种做法
fmt.printf("%T->%d\n",c,c)

//安全的类型断言
if d,ok := a.(int);ok{
    fmt.printf("%T->%d\n",d,d)
}

if e,ok := b.([]string);ok{
    fmt.printf("%T->%q\n",e,e)
}

//int->11
//int->11
//[]string->["go" "func" "chan"]

类型开关

如果类型是许多可能类型的一种，那就需要使用类型开关
用法：

switch optionalStatement;typeSwitchGuard {
    case typeList1:block1
    ...
    case typeListN:blockN
    default:blockD
}

示例：

func TypeSwitcher(items ...interface{}) {
    for i, t := range items {
        switch t.(type) {
        case int:
            fmt.Printf("item #%d is int\n", i)
        case bool:
            fmt.Printf("item #%d is boolean\n", i)
        case string:
            fmt.Printf("item #%d is string\n", i)
        case []byte:
            fmt.Printf("item #%d is byte\n", i)
            //...指定更多类型
        default:
            fmt.Printf("item #%d is unkonw\n", i)

        }
    }
}

4.select通道多路复用

select语句也为go语言特有分支结构语句，一般用于go并发编程的通道多路复用，这部分的知识会在go并发专题详细说明。

二、循环结构

go的循环语句很简单,只有for，不像其他语言除了for还有while/do while/foreach，这个一直想吐槽，为啥一种结构能解决的要搞那么复杂呢？go这点很干脆，好用的结构，一种就够了！