Golang - Part03 运算符和流程控制

本文使用Chatgpt辅助生成

运算符

算术运算符

包括加（+）、减（-）、乘（*）、除（/）和取模（%）等。其中，加号还可以用于字符串连接。

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

func main() {
  a := 10
  b := 5
  fmt.Println("a + b = ", a+b)
  fmt.Println("a - b = ", a-b)
  fmt.Println("a * b = ", a*b)
  fmt.Println("a / b = ", a/b)
  fmt.Println("a % b = ", a%b)
}

//a + b =  15
//a - b =  5
//a * b =  50
//a / b =  2
//a % b =  0

自增和自减不是运算符，只能作为独立语句使用，不能用于表达式，不能放在变量名前面使用。通过代码，我们演示 ++ 和 – 的用法。

1
2
3
4
5
6
7
8
9
10
func main() {
	a := 10
	b := 5
	a++
	b--
	fmt.Println("a++:", a)
	fmt.Println("b--:", b)
}
//a++: 11
//b--: 4

比较运算符

用于比较两个值的大小关系，包括等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）和小于等于（<=）等。

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
27
28
29
30
31
32
func main() {
	a := 10
	b := 5
	if a > 5 && b > 5 {
		fmt.Println("a > 5 且 b > 5")
	}

	if a > 5 || b > 5 {
		fmt.Println("a > 5 或 b > 5")
	}

	if a > 5 && b >= 5 {
		fmt.Println("a > 5 且 b >= 5")
	}

	if a == b {
		fmt.Println("a == b")
	}

	if a != b {
		fmt.Println("a != b")
	}

	boolean := false
	if !boolean {
		fmt.Println("非假既真")
	}
}
//a > 5 或 b > 5
//a > 5 且 b >= 5
//a != b
//非假既真

逻辑运算符

逻辑运算符：包括逻辑与（&&）、逻辑或（||）和逻辑非（!）等。其中，逻辑与和逻辑或都是短路运算符，也就是说，如果第一个操作数能够确定结果，则不会对第二个操作数进行求值

代码参考上方

位运算符

按照二进制位进行运算，包括按位与（&）、按位或（|）、按位异或（^）、左移（<<）和右移（>>）等

位运算符通常用于处理底层或者二进制数据，例如在实现网络协议、文件格式等领域。需要注意位运算符可能存在的溢出问题和操作数类型的问题。

位运算符是一种基于二进制位进行操作的运算符，主要包括以下几种：

  1. 按位与（&）：将两个操作数的每个对应位上的值都取出来，进行“与”运算，返回一个新的二进制数。
  2. 按位或（|）：将两个操作数的每个对应位上的值都取出来，进行“或”运算，返回一个新的二进制数。
  3. 按位异或（^）：将两个操作数的每个对应位上的值都取出来，进行“异或”运算，返回一个新的二进制数。
  4. 左移（<<）：将左操作数的二进制表示向左移动指定的位数，右边用 0 填充；返回一个新的二进制数。
  5. 右移（>>）：将左操作数的二进制表示向右移动指定的位数，左边用原来的数值填充；返回一个新的二进制数。

赋值运算符

用于给变量赋值，包括简单赋值（=）、加等于（+=）、减等于（-=）、乘等于（*=）、除等于（/=）、取模等于（%=）、按位与等于（&=）、按位或等于（|=）、按位异或等于（^=）、左移等于（<<=）和右移等于（>>=）等

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
func main() {
	aa := 50
	aa += 10
	fmt.Println("aa = ", aa)

	bb := 50
	bb -= 10
	fmt.Println("bb = ", bb)

	cc := 50
	cc *= 10
	fmt.Println("cc = ", cc)

	dd := 50
	dd /= 10
	fmt.Println("dd = ", dd)

	ff := 50
	ff %= 10
	fmt.Println("ff = ", ff)
}
//aa =  60
//bb =  40
//cc =  500
//dd =  5
//ff =  0

其他运算符

  1. 取地址（&）：取地址运算符（&）可以获取变量的内存地址。例如，&a 表示变量 a 的地址。
  2. 取值（*）：取值运算符（*）用于获取指针指向的变量的值。例如，如果 p 是一个指向整型变量的指针，则 *p 表示该变量的值。
  3. 三元运算符（?:）：三元条件运算符（? :）是一种简短的条件语句形式，它通常用于根据条件来选择两个值中的一个。语法为 condition ? value1 : value2，其中 condition 是一个布尔表达式，value1 和 value2 分别是两个可能的返回值。如果 condition 为 true，则返回 value1，否则返回 value2。

流程控制

if/else语句

if语句用于判断一个条件是否成立，如果成立则执行相应的代码块，否则执行else语句中的代码块。if语句还可以嵌套使用，形成if/else if/else结构。

1
2
3
4
5
6
7
8
9
10
11
func main() {
	x := 1
	if x >= 5 {
		fmt.Println("x >= 5")
	} else if x < 5 && x > 0 {
		fmt.Println("x < 5 && x > 0")
	} else {
		fmt.Println("x <= 0")
	}
}
//x < 5 && x > 0

