编程笔记 Golang基础 018 常量与变量

常量，就是在程序编译阶段就确定下来的值，而程序在运行时则无法改变该值。变量是程序的基本组成单位，用于存储和表示可变的数据。

一、常量

常量，就是在程序编译阶段就确定下来的值，而程序在运行时则无法改变该值。在Go程序中，常量可以是数值类型（包括整型、浮点型和复数类型）、布尔类型、字符串类型等。

常量的定义

常量的定义格式如下：

Go
const identifier [type] = value
1
2

identifier 是你为常量指定的名字。
[type] 是可选的，用于显式指定常量的数据类型。如果不提供类型，则编译器会根据 value 的初始值自动推断出类型。
value 是常量的值，它可以是布尔型、数字型（包括整数、浮点数和复数）、字符串或其他常量表达式的结果。

实例

package main

func main() {
	const PI float64 = 3.14
	const PI2 = 3.1415 // 可以省略类型

	const (
		width  = 100
		height = 200
	)

	const i, j = 1, 2 // 多重赋值
	const a, b, c = 1, 2, "foo"
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

const同时声明多个常量时，如果省略了值则表示和上面一行的值相同

package main

import "fmt"

func main() {
	const (
		a1 = 100
		a2
		a3
	)

	fmt.Printf("a1: %v\n", a1)
	fmt.Printf("a2: %v\n", a2)
	fmt.Printf("a3: %v\n", a3)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行结果
a1: 100
a2: 100
a3: 100

iota

iota 比较特殊，可以被认为是一个可被编译器修改的常量，它默认开始值是0，每调用一次加1。遇到 const 关键字时被重置为 0。

实例

package main

import "fmt"

func main() {
	const (
		a1 = iota
		a2 = iota
		a3 = iota
	)

	fmt.Printf("a1: %v\n", a1)
	fmt.Printf("a2: %v\n", a2)
	fmt.Printf("a3: %v\n", a3)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行结果
a1: 0
a2: 1
a3: 2

使用_跳过某些值

package main

import "fmt"

func main() {
	const (
		a1 = iota
		_
		a2 = iota
	)

	fmt.Printf("a1: %v\n", a1)
	fmt.Printf("a2: %v\n", a2)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果
a1: 0
a2: 2

iota声明中间插队

package main

import "fmt"

func main() {
	const (
		a1 = iota
		a2 = 100
		a3 = iota
	)

	fmt.Printf("a1: %v\n", a1)
	fmt.Printf("a2: %v\n", a2)
	fmt.Printf("a3: %v\n", a3)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行结果
a1: 0
a2: 100
a3: 2

特性

不可变性：一旦定义，常量的值就不能被更改。
类型安全：每个常量都有明确的类型，不能进行不兼容类型的隐式转换。
编译期确定：常量表达式的值在编译阶段就已经计算出来，而非运行时。
通过以上介绍，可以看出Go语言中的常量提供了简洁的方式来定义程序中不变的值，并且通过类型检查确保了程序的健壮性和可预测性。

二、变量

在Go语言中，变量是程序的基本组成单位，用于存储和表示可变的数据。以下是Go语言中关于变量的详解：

变量定义

1. 基本格式：

   var identifier type = value
   1

   其中 identifier 是变量名，type 是变量的类型（如 int、string、float64 等），value 是初始值。例如：

   var name string = "Alice"
   var age int = 25
   1
   2

2. 简写形式：
   如果初始化时明确给出了变量的值，可以省略变量类型的声明，Go编译器会根据赋值表达式的类型自动推断变量类型。

   var name = "Bob" // 编译器推断name为string类型
   var age = 30    // 编译器推断age为int类型
   1
   2

3. 同时声明多个变量：
   同一行内可以声明多个同类型变量，用逗号分隔。

   var a, b, c int = 1, 2, 3
   1

4. 短变量声明：
   在函数内部，还可以使用简化的变量声明方式，即:=操作符来同时声明并初始化变量，无需使用var关键字。此方式只适用于局部变量。

   func main() {
       x, y := 10, 20 // 声明并初始化x和y
   }
   1
   2
   3

5. 匿名变量（Blank Identifier）：
   使用下划线 _ 作为变量名时，表示该变量被声明但不使用，主要用于忽略函数返回的多余值。

   _, err := someFunctionReturningMultipleValues()
   1

变量作用域

• 在函数外部声明的变量具有包级作用域，在整个包文件内可见，如果不加访问修饰符（如 var variableName)，默认为包私有（不可从其他包直接访问）。
• 在函数内部声明的变量具有局部作用域，仅在该函数内部可见。

零值与初始化

• 如果没有显式初始化，变量将被赋予其类型的零值。比如整型为0，字符串为""（空字符串），布尔型为false等。
• Go语言强烈鼓励显式初始化变量以提高代码可读性和减少未初始化变量的使用错误。

类型转换

虽然Go是静态类型语言，但在必要时可以通过显式转换操作将一种类型转换为另一种类型。

注意事项

• 变量名必须遵循标识符命名规则，首字符不能是数字，可以包含字母（大小写敏感）、数字和下划线。
• Go语言是静态类型语言，因此每个变量都具有固定的类型，并且编译器会在编译阶段检查类型一致性。

三、重要性

在程序设计中，常量（Constants）和变量（Variables）扮演着至关重要的角色，它们都是存储数据的基本元素，但各自的特性和使用场景各有不同：

1. 常量的重要性：

   • 不变性与可靠性：常量的值一旦定义就不能改变，这为程序提供了确定性和稳定性。例如，在计算圆周率、物理常数或配置固定的错误代码时，使用常量可以确保这些数值在整个程序运行期间始终保持不变。
   • 提高可读性：通过命名良好的常量，可以增强代码的自解释性。比如，用 PI 替代具体的浮点数，使其他开发者更容易理解代码意图，减少阅读难度。
   • 防止意外修改：由于常量不可变，因此避免了因意外操作导致重要数据被修改的风险。
   • 编译时优化：编译器可以在编译阶段就对常量进行求值，并可能将常量直接内嵌到指令中，从而提高程序执行效率。

2. 变量的重要性：

   • 动态数据处理：变量是程序中必不可少的数据容器，其值可以根据程序逻辑随时更改，用于存储用户输入、计算结果、状态标志等临时或变化的数据。
   • 灵活性：变量的存在使得程序能够响应不同的输入和条件，执行不同的操作，从而使程序具有适应性。
   • 内存管理：变量占用内存空间并允许程序分配和释放资源，这对于实现复杂算法和数据结构至关重要。
   • 控制流：循环变量、条件语句中的测试变量等都在程序流程控制中起到关键作用。

综上所述，常量和变量在程序设计中共同构建了一个灵活且可靠的数据模型，保证了程序既能够在必要时持有静态不变的数据，又能够根据需要处理动态变化的信息。同时，恰当的使用两者还能促进代码的清晰度、健壮性和性能优化。