Go：常量&运算符&流程控制

目录

一、常量

1.1 常量基本定义

1.2 常量组的定义

1.3 常量枚举

二、运算符

2.1 算数运算符

2.2 关系运算符

2.3 逻辑运算符

2.4 位运算符

2.5 赋值运算符

2.6 指针运算符

2.7 运算符优先级

三、流程控制

3.1 if-else 条件语句

3.2 switch-case语句

3.3 for 循环

3.3 break & continue

break

continue

break & continue 的区别

3.4 goto跳转

四、练习

4.1 九九乘法表

4.2 数字金字塔

4.3 斐波那契数列

---

        在学习编程的过程中，掌握常量、运算符和流程控制是理解和使用任何编程语言的基础。对于Go语言，这些概念同样至关重要。通过本笔记，我们将详细介绍Go语言中的常量、运算符以及流程控制的相关知识，帮助读者在实际编程中灵活运用这些基本概念。

一、常量

1.1 常量基本定义

        常量是在程序编译时就确定下来的固定值。它们可以是数值、布尔值或字符串。Go语言的常量具有以下特点：

1. 使用 const 关键字声明
2. 在编译时被创建
3. 只能是基本数据类型（数值、字符串或布尔值）
4. 不可在运行时修改

注意：

• 一个常量被声明后可以不使用，但是变量一旦声明则必须使用。
• 显式定义：常量的声明以关键字const开头，后接变量类型并进行赋值，行尾没有其他标点符号。const 常量名 常量类型 = value
• 隐式定义：由于Go是编译型语言，定义常量时可以省略常量类型，因为编译器可以根据变量的值来推断其类型。const 常量名 = value

package main

import "fmt"

// 单个常量声明
const PI = 3.14159

// 多个常量声明
const (
	StatusOK          = 200
	StatusNotFound    = 404
	StatusServerError = 500
)

func main() {
	fmt.Println("PI:", PI)
	// 常量的数学运算
	fmt.Println("圆的面积 (半径为5):", PI*5*5)
	// 尝试修改常量会导致编译错误
	fmt.Println("HTTP状态码 - OK:", StatusOK)
	fmt.Println("HTTP状态码 - Not Found:", StatusNotFound)
	fmt.Println("HTTP状态码 - Server Error:", StatusServerError)
}
//result
PI: 3.14159
圆的面积 (半径为5): 78.53975
HTTP状态码 - OK: 200
HTTP状态码 - Not Found: 404
HTTP状态码 - Server Error: 500

1.2 常量组的定义

        如果程序需要用到大量值相同的常量，我们可以直接定义常量组。 在定义常量组时，若不提供初始值，则表示将使用上行的表达式。

package main

import "fmt"

const (
	a = 3.14
	b
	c
	d = 100
)

func main() {
	fmt.Println("a:", a)
	fmt.Println("b:", b)
	fmt.Println("c:", c)
	fmt.Println("d:", d)
}
//result
a: 3.14
b: 3.14
c: 3.14
d: 100

1.3 常量枚举

        枚举通常针对一个有穷序列集而言，一个集的枚举就是列出有穷序列集的所有成员。Go语言现阶段还没有枚举，但是我们可以使用一种特殊常量“iota”来模拟枚举。

  iota 是Go语言的一个预定义标识符，它表示从0开始的连续整数。在每个const关键字出现时，iota都会重置为0。

package main

import "fmt"

func main() {
	const (
		a = iota    // 0
		b           // 1, 沿用上一行的 iota
		c = "Hello" // "Hello", iota = 2 但未使用
		d           // "Hello", 沿用上一行的表达式
		e = iota    // 4, iota 继续计数
		f           // 5

		g = iota * 2 // 12, iota = 6
		h            // 14, 沿用 iota * 2 表达式

		i = 1 << iota // 512, iota = 9，这是位运算
		j             // 1024, 沿用 1 << iota 表达式
	)

	fmt.Println("a:", a)
	fmt.Println("b:", b)
	fmt.Println("c:", c)
	fmt.Println("d:", d)
	fmt.Println("e:", e)
	fmt.Println("f:", f)
	fmt.Println("g:", g)
	fmt.Println("h:", h)
	fmt.Println("i:", i)
	fmt.Println("j:", j)

	// 在新的 const 块中 iota 重新从 0 开始
	const (
		k = iota // 0
		l        // 1
		_        // 2, 使用下划线跳过这个值
		m        // 3
	)

	fmt.Println("k:", k)
	fmt.Println("l:", l)
	fmt.Println("m:", m)

	// 在一行中使用多个 iota
	const (
		a1, a2 = iota + 1, iota + 2 // 1, 2
		b1, b2                      // 2, 3
		c1, c2                      // 3, 4
	)

	fmt.Printf("a1: %d, a2: %d\n", a1, a2)
	fmt.Printf("b1: %d, b2: %d\n", b1, b2)
	fmt.Printf("c1: %d, c2: %d\n", c1, c2)
}
//result
a: 0
b: 1
c: Hello
d: Hello
e: 4
f: 5
g: 12
h: 14
i: 256
j: 512
k: 0
l: 1
m: 3
a1: 1, a2: 2
b1: 2, b2: 3
c1: 3, c2: 4

