返回专栏
· 14 分钟阅读

变量与常量(Variables & Constants)


一、什么是变量?

变量(Variable)是程序中用于引用或存储数据的基本单位,可以通过名称访问其关联的值。

例如:

age = 25
name = "Alice"
price = 19.99

这里定义了三个变量:

  • age:关联整数值 25。
  • name:关联字符串值 "Alice"。
  • price:关联浮点数值 19.99。

变量通常由以下几个要素构成:

要素 含义
名称(Name) 用于标识变量的名称
值(Value) 变量当前关联的数据
类型(Type) 描述数据的类型及操作规则
存储位置(Storage Location) 数据或对象引用在运行时对应的位置
作用域(Scope) 变量可以被访问的代码范围
生命周期(Lifetime) 变量或其存储实体存在的时间范围

变量的核心作用是让程序能够保存和操作数据,并在执行过程中维护状态。

1.1 变量的基本操作

变量通常涉及以下几种操作:

定义(Declaration)

声明变量,使其名称在指定作用域内具有意义。

int age;

初始化(Initialization)

变量首次获得初始值。

int age = 25;

赋值(Assignment)

将一个值赋给变量,或者改变变量当前关联的值。

age = 30;

读取(Read)

获取变量当前关联的值。

System.out.println(age);

更新(Update)

根据当前值计算新值,再重新赋给变量。

age = age + 1;

变量操作可以抽象为:

flowchart TB
    A["声明变量"] --> B["初始化变量"]
    B --> C["读取变量"]
    C --> D["执行计算"]
    D --> E["更新变量值"]
    E --> C

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

需要注意,并非所有语言都要求显式声明和初始化。例如 Python 可以直接通过赋值建立变量名与对象之间的绑定关系。

二、变量的本质:名称、值与内存

理解变量,最重要的是区分变量名称、变量值和内存存储位置。

在不同编程语言中,变量的底层实现并不完全相同。

2.1 变量不一定直接存储数据

在 C 语言中:

int age = 25;

在典型实现中,age 对应一块能够存储整数的内存空间,整数值 25 存储在其中。

可以简化为:

变量名:age
存储位置:某个内存地址
存储内容:25

而在 Python 中:

age = 25

更准确的理解是:

  • 25 是一个整数对象。
  • age 是一个名称。
  • 名称 age 绑定到整数对象。

Python 变量不是像 C 语言局部整数变量那样,直接代表一块固定类型的数值存储空间。

因此,不同语言中变量的底层语义可能存在很大区别。

2.2 变量的内存示意

以 C 语言中的普通局部整数变量为例:

int age = 25;

可以用下面的示意理解:

