一、分支结构
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这点很干脆，好用的结构，一种就够了！
基本结构：
//1.无限循环
for {
//block
}
//2.条件表达式循环
for booleanExpression {
//block
}
//3.经典:预声明语句+条件语句+操作语句循环
for optionalPreStatement;booleanExpress;optionalPostStatement {
//block
}
//4.用于遍历array、slice、map、strings、channel的for range循环
for index,item := range [strings/slice/array/map/channel] {
//block
}
示例：
//无限循环
for {
fmt.Println("fuck off!!!")
time.Sleep(time.Second)
}
//条件循环
var i = 0
for i<50 {
fmt.Print(i, " ")
i++
}
//经典结构
for i := 1; i <= 50; i++ {
fmt.Print(i, " ")
}
fmt.Println()
//for range循环
a := []int{11, 22, 33, 4, 55, 66, 77, 99, 6745}
for index, value := range a {
fmt.Printf("序号为%d,值为%v\n", index, value)
}
//退出循环
times := 0
for {
if times >= 5 {
break
}
fmt.Println("fuck off!!!")
time.Sleep(time.Second)
times++
}
//循环跳过某个条件
times := 0
for {
if times > 5 {
break
}
if times == 3 {
fmt.Println("fuck you!!!")
time.Sleep(time.Second)
times++
continue
}
fmt.Println("fuck off!!!")
time.Sleep(time.Second)
times++
}