---

二、运算符

        Go数据是通过使用操作运算符来进行操作的，与数学运算符类似。操作运算符接受一个或多 个参数，并生成一个新的值

2.1 算数运算符

算术运算符用于Go语言的数学表达式中，它们的作用和在数学中的作用一样。

运算符	说明	示例
+	加法：相加运算符两侧的值	a + b
-	减法：左操作数减去右操作数	a - b
*	乘法：操作符两侧的值相乘	a * b
/	除法：左操作数除以右操作数	a / b
%	取模：左操作数除以右操作数的余数	a % b
++	自增：操作数加1	a++
--	自减：操作数减1	a--

package main

import "fmt"

func main() {
	// 算术运算符
	a, b := 10, 3
	fmt.Printf("a = %d, b = %d\n", a, b)
	fmt.Printf("a + b = %d\n", a+b)
	fmt.Printf("a - b = %d\n", a-b)
	fmt.Printf("a * b = %d\n", a*b)
	fmt.Printf("a / b = %d\n", a/b)
	fmt.Printf("a %% b = %d\n", a%b)  //注意：要使用两个百分号，转意
	a++
	fmt.Printf("a = %d\n", a)
	b--
	fmt.Printf("b = %d\n", b)
}
a = 10, b = 3
a + b = 13
a - b = 7
a * b = 30
a / b = 3
a % b = 1
a = 11
b = 2

2.2 关系运算符

        比较运算符，对符号两边的变量进行比较，包括大小、相等等。如果比较结果是正确，返回 真（true），否则返回假（false）

运算符	说明	示例
==	等于：比较对象是否相等	a == b
!=	不等于：比较两个对象是否不相等	a != b
＞	大于：返回a是否大于b	a ＞ b
＜	小于：返回a是否小于b	a ＜ b
＞=	大于等于：返回x是否大于等于y	x ＞= y
＜=	小于等于：返回x是否小于等于y	x ＜= y

package main

import "fmt"

func main() {
	// 关系运算符
	a, b := 10, 3
	fmt.Printf("a == b: %t\n", a == b)
	fmt.Printf("a != b: %t\n", a != b)
	fmt.Printf("a > b: %t\n", a > b)
	fmt.Printf("a < b: %t\n", a < b)
	fmt.Printf("a >= b: %t\n", a >= b)
	fmt.Printf("a <= b: %t\n", a <= b)
}
//result
a == b: false
a != b: true
a > b: true
a < b: false
a >= b: true
a <= b: false

2.3 逻辑运算符

运算符	说明	示例
&&	逻辑与，当且仅当两个操作数都为真，条件才为真	a && b
||	逻辑或，两个操作数中任意一个为真，条件为真	a || b
!	逻辑非，用来反转操作数的逻辑状态。如果条件为true，则逻辑非运 算符将得到false	! a

package main

import "fmt"

func main() {
	// 逻辑运算符
	x, y := true, false
	fmt.Printf("x && y: %t\n", x && y)
	fmt.Printf("x || y: %t\n", x || y)
	fmt.Printf("!x: %t\n", !x)
}
//result
x && y: false
x || y: true
!x: false

2.4 位运算符

运算符	名称	描述	示例
&	按位与	两个位都为1时，结果为1	1100 & 1010 = 1000
|	按位或	至少一个位为1时，结果为1	1100 | 1010 = 1110
^	按位异或	两个位不同时，结果为1	1100 ^ 1010 = 0110
^	按位非（一元）	翻转所有位	^1100 = 0011
<<	左移	将位向左移动指定数量	1100 << 2 = 110000
>>	右移	将位向右移动指定数量	1100 >> 2 = 0011
&^	位清空（AND NOT）	清除指定的位	1100 &^ 1010 = 0100

package main

import (
	"fmt"
)

