Go Book / 1 Go Basics / 06 Go外壳:分支与循环

06 Go外壳:分支与循环

一、分支结构

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++
}