flowchart LR
    A["变量名称 age"] --> B["内存位置"]
    B --> C["存储内容 25"]
    C --> D["整数类型 int"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

这是概念示意,不代表所有语言的变量都采用这种直接存储模型。

2.3 变量名与变量值不是一回事

观察下面的代码:

a = 10
b = a

a = 20

print(a)  # 20
print(b)  # 10

执行 b = a 时,b 获得了当前 a 所关联的对象。

之后 a = 20 让名称 a 绑定到另一个整数对象,并不会自动改变 b 的绑定关系。

这里体现了一个重要区别:

变量名的重新绑定,不等于修改原有对象。

对于可变对象,这种区别更加重要:

a = [1, 2, 3]
b = a

a.append(4)

print(a)  # [1, 2, 3, 4]
print(b)  # [1, 2, 3, 4]

因为 a 和 b 都绑定到同一个列表对象,对列表的原地修改可以通过两个名称观察到。

三、什么是常量?

常量(Constant)是用于表示不应被重新赋值或改变的值的语言机制。

例如:

final double PI = 3.141592653589793;

这里使用 final 声明常量变量,初始化后不能再次赋值。

常量主要用于表达:

  • 数学常数
  • 配置参数
  • 固定业务规则
  • 系统限制
  • 协议定义
  • 不应被修改的程序数据

例如:

MAX_RETRY = 3
DEFAULT_TIMEOUT = 30
API_VERSION = "v1"

Python 使用大写命名约定表示常量意图,但语言本身不会阻止重新赋值。

MAX_RETRY = 3
MAX_RETRY = 5  # Python 允许

因此,必须区分:

  • 语言层面真正提供的常量约束。
  • 仅通过命名规范表达的常量约定。

3.1 常量的主要特点

特点 说明
固定性 通常不允许重新赋值
可读性 通过名称表达固定含义
可维护性 修改配置时集中调整
安全性 减少意外修改
可复用性 多处代码可以引用同一常量

3.2 常量与字面量

常量和字面量(Literal)容易混淆。

字面量是直接出现在源代码中的固定值。

例如:

age = 25
name = "Alice"
enabled = True

其中:

  • 25 是整数字面量。
  • "Alice" 是字符串字面量。
  • True 是布尔字面量。

而常量通常是一个具有固定值的命名实体。

例如:

MAX_USERS = 100

这里:

  • 100 是字面量。
  • MAX_USERS 是通过命名约定表达的常量。

二者的关系可以理解为:

flowchart TB
    A["固定值"] --> B["字面量"]
    A --> C["命名常量"]
    B --> D["直接写在代码中"]
    C --> E["通过名称引用"]
    E --> F["关联固定值"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

字面量描述的是值在源代码中的表示形式;常量描述的是值的命名和约束方式。

四、变量与常量的区别

变量和常量都用于在程序中表达数据,但它们对值变化的约束不同。

对比维度 变量 常量
英文 Variable Constant
赋值 通常允许重新赋值 通常限制重新赋值
值变化 可以变化 通常不允许变化
使用场景 运行状态、临时数据、计算结果 固定配置、规则、参数
可维护性 需要关注状态变化 有助于统一管理固定值
典型声明 let、var、普通变量声明 const、final、const

例如:

int score = 80;
score = 90;

final int MAX_SCORE = 100;

score 可以被更新,而 MAX_SCORE 不能被再次赋值。

但需要注意:

常量不一定意味着它所引用的对象在内存中完全不可修改。

这涉及常量与不可变对象之间的重要区别。

五、常量与不可变对象

常量(Constant)与不可变对象(Immutable Object)不是同一个概念。

这是实际开发中非常容易出错的地方。

5.1 常量约束的是变量绑定或赋值

例如 Java:

final List<String> names = new ArrayList<>();

names.add("Alice");
names.add("Bob");

// names = new ArrayList<>(); // 编译错误

这里:

  • names 是 final 引用变量。
  • names 不能重新指向另一个列表对象。
  • 列表对象本身仍然可以被修改。

也就是说,final 约束的是引用变量不能重新赋值,并不自动让列表内容不可变。

5.2 不可变对象约束的是对象状态

不可变对象一旦创建,其内部状态就不能再发生变化。

例如 Python:

name = "Alice"
name = "Bob"

字符串对象本身不可变。

第二次赋值并没有修改原字符串,而是让 name 绑定到另一个字符串对象。

再看元组:

user = (1001, "Alice")

元组本身不可修改,但如果元组中包含可变对象,这些对象的内部状态仍可能发生变化:

data = ([1, 2], "Alice")

data[0].append(3)

print(data)  # ([1, 2, 3], 'Alice')

元组结构没有被修改,但其中的列表发生了变化。

5.3 常量与不可变对象的区别

对比维度 常量约束 不可变对象
约束对象 名称、变量或绑定 对象自身的状态
是否允许重新赋值 通常不允许 取决于引用变量
是否允许修改内部状态 不一定 不允许
主要目的 限制重新赋值 保证对象状态稳定

可以用以下方式理解:

flowchart TB
    A["数据固定性"] --> B["赋值不可变"]
    A --> C["对象不可变"]

    B --> D["限制变量重新赋值"]
    C --> E["限制对象内部状态变化"]

    D --> F["常量机制"]
    E --> G["不可变对象"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

在并发编程、函数式编程和大型系统设计中,不可变对象具有重要价值,因为它能够减少共享状态变化带来的复杂性。

六、变量的声明、定义与初始化

变量声明、定义和初始化是三个相关但不同的概念。

6.1 声明(Declaration)

声明用于告诉编译器或运行环境,某个名称具有特定含义。

例如 C 语言:

extern int age;

这里声明了一个外部整数变量,但没有在此处定义它的存储实体。

6.2 定义(Definition)

定义通常用于创建变量实体,并在适用的语言规则下分配存储空间。

例如:

int age;

这里既声明了 age,也定义了该变量。

在 C 语言中,变量声明与定义的区别具有明确的语言规范意义。

6.3 初始化(Initialization)

初始化是变量创建时获得初始值的过程。

int age = 25;

这里定义了变量,并将其初始化为 25。

需要注意,不同语言对未初始化变量的处理差异很大:

  • C 语言中,具有自动存储期的未初始化局部变量,其值是不确定的。
  • Java 中,实例字段和静态字段具有默认值,局部变量在使用前必须明确赋值。
  • Go 中,变量会获得对应类型的零值。
  • Python 中,名称在绑定对象之前不能直接读取,否则通常会产生 NameError 或相关异常。

因此,不能将某一种语言的初始化规则直接套用到其他语言。

七、变量的作用域(Scope)

作用域是变量名称能够被访问的代码范围。

变量的作用域决定了程序在哪些位置可以通过名称引用它。

常见作用域包括:

  • 全局作用域
  • 文件或模块作用域
  • 函数作用域
  • 块级作用域
  • 类作用域

7.1 全局作用域

全局变量通常在较大的程序范围内可见。

例如 Python:

message = "Hello"

def greet():
    print(message)

greet()

message 定义在函数外部,可以在函数中读取。

但如果需要在函数内部重新绑定全局变量,需要使用 global:

count = 0

def increment():
    global count
    count += 1

7.2 局部作用域

局部变量通常定义在函数内部,只能在对应的局部作用域中访问。

def calculate():
    result = 100
    print(result)

calculate()

# print(result)  # NameError

result 在函数内部有效,函数外部无法直接访问。

7.3 块级作用域

块级作用域通常由一对代码块边界限定,例如 {}。

Java:

public class Main {
    public static void main(String[] args) {
        if (true) {
            int value = 10;
            System.out.println(value);
        }

        // System.out.println(value); // 编译错误
    }
}

value 只在 if 代码块内部有效。

JavaScript 使用 let 和 const 声明的变量也具有块级作用域。

7.4 作用域嵌套与变量遮蔽

当内部作用域定义了与外部作用域同名的变量时,可能发生变量遮蔽(Variable Shadowing)。

例如:

let name = "Global";

function greet() {
    let name = "Local";
    console.log(name);
}

greet();           // Local
console.log(name); // Global

函数内部的 name 遮蔽了外部的 name。

变量遮蔽不等于修改外部变量,而是在当前作用域中使用了另一个同名绑定。

7.5 作用域示意

flowchart TB
    A["全局作用域"] --> B["函数作用域"]
    B --> C["块级作用域"]
    A --> D["其他函数作用域"]
    C --> E["块内局部变量"]
    B --> F["函数局部变量"]
    A --> G["全局变量"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

这是作用域嵌套的概念示意。不同语言的作用域规则并不完全一致,例如 JavaScript 还涉及词法作用域、闭包和暂时性死区等机制。

八、变量的生命周期(Lifetime)

作用域与生命周期是两个不同的概念。

  • 作用域关注:变量名称在哪里可以被访问。
  • 生命周期关注:变量或相关存储实体什么时候创建、什么时候销毁。

例如:

void test() {
    int count = 10;
}

在典型 C 实现中,count 是自动存储期的局部变量,其生命周期与函数执行过程相关。

当函数执行结束后,该变量的生命周期结束。

但不能简单认为所有局部变量都在函数返回时销毁。

不同语言具有不同的内存管理机制:

语言 常见生命周期管理方式
C 自动存储期、静态存储期、动态分配
C++ 自动对象、静态对象、动态对象、RAII
Java 对象由垃圾回收机制管理
Python 对象生命周期受引用关系和垃圾回收机制影响
Go 编译器逃逸分析与垃圾回收共同参与内存管理
Rust 所有权、借用与生命周期规则