func main() {
	a := 60 // 二进制: 0011 1100
	b := 13 // 二进制: 0000 1101

	fmt.Printf("a = %d, binary: %08b\n", a, a)
	fmt.Printf("b = %d, binary: %08b\n", b, b)

	// 1. 按位与 (&)
	result := a & b
	fmt.Printf("a & b  = %d, binary: %08b\n", result, result)

	// 2. 按位或 (|)
	result = a | b
	fmt.Printf("a | b  = %d, binary: %08b\n", result, result)

	// 3. 按位异或 (^)
	result = a ^ b
	fmt.Printf("a ^ b  = %d, binary: %08b\n", result, result)

	// 4. 按位非 (^)
	result = ^a
	fmt.Printf("^a     = %d, binary: %08b\n", result, uint8(result))

	// 5. 左移 (<<)
	result = a << 2
	fmt.Printf("a << 2 = %d, binary: %08b\n", result, result)

	// 6. 右移 (>>)
	result = a >> 2
	fmt.Printf("a >> 2 = %d, binary: %08b\n", result, result)

	// 7. 位清空 (&^)
	result = a &^ b
	fmt.Printf("a &^ b = %d, binary: %08b\n", result, result)
}
//result
a = 60, binary: 00111100
b = 13, binary: 00001101
a & b  = 12, binary: 00001100
a | b  = 61, binary: 00111101
a ^ b  = 49, binary: 00110001
^a     = -61, binary: 11000011
a << 2 = 240, binary: 11110000
a >> 2 = 15, binary: 00001111
a &^ b = 48, binary: 00110000

2.5 赋值运算符

        最常用的赋值运算符是等号“=”，表示把右边的结果值赋值给左边的变量。其他的赋值运算 符大多都是算术运算符和赋值运算符的简写。

运算符	说明	示例	展开形式
=	将右边值赋给左边	a=100	a=100
+=	将左边值加上右边值	a+=10	a=a+10
-=	将左边值减去右边值	a-=10	a=a-10
*=	将左边值乘以右边值	a*=10	a=a*10
/=	将左边值除以右边值	a/=10	a=a/10
%=	将左边值对右边值做取模	a%=10	a=a%10
**=	将左边值的右边值次方赋给左边	a**=2	a=a**2
//=	将左边值除以右边值(取整除)	a//=3	a=a//3
&=	按位与运算后赋值	a&=5	a=a&5
|=	按位或运算后赋值	a|=5	a=a|5
^=	按位异或运算后赋值	a^=5	a=a^5
>>=	右移运算后赋值	a>>=2	a=a>>2
<<=	左移运算后赋值	a<<=2	a=a<<2

package main

import "fmt"

func main() {
	var a int = 100

	fmt.Println("Initial value of a:", a)

	a += 10
	fmt.Println("After a += 10:", a)

	a -= 5
	fmt.Println("After a -= 5:", a)

	a *= 2
	fmt.Println("After a *= 2:", a)

	a /= 4
	fmt.Println("After a /= 4:", a)

	a %= 7
	fmt.Println("After a %= 7:", a)

	// Go doesn't have **= operator, so we'll use regular multiplication
	a *= a
	fmt.Println("After a *= a (simulating a **= 2):", a)

	// Go uses / for both float and integer division
	a /= 3
	fmt.Println("After a /= 3:", a)

	a &= 5
	fmt.Println("After a &= 5:", a)

	a |= 8
	fmt.Println("After a |= 8:", a)

	a ^= 3
	fmt.Println("After a ^= 3:", a)

	a >>= 1
	fmt.Println("After a >>= 1:", a)

	a <<= 2
	fmt.Println("After a <<= 2:", a)
}
//result
Initial value of a: 100
After a += 10: 110
After a -= 5: 105
After a *= 2: 210
After a /= 4: 52
After a %= 7: 3
After a *= a (simulating a **= 2): 9
After a /= 3: 3
After a &= 5: 1
After a |= 8: 9
After a ^= 3: 10
After a >>= 1: 5
After a <<= 2: 20

2.6 指针运算符

运算符	描述	示例
&	返回变量的内存地址	&a // 将给出变量a的实际地址
*	指向变量。用于声明指针类型或访问指针指向的值	*p // 是一个指针变量
^	一元运算符时：对整数按位取反（NOT） 二元运算符时：按位异或（XOR）	^a   // 对a的所有位取反 a ^ b  // a和b按位异或

package main

import "fmt"

func main() {
	a := 10
	var p *int
	p = &a

	fmt.Println("a =", a)
	fmt.Printf("变量a的地址: %p\n", p)
	fmt.Println("指针p指向的值:", *p)
}
//result
a = 10
变量a的地址: 0xc00000a0b8
指针p指向的值: 10

2.7 运算符优先级

优先级	运算符
5	* / % << >> & &^
4	+ - | ^
3	== != < <= > >=
2	&&
1	||

