Go语言的流程控制

01.if分支结构语句

条件语句：
根据是否满足条件，有选择地跳转到相应的执行序列。

• if分支结构语句一般会由关键字if、条件表达式和由花括号包裹的代码块组成。
• 其中代码块为：包含了若干表达式和语句的序列。在Go语言中，代码块必须由花括号包裹。

单分支：

if <condition> {
    <Execute statement>
}

双分支：

if <condition> {
    <Execute statement>
}else{
    <Execute statement>
}

多分支：

if <condition> {
    <Execute statement>
}else if <condition> {
    <Execute statement>
}....
else{
    <Execute statement>
}

• 1.思考：运行结果是什么？

package main
import "fmt"
func main() {
    var a = 1
    var b = 2
    //如果 if 语句条件为真，则会执行相对应的代码
    if a <= b{
        fmt.Println("a <= b")
    }else {
        fmt.Println("a > b")
    }
}




//运行结果为：
a <= b

• if 语句的条件判断表达式不需要也不能加小括号，即 ()，这是 Go 语言与其他语言 if 语句的区别。
• if 语句后面的大括号必须跟条件表达式写在一行，不能换行写，换行写会导致编译错误。

• 2.思考：运行结果是什么？

package main
import "fmt"
func main() {
    var a = 10
    var b = 20
    // 如果 if 语句条件为真，则不会执行 else if 相对应的代码
    if a > 5{
        fmt.Println("a > 5")
    }else if a < b{
        fmt.Println("a < b")
    }
}



//运行结果为：
a > 5

• if 语句与 else if 语句是互斥的执行
• 因为 if 语句已经成立了，所以 else if 里面的语句未能执行。

• 3.思考：运行结果是什么？

package main
import  "fmt"
func main() {
    var a = 11
    var b = 5
    if a > 20{
        fmt.Println("a > 20")
    }else if a > 15{
        fmt.Println("a > 15")
    }else if a > 10{
        fmt.Println("a > 10")
    } else if a > b{
        fmt.Println("a > b")
    }
}




//运行结果为：
a > 10

• 多个 else if 语句，会被依次判断，直到其中一个满足条件的被执行

• 4.思考：运行结果是什么？

package main
import "fmt"
func main() {
var a = 10
    if a > 5{
        if a > 20{
            fmt.Println("a > 20")
        }else if a > 10{
            fmt.Println("a > 10")
        }else{
            fmt.Println("a > 5")
        }
    }else{
        fmt.Println("a <= 5")
    }
}



//运行结果为：
a > 5

• if 语句里面可以嵌套多层的 if、else if以及else

• 注意事项：

02.Switch选择语句

• 定义：
  根据不同条件来执行不同动作，每一个条件对应一个case分支。

• switch语句的执行过程从上至下，直到找到匹配项
  匹配项后不需要再加break

• 每一个switch语句只能包含一个可选的default分支，若没有找到匹配项，会默认执行default分支中的代码块

• 有表达式：

switch 表达式{
//case后的条件可以是多个值
case value1，value2: 
<Execute statement>1
case value3:
    <Execute statement>2
......
//若以上条件都不满足，则执行下面的语句
default:
    <Execute statement>n
}

• 无表达式：

switch {
case <condition>1:
    <Execute statement>1
case <condition>2:
    <Execute statement>2
......
//若以上条件都不满足，则执行下面的语句
default:
	<Execute statement>n
}

• 1.思考：运行结果是什么？

package main
import "fmt"
func main() {
    score := 80
    switch score {
    case 90:
        fmt.Println("A")
    case 80:
        fmt.Println("B")
    case 70:
        fmt.Println("C")
    default:
        fmt.Println("D")
    }
}




//运行结果为：
B

首先定义整数变量 score
接着使用 switch 语句判断 score
如果是 90，则打印 A
如果是 80，则打印 B
如果是 70，则打印 C
其他情况，则打印 D

• 2.思考：运行结果是什么？

package main
import "fmt"
func main() {
    score := 80
    if score==90{
        fmt.Println("A")
    }else if score==80{
        fmt.Println("B")
    }else if score==70{
        fmt.Println("C")
    }else {
        fmt.Println("D")
    }
}






//运行结果为：
B

将上述代码改成if-else写法
如果是 90，则打印 A
如果是 80，则打印 B
如果是 70，则打印 C
其他情况，则打印 D

• 3.思考：运行结果是什么？

package main
import "fmt"
func main() {
    switch score := 80;score {
    case 90:
        fmt.Println("A")
    case 80:
        fmt.Println("B")
    case 70:
        fmt.Println("C")
    default:
        fmt.Println("D")
    }
}