if/else语句区别于其它语言，它在条件表达式中，支持初始化语句，可以定义局部变量（一个或多个）或执行初始化函数。其中，局部变量的有效范围包含整个if/else块。通过代码，我们演示 if/else在条件表达式中初始化语句的使用方法。

1
2
3
4
5
6
7
8
9
func main() {
	var x int
	if a, b := x+1, x+10; a < b {
		fmt.Println("a < b")
	} else {
		fmt.Println("a >= b")
	}
}
//a < b

for循环

for循环 for循环用于重复执行某段代码，直到指定的条件满足为止。Go语言中for循环有：for 循环、for range循环和无限循环等。

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

func main() {
	// for循环
	for i := 0; i < 10; i++ {
		fmt.Println(i)
	}

	// for range循环
	arr := []int{1, 2, 3, 4, 5}
	for index, value := range arr {
		fmt.Printf("index: %d, value: %d\n", index, value)
	}

	// 无限循环
	for {
		// do something
	}
    
	// for 模拟 while
	x := 0
	for x < 5 {
		x++
		fmt.Println("x = ", x)
	}
}

//0
//1
//2
//3
//4
//5
//6
//7
//8
//9
//index: 0, value: 1
//index: 1, value: 2
//index: 2, value: 3
//index: 3, value: 4
//index: 4, value: 5
//x =  1
//x =  2
//x =  3
//x =  4
//x =  5

switch语句

switch 语句和 if 语句类似，也用于选择执行，在 Go 语言中，switch 语句不同于其他语言中的 switch 语句，匹配到 case 块后，不需要显式执行 break 语句，程序自动不会继续执行下个 case 块，如果需要程序继续执行匹配 case 块的下一个 case 块，可以在 case 块的结尾执行 fallthrough，但是不会再匹配 case 块的条件表达式。如果想要阻止 fallthrough，可以显式执行 break 语句。在一个 case 块存在多个匹配条件时，命中其中一个条件即可，类似逻辑运算符“或”，通过代码，我们演示 switch 在 Go 语言中的使用方法。

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

func main() {
  a, b, c, x := 2, 3, 4, 2
  switch x {
  case a, b:
    println("x == a || x == b")
    fallthrough
  case c:
    println("x == c")
  case 3:
    println("x == 3")
  default:
    println("x 不符合任何 case 条件")
  }
}


//x == a || x == b
//x == c

除了常规的switch语句外，Go语言还提供了一种特殊的形式，即在switch表达式中省略表达式。这种形式的switch语句可以用来简化大量的if/else if结构。

1
2
3
4
5
6
7
8
9
switch {
case a > 0 && a < 10:
    fmt.Println("a is between 0 and 10")
case a >= 10 && a < 20:
    fmt.Println("a is between 10 and 20")
default:
    fmt.Println("a is less than 0 or greater than or equal to 20")
}
// 上述代码中，根据a的值判断它属于哪个范围，并输出相应的结果。如果a在0~10之间，则输出"a is between 0 and 10"；如果a在10~20之间，则输出"a is between 10 and 20"；否则输出"a is less than 0 or greater than or equal to 20"。

continue、break和goto

  • continue 用于跳过当前循环中剩余的语句，直接进入下一次循环。例如：
1
2
3
4
5
6
7
for i := 0; i < 10; i++ {
    if i % 2 == 0 {
        // 如果i为偶数，跳过本次循环，进入下一次循环
        continue
    }
    fmt.Println(i)
}

上述代码将输出所有奇数（1, 3, 5, 7, 9），因为当 i 为偶数时，continue 跳过了 fmt.Println(i) 这条语句。

  • break 用于结束当前循环或 switch 语句。例如：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
for i := 0; i < 10; i++ {
    if i == 5 {
        // 当 i 等于 5 时，跳出循环
        break
    }
    fmt.Println(i)
}

switch name {
case "Bob":
    fmt.Println("Hello Bob")
    // 匹配到 "Bob" 后，跳出 switch 语句
    break
case "Alice":
    fmt.Println("Hello Alice")
default:
    fmt.Println("Hello")
}

上述代码将输出 0 到 4（不包括 5），因为当 i 等于 5 时，break 终止了循环。另外，当 switch 语句匹配到 “Bob” 后，break 也会终止 switch 语句。

  • goto 用于无条件地转移到被标记的语句。例如：
1
2
3
4
5
6
7
8
9
10
for i := 0; i < 10; i++ {
    if i == 5 {
        // 当 i 等于 5 时，跳转到 Label 处执行
        goto Label
    }
    fmt.Println(i)
}

Label:
fmt.Println("Jumped to Label")

上述代码将输出 0 到 4，然后跳转到 Label 标记处执行。在实际开发中，由于滥用 goto 可能导致代码难以理解和维护，因此 Go 语言鼓励使用结构化的控制流程，避免使用 goto。