流程控制

1.条件判断(if)

1.1 if

1.语法结构

if 布尔表达式 {
  // 布尔表达式为true时执行
}

2. 使用

a := 10
if a  > 3{
  fmt.Println("a > 3 为true")
}

1.2 if...else

1.语法结构

if 布尔表达式 {
  // 布尔表达式为true时执行
} else {
  // 布尔表达式为false时执行
}

2.使用

在if之后，条件语句之前，可以添加变量初始化语句，使用“;”进行分隔。

if a := 10; a  > 3{
  fmt.Println("a > 3 为true时,执行！")
} else {
  fmt.Println("a > 3 为false时,执行！")
}

1.3 if...else if...else

1.语法结构

if 布尔表达式1 {
  // 布尔表达式1为true时执行
} else if (布尔表达式2) {
  // 布尔表达式2为true时执行
} else {
  // 布尔表达式1和2都为false时执行
}

2.使用

package main
import "fmt"
func main() {
 useIf(5)
 useIf(14)
 useIf(23)
 useIf(42)
}
func useIf(a int)  {
 if a <= 10 {
  fmt.Printf("a: %d, a <= 10\n",a)
 } else if a > 10 && a <= 20  {
  fmt.Printf("a: %d, a > 10 && a <= 20 \n",a)
 } else if a>20 && a <= 30 {
  fmt.Printf("a: %d, a > 20 && a <= 30 \n",a)
 } else {
  fmt.Printf("a:%d, a > 30\n",a)
 }
}
/* 输出:
a: 5, a <= 10
a: 14, a > 10 && a <= 20 
a: 23, a > 20 && a <= 30 
a:42, a > 30
*/

1.4 if嵌套

1.语法结构

if 布尔表达式A {
  if 布尔表达式B {
    // 布尔表达式A和布尔表达式B都为true时执行!
  }
}

2.使用

a := 7
if a > 5 {
  if a <=7 {
    fmt.Println("执行！")
  }
}

1.5 注意事项

在if语句的使用过程中，应注意以下细节。

• 不需使用括号将条件包含起来。
• 大括号{}必须存在，即使只有一行语句。
• 左括号必须在if或else的同一行。
• 在if之后，条件语句之前，可以添加变量初始化语句，使用“;”进行分隔。

2. 分支选择(switch)

2.1 基本写法

1. 语法结构

switch var1 {
case "A":
  fmt.Println("满足A！")
case "B":
  fmt.Println("满足B！")
default:
  fmt.Println("A、B都不满足！")
}

2. 使用

package main
import "fmt"
func main() {
 useSwitch("A")
 useSwitch("B")
 useSwitch("C")
 useSwitch("D")
}
func useSwitch(a string) {
 switch a {
 case "A":
  fmt.Println(a + ":优秀")
 case "B":
  fmt.Println(a + ":中等")
 case "C":
  fmt.Println(a + ":及格")
 default:
  fmt.Println(a + ":不及格")
 }
}
/** 输出:
A:优秀
B:中等
C:及格
D:不及格
*/

2.2 一支多值

1. 语法结构

switch var1 {
case "A","A1","A2":
  fmt.Println("满足A,A1,A2中的一个！")
case "B","B1","B2":
  fmt.Println("满足B,B1,B2中的一个！")
default:
   fmt.Println("以上条件都不满足！")
}

2.使用

package main
import "fmt"
func main() {
 useManyValSwitch("小花")
 useManyValSwitch("小明")
 useManyValSwitch("太监总管")
}
func useManyValSwitch(a string)  {
 switch a {
 case "小花","小丽","小美" :
  fmt.Println(a + "是女生！")
 case "小明","小虎" :
  fmt.Println(a + "是男生！")
 default:
  fmt.Println(a + "不男不女!")
 }
}
/** 输出
小花是女生！
小明是男生！
太监总管不男不女!
*/

2.3 表达式分支

1.语法结构

switch {
case a < A:
  fmt.Println("a小于A！")
 case A <=a && a < B
  fmt.Println("a大于A,并且小于B！")
  default:
   fmt.Println("a大于等于A,并且小于B！")
}

switch后面省略不写，默认相当于switch true

2.使用

package main

import "fmt"
func main() {
 useExpressionSwitch(5)
 useExpressionSwitch(15)
 useExpressionSwitch(25)
}
func useExpressionSwitch(a int)  {
 switch  {
 case a >= 1 && a  < 10:
  fmt.Printf(" a = %d, a >= 1 && a  < 10 \n",a)
 case a >= 10 && a  < 20:
  fmt.Printf(" a = %d, a >= 10 && a  < 20 \n",a)
 case a >= 20 && a  < 30:
  fmt.Printf(" a = %d, a >= 20 && a  < 30 \n",a)
 }
}
/**输出:
 a = 5, a >= 1 && a  < 10 
 a = 15, a >= 10 && a  < 20 
 a = 25, a >= 20 && a  < 30 
*/

3.循环(for)