• 最高优先级（5级）：
  • *、/、%：乘、除、取模
  • <<、>>：左移、右移
  • &：按位与
  • &^：按位清零（AND NOT）
• 次高优先级（4级）：
  • +、-：加、减
  • |：按位或
  • ^：按位异或
• 比较运算符（3级）：
  • ==、!=：等于、不等于
  • <、<=、>、>=：小于、小于等于、大于、大于等于
• 逻辑与（2级）：
  • &&
• 逻辑或（1级）：
  • ||

---

三、流程控制

        与其他编程语言一样，使用Go语言的编程者需要通过流程控制语句来控制程序的逻辑走向和 执行次序。 Go语言基本上继承了C/C++语言所有流程控制语句，如果有C/C++的编程经验，那么理解本章内容将较为轻松。

        流程控制语句主要包括：条件判断语句（if、switch和select）、循环控制语句（for、break和continue） 和跳转语句（goto）。selects是用于处理多个通道操作，以后结合通道在学

3.1 if-else 条件语句

用于根据条件执行不同的代码块。

if condition {
    // 条件为真时执行
} else if anotherCondition {
    // 另一个条件为真时执行
} else {
    // 所有条件都为假时执行
}

特点：

• 条件表达式不需要括号
• 支持在 if 语句中声明局部变量

条件表达式使用例子

以下程序引入了runtime包，使用NumCPU()函数获取了程序使用的CPU核数并传递给num变量。

package main

import (
	"fmt"
	"runtime"
)

func main() {
	if num := runtime.NumCPU(); num >= 1 {
		fmt.Println("程序使用的CPU核数为:", num)
	}
}
//result
程序使用的CPU核数为: 16

3.2 switch-case语句

switch语句常用于基于大量不同条件来执行不同动作，每一个条件对应一个case分支。  

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

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

switch variable {
case value1:
    // 代码块
case value2,value3:
    // 代码块
default:
    // 默认代码块
}

        变量varible可以是任何类型，但value1和value2必须是相同的类型或最终结果为相同类型的表达式。每个case分支后可跟多个可能符合条件的值，使用逗号分隔它们，例如：case value2, value3

特点：

• 默认情况下，case 语句后不需要 break
• 支持多个条件在同一个 case 中
• 支持 fallthrough 关键字实现穿透到下一个 case

使用fallthrough的例子

package main

import "fmt"

func main() {
	switch {
	//false，肯定不会执行
	case false:
		fmt.Println("case1 为false")
		fallthrough
		//true，肯定执行
	case true:
		fmt.Println("case2 为 true")
		fallthrough
		//由于上一个case中有fallthrough，即使是false，也强制执行
	case false:
		fmt.Println("case3 为 false")
		fallthrough
	default:
		fmt.Println("默认 case")
	}
}
//result
case2 为 true
case3 为 false
默认 case

3.3 for 循环

Go 只有一种循环结构：for 循环。不同于其他编程语言，Go语言没有while关键字，不存在while循环

// 标准 for 循环
for i := 0; i < 10; i++ {
    // 循环体
}

// 类似 while 循环
for condition {
    // 循环体
}

// 无限循环
for {
    // 循环体
}

// 遍历数组、切片或 map
for index, value := range collection {
    // 使用 index 和 value
}

3.3 break & continue

  break 和 continue 是Go语言中用于控制循环执行的关键字。它们可以改变循环的正常执行流程，但有着不同的作用。

Go 没有 do-while 循环，所以 break 和 continue 主要用在 for 循环中。

break

在 for 循环中：

for i := 0; i < 10; i++ {
    if i == 5 {
        break
    }
    fmt.Println(i)
}
// 输出: 0 1 2 3 4

在 switch 语句中：

switch n {
case 1:
    fmt.Println("一")
case 2:
    fmt.Println("二")
    break
    fmt.Println("这行不会执行")
default:
    fmt.Println("其他")
}

Go 支持带标签的 break，可以跳出多层嵌套循环：

package main

import "fmt"

func main() {
outerLoop:
	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			if i == 1 && j == 1 {
				break outerLoop
			}
			fmt.Printf("%d %d\n", i, j)
		}
	}
}
//result
0 0
0 1
0 2
1 0

continue

continue 语句用于跳过当前循环的剩余部分，直接进入下一次迭代。

基本用法

for i := 0; i < 5; i++ {
    if i == 2 {
        continue
    }
    fmt.Println(i)
}
// 输出: 0 1 3 4

标签用法，类似于break

package main

import "fmt"

