1.条件判断(if)

1.1 if

1.语法结构

1
2
3

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

2. 使用

1
2
3
4

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

1.2 if…else

1.语法结构

1
2
3
4
5

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

2.使用

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

1
2
3
4
5

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

1.3 if…else if…else

1.语法结构

1
2
3
4
5
6
7

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

2.使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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.语法结构

1
2
3
4
5

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

2.使用

1
2
3
4
5
6

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

1.5 注意事项

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

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

2. 分支选择(switch)

2.1 基本写法

1. 语法结构

1
2
3
4
5
6
7
8

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

2. 使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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. 语法结构

1
2
3
4
5
6
7
8

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

2.使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

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.语法结构

1
2
3
4
5
6
7
8

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

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

2.使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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循环语法结构。其语法结构如下所示:

1
2
3

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

使用说明:

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

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

1
2
3
4
5
6
7
8

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

3.2 省略初始化语句

1
2
3
4
5
6
7
8

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

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

3.3 省略初始和条件表达式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

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

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

3.4 只有条件表达式

1
2
3
4
5
6
7
8
9

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

3.5 无限循环

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

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

3.6 嵌套循环

1
2
3
4
5
6
7
8
9

// 乘法表
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只返回通道内的值。其语法结构如下所示:

1
2
3

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

4.1 遍历字符串

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package main
import "fmt"
func main() {
	s := "Go，您好！"
	ForByStr(s)
	ForByByte(s)
	ForByRune(s)
}
// 遍历字符串
func ForByStr(str string) {
	for k,v := range str {
		fmt.Printf("遍历字符串 -> k:%v , v:%c \n",k,v)
	}
}
// 遍历字节
func ForByByte(string2 string)  {
	for k,v := range []byte(string2){
		fmt.Printf("遍历字节 ->  k:%v , v:%x \n",k,v)
	}
}
// 遍历字符
func ForByRune(string2 string)  {
	for k,v := range []rune(string2) {
		fmt.Printf("遍历字符 -> k:%v , v:%c \n",k,v)
	}
}

如果字符串涉及中文，遍历字符推荐使用rune。因为一个byte存不下一个汉语文字的unicode值。

4.2 遍历数组

1
2
3
4
5
6
7

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 遍历切片

1
2
3
4
5
6
7

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

4.4 遍历Map

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

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

5.循环控制语句

5.1 break

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

使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

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不是跳出循环，而是跳过当前循环，执行下一次循环语句。

使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

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

使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

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 
程序从这里开始执行.....
*/