for是Go语言中唯一的循环语句，Go没有while、do...while、foreach循环。按语法结构来分，Go语言的for循环有4种形式

语法结构:

for关键字后有3个表达式——基本for循环语法结构。其语法结构如下所示:

for 初始化语句; 条件表达式; 结束语法 {
  ...
}

使用说明:

• 先执行初始语句，对控制变量赋初始值。初始语句只执行一次；
• 初始语句、条件表达式和结束语句，都是可选的。可写可不写;
• 条件表达式是控制循环与否的开关: 如果表达式为true，则循环继续；否则结束循环;
• 省略条件表达式默认形成无限循环;
• 左括号必须和for 关键字在同一行;
• 初始语句可以省略不写，但是初始语句之后的分号必须要写

3.1 基础使用(表达都不省略)

// 基础for循环使用
func main() {
 var sum int
 for i := 1; i <= 100; i++ {
  sum += is
 }
 fmt.Printf("1到100的数字相加结果: %d " ,sum)
}

3.2 省略初始语句

func main() {
 sum := 0
 i := 1
 for ; i<= 100 ; i++ {
  sum += i
 }
 fmt.Printf("1到100的数字相加结果: %d " ,sum)
}

初始语句可以省略不写，但是初始语句之后的分号必须要写。

3.3 省略初始和条件表达式

func mai3n() {
 sum := 0
 i := 0
 for ; ; i++ {
  if i > 100 {
   break
  }
  sum += i
 }
 fmt.Printf("1到100的数字相加结果: %d " ,sum)
}

条件表达式（condition）是控制循环与否的开关：如果表达式为true，则循环继续；否则结束循环。条件表达式可以省略不写，之后的分号必须要写。省略条件表达式默认形成无限循环。

3.4 只有条件表达式

func main() {
 sum := 0
 i := 1
 for i <= 100 {
  sum += i
  i ++
 }
 fmt.Printf("1到100的数字相加结果: %d " ,sum)
}

3.5 无限循环

func mai3n() {
 sum := 0
 i := 1
 for {
    // 不满足则一直循环
  if i > 100 {
   break
  }
  sum += i
  i++
 }
 fmt.Printf("1到100的数字相加结果: %d " ,sum)
}

3.6 嵌套循环

// 乘法表
func main() {
 for i :=1 ; i< 9; i++  {
  for j :=1; j <= i; j++ {
   fmt.Printf("%d * %d = %d   ",i,j,i * j)
  }
  fmt.Println()
 }
}

4 . 遍历( for ... range)

for循环的range格式对string、slice、array、map、channel等进行迭代循环。array、slice、string返回索引和值；map返回键和值；channel只返回通道内的值。其语法结构如下所示:

for key,value := range data {
   ....
}

4.1 遍历字符串

func main() {
 str := "Hello,欢迎来到Go世界!"
 for key,val := range str {
  fmt.Printf("第%d位,字符是: %c ASCII值为: %d \n",key,val,val)
 }
}

4.2 遍历数组

func main() {
 arr := [5]string{"hello","word","欢","迎","!"}
 fmt.Printf("arr 类型:%T, 值:%v \n",arr,arr)
 for key, val := range  arr{
  fmt.Printf("key: %d, value: %s \n",key,val)
 }
}

4.3 遍历切片

func main() {
 slice := []int{1,3,5,7,9,11}
 // key 可以省略不写
 for val := range slice {
  fmt.Printf("值: %d \n",val)
 }
}

4.4 遍历Map

func main() {
 grades := map[string]int{
  "张三":60,
  "小米":70,
  "小明":88,
 }
 for name, grade := range grades {
  fmt.Printf("姓名: %s 成绩: %d \n", name,grade)
 }
}

5.循环控制语句

5.1 break

跳出循环体。break语句用于终止当前正在执行的for循环，并开始执行循环之后的语句。

使用

func main() {
 for i := 1; i < 5 ; i++  {
    // i > 3后跳出循环
  if i > 3 {
   break
  }
  fmt.Printf("i = %d \n" , i)
 }
}
/** 输出
i = 1 
i = 2 
i = 3 
*/

5.2 continue

Go语言的continue语句有点像break语句。但是continue不是跳出循环，而是跳过当前循环，执行下一次循环语句。

使用

func main() {
   for i := 1; i < 5 ; i++  {
    if i == 3 {
     // 跳过i=3这个循环
     continue
    }
    fmt.Printf("i = %d \n" , i)
   }
}
/** 输出:
i = 1 
i = 2 
i = 4
*/

5.3 goto

func main() {
 for i := 1; i < 5 ; i++  {
  if i == 3 {
   // 当i=3时，重新循环
   goto RESET
  }
  fmt.Printf("i = %d \n" , i)
 }
 fmt.Println("这里将不会打印出来.....")
RESET:
 fmt.Println("程序从这里开始执行.....")
}
/** 输出
i = 1 
i = 2 
程序从这里开始执行.....
*/