//运行结果为：
B

可以在判断条件前面定义变量
用；号分割

• 4.思考：运行结果是什么？

package main
import "fmt"
func main() {
    score := 66
    switch {
    case score > 90:
        fmt.Println("A")
    case score > 80:
        fmt.Println("B")
    case score > 70, score > 60:  //可以放多个条件
        fmt.Println("C")
    default:
        fmt.Println("D")
    }
}



//运行结果为：
 C

switch后面可以没有条件表达，将条件放在case的后面，也可以放多个条件，但每个case后面的条件不能重复。

• 5.思考：运行结果是什么？

package main
import "fmt"
func main() {
    switch score := 80;score {
    case 90:
        fmt.Println("A")
    case 80:
        fmt.Println("B")
        fallthrough  //强制执行下一case后面的代码
    case 70:
        fmt.Println("C")
    default:
        fmt.Println("D")
    }
}




//运行结果为：
B
C

switch语句支持使用fallthrough关键字强制执行下一case里面的代码

• 6.思考：运行结果是什么？

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>

通过switch语句判断类型

• Switch选择语句注意事项:

1. switch/case 后是一个表达式（即：常量，变量，一个有返回的函数都可以）；
2. case后的各个表达式的值的数据类型，必须和switch的表达式数据类型一致；
3. case后面可以带多个表达式，使用逗号间隔；
4. case后面的表达式如果是常量值，则要求不能重复；
5. case后面不需要带break，程序匹配到一个case后就会执行对应的代码块，然后退出switch，如果一个都匹配不到，则执行default;
6. default语句不是必须的；
7. switch后也可以不带表达式，类似 if --else分支来使用；
8. switch后也可以直接声明一个变量，分号结束，不过不推荐；
9. switch穿透：如果在case语句增加fallthrough,则会继续执行下一个case，默认只穿透一层；
10. type-switch：来判断interface变量中实际指向的变量类型。

03.for循环

• Go语言中的循环

• Go语言中的循环逻辑通过for关键字实现
• Go语言没有while关键字，不存在while循环
• for循环可以执行指定循环次数，从而让程序多次执行相同的代码块
• for循环用的最多的地方是：遍历数组或切片等

• for循环三种方式

• 常见的for循环，在指定条件下运行，支持初始化语句
• 条件表达式控制循环：当满足条件时会进入循环。进入循环后，当条件不满足时会跳出循环。
• 无限循环：不断的执行程序，也称作死循环，通常会配合break关键字进行使用。

• for循环语法

for init; condition; post { 
    expression
}

语法详解:

• init：一般为赋值表达式，给控制变量赋初值
• condition：关系表达式或逻辑表达式，循环控制条件
• post：一般为赋值表达式，给控制变量增量或减量
• 判别赋值表达式 init 是否满足给定 condition 条件，若其值为真，满足循环条件，则执行循环体内语句，然后执行 post，进入第二次循环，再判别 condition;否则判断condition 的值为假，不满足条件，就终止for循环，执行循环体外语句

• 1.思考：运行的结果是什么？

package main
import "fmt"
func main() {
    /*for 初始化条件；判断条件；条件变化{
    	1+2+…+100累加
    }*/
    sum := 0
    for i := 1; i <= 100; i++ {
        sum += i
    }
    fmt.Println("sum = ", sum)
}




//运行结果为：
sum =  5050

• 2.思考：运行的结果是什么？

package main
func main() {
    s := "abc"
    for i, n := 0, len(s); i < n; i++ {
        println(s[i])
    }
}




//运行结果为：
97
98
99

package main
import "fmt"
func main() {
    s := "abc"
    n := len(s)
    for n > 0 {
        fmt.Println(s[n-1])
        n--
    }
}



//运行结果为：
99
98
97

• 3.思考：运行的结果是什么？

package main
import "fmt"
func main() {
    s := "abc"
    for {
        fmt.Println(s)
    }
}



//运行结果为：
abc
abc
......

package main
func length(s string) int {
    println("call length.")
    return len(s)
}
func main() {
    s := "abcd"
    for i, n := 0, length(s); i < n; i++ {
        println(i, s[i])
    }
}



//运行结果为：
call length.
0 97
1 98
2 99
3 100

• for循环嵌套

• 4.思考：运行的结果是什么？

package main
import "fmt"
func main() {
   var i, j int
   for i=2; i < 100; i++ {
      for j=2; j <= (i/j); j++ {
         if(i%j==0) {
            break 
         }
      }
      if(j > (i/j)) {
         fmt.Printf("%d是素数\t", i)
      }
   }  
}