func main() {
outerLoop:
	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			if i == 1 && j == 1 {
				continue outerLoop
			}
			fmt.Printf("%d %d\n", i, j)
		}
	}
}
// result
// 0 0
// 0 1
// 0 2
// 1 0
// 2 0
// 2 1
// 2 2

break & continue 的区别

1. break 终止整个循环，而 continue 只跳过当前迭代。
2. break 可以用在 for 循环和 switch 语句中，而 continue 只用在循环中。
3. 带标签的 break 可以跳出多层循环，而带标签的 continue 会跳到外层循环的下一次迭代。

3.4 goto跳转

goto语句用于代码间的无条件跳转，格式如下：

goto label
// ... 其他代码 ...
label:
    // 跳转到这里

一般情况下，在程序中不建议使用goto语句，过多的goto语句会破坏程序结构，使程序的可读 性变差。

package main

import "fmt"

func main() {
	fmt.Println("Hello")
	goto sign
	fmt.Println("无效代码")
sign:
	fmt.Println("world")
}
//result
Hello
World

---

四、练习

4.1 九九乘法表

实现的效果

1 * 1 =  1  
1 * 2 =  2  2 * 2 =  4  
1 * 3 =  3  2 * 3 =  6  3 * 3 =  9  
1 * 4 =  4  2 * 4 =  8  3 * 4 = 12  4 * 4 = 16  
1 * 5 =  5  2 * 5 = 10  3 * 5 = 15  4 * 5 = 20  5 * 5 = 25  
1 * 6 =  6  2 * 6 = 12  3 * 6 = 18  4 * 6 = 24  5 * 6 = 30  6 * 6 = 36  
1 * 7 =  7  2 * 7 = 14  3 * 7 = 21  4 * 7 = 28  5 * 7 = 35  6 * 7 = 42  7 * 7 = 49  
1 * 8 =  8  2 * 8 = 16  3 * 8 = 24  4 * 8 = 32  5 * 8 = 40  6 * 8 = 48  7 * 8 = 56  8 * 8 = 64  
1 * 9 =  9  2 * 9 = 18  3 * 9 = 27  4 * 9 = 36  5 * 9 = 45  6 * 9 = 54  7 * 9 = 63  8 * 9 = 72  9 * 9 = 81  

package main

import "fmt"

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

4.2 数字金字塔

实现的效果

        *
       ***
      *****
     *******
    *********
   ***********
  *************
 ***************
*****************

package main

import "fmt"

func Pyramid(n int) {
	// n 表示总层数
	for i := 1; i <= n; i++ {
		// 打印空格
		for j := 1; j <= n-i; j++ {
			fmt.Print(" ")
		}
		// 打印星号
		for k := 1; k <= 2*i-1; k++ {
			fmt.Print("*")
		}
		fmt.Println()
	}
}

func main() {
	n := 9
	Pyramid(n)
}

4.3 斐波那契数列

斐波那契数列，又称黄金分割数列，因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）

以兔子繁殖为例子而引入，故又称为兔子数列，指的是这样一个数列：1、1、2、3、5、8、13、 21、34……这个数列从第三项开始，每一项都等于前两项之和。斐波那契数列在现代物理、准晶 体结构、化学等领域都有直接的应用。 那么，我们是否可以编写一个斐波那契数列的程序，输入第n项，程序输出对应第n项的值？ 答案是肯定的，最常见的实现方式就是循环和递归。

前20个例子：

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 

使用for循环实现斐波那契数列的程序如下：

package main

import "fmt"

func Fibonacci(n int) (res int) {
	a := 1
	b := 1
	for i := 2; i < n; i++ {
		c := b
		b = a + b
		a = c
	}
	return b
}

func main() {
	n := 9
	fmt.Printf("Fibonacci(%d) = %d\n", n, Fibonacci(n))
}
//result
Fibonacci(9) = 34

使用递归实现斐波那契数列的程序如下：

package main

import "fmt"

func Fibonacci(n int) (res int) {
	if n == 1 || n == 2 {
		return 1
	} else {
		return Fibonacci(n-2) + Fibonacci(n-1)
	}
}

func main() {
	n := 10
	fmt.Printf("Fibonacci(%d) = %d\n", n, Fibonacci(n))
}
//result
Fibonacci(10) = 55

使用switch分支来进行代替：

package main

import "fmt"

func Fibonacci(n int) (res int) {
	switch n {
	case 1:
		return 1
	case 2:
		return 1
	default:
		return Fibonacci(n-1) + Fibonacci(n-2)
	}
}

func main() {
	n := 6
	fmt.Printf("Fibonacci(%d) = %d\n", n, Fibonacci(n))
}
//result
Fibonacci(6) = 8