//运行结果为：    
    2是素数	3是素数	5是素数	7是素数	11是素数	
    13是素数	17是素数	19是素数	23是素数	29是素数	
    31是素数	37是素数	41是素数	43是素数	47是素数	
    53是素数	59是素数	61是素数	67是素数	71是素数	
    73是素数	79是素数	83是素数	89是素数	97是素数	

• for无限循环
  

• 循环中条件语句永远不为 false 则会进行无限循环
• 通常会配合跳出语句，以避免死循环的情况

• 5.思考：运行的结果是什么？

package main
import "fmt"
func main() {
    for true  {
        fmt.Printf("这是无限循环。\n");
    }
}



//运行结果为：
这是无限循环。
这是无限循环。
这是无限循环。
…..

• 范围(range)：

• Go 语言中 range 关键字用于for循环中 迭代数组(array)、切片(slice)、通道(channel)或集合(map) 的元素。
• 在数组和切片中它返回元素的索引值，在集合中返回 key-value 对的 key 值。

• for循环语法

• 其中key 和 value 是可以省略
• 省略前面的key时，使用_占位
• 省略后面的value时，使用_占位或直接空着

• 6.思考：运行的结果是什么？

package main
import "fmt"
func main() {
    str := "abcd"
    //迭代打印每个元素，默认返回两个值：元素索引，元素键值
    for index, value := range str {
        fmt.Printf("str[%d] = %c\n", index, value)
    }
}


//运行结果为：
str[0] = a
str[1] = b
str[2] = c
str[3] = d

• 7.思考：运行的结果是什么？

package main
import "fmt"
func main() {
    str := "abcd"
    //第一个返回值使用"_"忽略，只返回元素
    for  _,value := range str {
        fmt.Println(value)
    }
}



//运行结果为：
97
98
99
100

• 8.思考：运行的结果是什么？

package main
import "fmt"
func main() {
    str := "abcd"
    //第二个返回值使用"_"忽略，只返回元素索引
    for index, _ := range str {
        fmt.Printf("str[%d] = %c\n", index, str[index])
    }
}



//运行结果为：
str[0] = a
str[1] = b
str[2] = c
str[3] = d

• 9.思考：运行的结果是什么？

func main() {
      lines := 8
     for i := 0; i <= lines; i++ {
	for n := 0; n < 2*i+1; n++ {
	 fmt.Print("* ")
	  }
	 fmt.Println()
	}	
}




//运行结果为：
*
 * *
 * * *                             
 * * * * *                         
 * * * * * * *                     
 * * * * * * * * *                 
 * * * * * * * * * * *             
 * * * * * * * * * * * * *         
 * * * * * * * * * * * * * * *     
 * * * * * * * * * * * * * * * * *

04.break语句

break语句作用：

• break语句可以用来结束for循环
• 无论for循环还有几次执行,立即停止
• 可以在break语句后面添加标签，表示退出标签对应的代码块逻辑
• break语句如果不带标签，则默认跳出最内层的for循环

• 思考：运行的结果是什么？

package main
import "fmt"
func main(){
    for i := 0; i < 10; i++ {
        if i > 5 {
            fmt.Println("i>5：",i)
            break
        }
        fmt.Println(i)
    }
}


//运行结果为：
0
1
2
3
4
5
i>5： 6

05.continue语句

• continue语句作用：

• continue 语句 有点像 break 语句。但是 continue 不是跳出循环，而是跳过当前循环执行下一次循环语句
• for 循环中，执行 continue 语句会触发 for 增量语句 increment 的执行
• 在多重循环中，可以用标签 label 标出想 continue 的循环

• 思考：运行的结果是什么？

package main
import "fmt"
func main(){
    for i := 0; i < 10; i++ {
        if i == 3 {
            fmt.Println("i==3:",i)
            continue
        }
        fmt.Println(i)
    }
}



//运行结果为：
0
1
2
i==3: 3
4
5
6
7
8
9

06.goto语句

• goto语句作用：

• goto 语句可以无条件地转移到过程中指定的行
• goto 语句通常与条件语句配合使用。可用来实现条件转移，构成循环，跳出循环体等功能
• 在结构化程序设计中一般不主张使用 goto 语句，以免造成程序流程的混乱，使理解和调试程序都产生困难

• 思考：运行的结果是什么？

package main
import "fmt"
func main() {
fmt.Println("1")
goto next
    fmt.Println("2")
next:
    fmt.Println("3")
}



//运行结果为：
1
3

使用goto跳转到next标签指定的行