返回专栏
· 18 分钟阅读

不可变性与可变性(Immutability & Mutability)


一、不可变性与可变性的基本概念

不可变性(Immutability)和可变性(Mutability)描述的是数据创建之后,其状态是否允许发生变化。

可变性:对象或数据创建之后,允许修改其内部状态。

不可变性:对象或数据创建之后,不允许修改其内部状态。需要产生不同状态时,通常创建新的对象或值。

例如:

// 可变对象
const user = {
    name: "Alice",
    age: 20
};

user.age = 21;

// 不可变值
const name = "Alice";

// 字符串操作返回新字符串
const newName = name.toUpperCase();

这里需要区分两个概念:

  • const 限制变量重新赋值,不代表对象内部不可变。
  • 不可变性描述的是数据本身的修改能力,而不是变量是否能够重新绑定。

例如:

const user = {
    name: "Alice"
};

// 可以修改对象属性
user.name = "Bob";

// 不允许重新绑定变量
user = {};

第一种操作合法,第二种操作会产生错误。

因此,判断一个对象是否可变,不能仅仅看它是否使用了 const、final 或 let 等声明方式。

1.1 可变对象与不可变对象

对比维度 可变对象 不可变对象
创建后是否允许修改状态 允许 不允许
修改方式 直接修改内部状态 创建新值或新对象
对象身份 修改前后通常相同 修改后通常是新对象
内存使用 可以复用原对象 可能产生新对象
并发共享 需要考虑同步 通常更容易安全共享
状态追踪 需要关注修改历史 状态变化更加明确
典型应用 缓存、状态容器、可变集合 配置、值对象、函数式数据

需要注意,不可变对象并不意味着底层内存永远不会发生变化。例如垃圾回收、运行时内部缓存和延迟初始化可能改变对象的物理状态,但不一定改变其对外可观察的逻辑状态。

二、可变性的实现机制

可变对象允许在创建之后修改其内部状态。

例如 Java:

class User {
    String name;
    int age;
}

User user = new User();

user.name = "Alice";
user.age = 20;

user.age = 21;

对象创建之后,程序可以通过引用访问对象,并修改其字段。

从内存模型角度,可以抽象为:

变量 user
    |
    v
User 对象
    |
    +-- name = "Alice"
    |
    +-- age = 20

修改之后:

变量 user
    |
    v
User 对象
    |
    +-- name = "Alice"
    |
    +-- age = 21

对象的身份没有改变,但内部状态发生了变化。

2.1 原地修改(In-place Mutation)

原地修改是指直接修改已有对象,而不创建一个新的对象来替代它。

例如 Python:

numbers = [1, 2, 3]

numbers.append(4)

print(numbers)
# [1, 2, 3, 4]

append() 直接修改原列表。

再看字典:

user = {
    "name": "Alice",
    "age": 20
}

user["age"] = 21

字典对象仍然是原来的对象,只是内部数据发生了变化。

原地修改通常具有以下特点:

  • 可以复用已有对象。
  • 减少部分对象创建和复制开销。
  • 可能影响共享同一对象的其他代码。
  • 需要考虑别名、并发和状态一致性。

2.2 可变对象的引用共享问题

当多个变量引用同一个可变对象时,通过其中任意一个引用修改对象,其他引用都能观察到变化。

例如:

user_a = {
    "name": "Alice",
    "age": 20
}

user_b = user_a

user_b["age"] = 21

print(user_a["age"])
# 21

这里并没有复制对象,而是创建了两个指向同一个对象的引用。

flowchart TD
    A["变量 user_a"] --> C["同一个 User 对象"]
    B["变量 user_b"] --> C
    C --> D["name = Alice"]
    C --> E["age = 20"]
    F["通过 user_b 修改 age"] --> G["age = 21"]
    G --> C

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#F3EDFC,stroke:#C4B2E3,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

这种现象称为引用别名(Aliasing)。

引用别名本身并不是错误,但它会增加状态管理的复杂度。

当一个对象被多个模块共享时,修改行为可能影响其他模块,导致:

  • 隐式状态变化。
  • 难以追踪的数据来源。
  • 难以复现的错误。
  • 并发访问冲突。
  • 缓存数据不一致。

2.3 浅拷贝与深拷贝

为了避免共享同一个可变对象,可以通过复制创建新的对象。

但复制并不一定意味着所有嵌套对象都被复制。

浅拷贝(Shallow Copy)

浅拷贝只复制对象的第一层结构,内部嵌套对象仍然可能共享引用。

Python:

import copy

user_a = {
    "name": "Alice",
    "profile": {
        "age": 20
    }
}

user_b = copy.copy(user_a)

user_b["name"] = "Bob"
user_b["profile"]["age"] = 21

print(user_a["name"])          # Alice
print(user_a["profile"]["age"]) # 21

user_a 和 user_b 是两个不同的外层字典,但它们内部的 profile 仍然指向同一个字典。

深拷贝(Deep Copy)

深拷贝会递归复制嵌套对象,尽可能构建一份独立的数据结构。

import copy

user_a = {
    "name": "Alice",
    "profile": {
        "age": 20
    }
}

user_b = copy.deepcopy(user_a)

user_b["profile"]["age"] = 21

print(user_a["profile"]["age"]) # 20

两种复制方式的区别:

对比维度 浅拷贝 深拷贝
外层对象 新对象 新对象
嵌套对象 通常共享 通常递归复制
复制成本 较低 较高
内存占用 较少 较多
循环引用 不需要递归处理内部结构 需要处理循环引用
适用场景 只需要隔离外层结构 需要隔离整个对象图

深拷贝也不是所有情况下都能直接使用。文件句柄、锁、网络连接、数据库连接等资源对象通常不能简单地通过复制获得独立且有效的资源状态。

三、不可变性的实现机制

不可变对象在创建之后,不允许外部代码修改其逻辑状态。

例如 Java:

public final class User {
    private final String name;
    private final int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

这个类具有以下特点:

  • 类使用 final,不能被继承。
  • 字段使用 private,避免外部直接访问。
  • 字段使用 final,只能在初始化阶段赋值。
  • 不提供修改字段的 setter。
  • 构造完成之后,字段值不再改变。

使用时:

User user = new User("Alice", 20);

如果需要得到年龄为 21 的用户,通常创建一个新对象:

User updated = new User(
    user.getName(),
    21
);

原来的 user 对象没有发生变化。

3.1 不可变对象的状态变化

不可变对象不会直接修改自身,而是通过创建新对象表达新的状态。

flowchart TD
    A["创建 User 对象"] --> B["User(Alice, 20)"]
    B --> C["需要修改 age"]
    C --> D["创建新对象"]
    D --> E["User(Alice, 21)"]
    B --> F["原对象保持不变"]
    E --> G["使用新对象"]

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

这种方式使状态变化显式化,有利于追踪数据来源和构建可预测的程序逻辑。

3.2 不可变对象的深层问题

一个对象的字段不可重新赋值,并不代表整个对象一定不可变。

例如:

public final class User {
    private final List<String> roles;

    public User(List<String> roles) {
        this.roles = roles;
    }

    public List<String> getRoles() {
        return roles;
    }
}

虽然 roles 使用了 final,但列表本身仍然可以修改:

List<String> roles = new ArrayList<>();
roles.add("USER");

User user = new User(roles);

user.getRoles().add("ADMIN");

此时对象的内部状态已经发生变化。

原因在于:

final 限制的是引用变量不能重新指向另一个列表,并不限制列表对象本身的修改。

此外,构造函数直接保存外部传入的可变列表,也会导致外部代码能够修改对象内部状态。

3.3 防御性复制(Defensive Copying)

为了避免外部引用影响对象内部状态,可以在输入和输出边界进行防御性复制。

public final class User {
    private final List<String> roles;

    public User(List<String> roles) {
        this.roles = List.copyOf(roles);
    }

    public List<String> getRoles() {
        return roles;
    }
}

List.copyOf() 会创建一个不可修改的列表视图或副本,具体是否复用已有不可修改列表由实现决定。

对于这里的字符串元素,由于 String 本身不可变,因此可以满足预期的不可变性。

但如果列表元素是可变对象,List.copyOf() 只保证列表结构不可修改,不会递归冻结元素对象。

例如:

List<UserProfile> profiles = ...;

List<UserProfile> copied = List.copyOf(profiles);

调用方仍可能通过 UserProfile 的其他引用修改元素内部状态。

因此:

不可变性必须考虑整个可达对象图,而不仅仅是对象最外层的字段。

四、不可变性的不同层次

不可变性并不是简单的二元概念。在实际编程中,可以从不同层次理解。

4.1 变量不可重新赋值

变量绑定不可变,表示变量不能重新绑定到另一个值或对象。

例如 Java:

final int count = 10;

以下操作不允许:

count = 20;

JavaScript:

const count = 10;

同样不能重新赋值。

但变量绑定不可变不代表对象不可变。

const user = {
    name: "Alice"
};

user.name = "Bob";

这里变量绑定没有改变,但对象状态发生了变化。

4.2 对象不可变

对象不可变意味着创建完成后,其可观察的逻辑状态不能被外部修改。

例如 Java:

String name = "Alice";

字符串是不可变对象。

String newName = name.replace("A", "B");

执行之后,原字符串仍然是 "Alice",新字符串是 "Blice"。

4.3 集合结构不可变

集合结构不可变,意味着集合中的元素数量、顺序或成员关系不能被修改。

例如 Java:

List<String> names = List.of(
    "Alice",
    "Bob"
);

尝试执行:

names.add("Charlie");

会抛出 UnsupportedOperationException。

但如果集合中保存的是可变对象,集合元素自身仍可能变化。

4.4 深度不可变(Deep Immutability)

深度不可变要求对象及其可达的内部对象都不能发生可观察的状态变化。

例如:

User
 ├── name: String
 ├── age: int
 └── roles: List<String>

如果:

  • User 本身不能修改字段。
  • roles 集合不能增删元素。
  • 集合中的元素也是不可变值。

那么整个对象结构才可以达到深度不可变。

实际工程中,深度不可变通常比浅层不可变更有价值,但也需要更严格的对象设计和复制策略。

五、不同编程语言中的不可变性与可变性

不同语言通过不同机制表达可变性。

5.1 Java:final 与不可变类

Java 使用 final 限制变量重新赋值,也可以配合类设计构建不可变对象。

final class Point {
    private final int x;
    private final int y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    int getX() {
        return x;
    }

    int getY() {
        return y;
    }
}

需要区分:

  • final 变量:不能重新赋值。
  • final 引用:不能指向另一个对象。
  • final 字段:初始化后不能再次赋值。
  • final 类:不能被继承。
  • 不可变对象:整个对象的逻辑状态不能被修改。

这些概念相关,但不等价。

5.2 JavaScript:const、Object.freeze 与结构共享

JavaScript 中,const 只限制变量重新绑定。

const user = {
    name: "Alice"
};

user.name = "Bob";

如果希望阻止对象属性被修改,可以使用:

const user = Object.freeze({
    name: "Alice",
    age: 20
});

但 Object.freeze() 默认只执行浅层冻结。

const user = Object.freeze({
    name: "Alice",
    profile: {
        age: 20
    }
});

user.profile.age = 21;

嵌套对象仍然可以被修改。

对于复杂状态,可以采用递归冻结或不可变数据结构库,但需要考虑循环引用、对象类型和性能成本。

5.3 Python:可变与不可变内置类型

Python 中常见的不可变类型:

  • int
  • float
  • bool
  • str
  • tuple
  • frozenset

常见的可变类型:

  • list
  • dict
  • set
  • 大多数自定义类实例

例如:

name = "Alice"

name = name + " Smith"

字符串操作不会修改原字符串,而是产生新的字符串对象,并让变量重新绑定。

再看列表:

numbers = [1, 2, 3]

numbers.append(4)

列表本身发生了变化。

需要特别注意:元组虽然不可变,但它可以包含可变对象。

data = ([1, 2], 3)

data[0].append(4)

print(data)
# ([1, 2, 4], 3)

元组的元素绑定没有改变,但内部列表的状态发生了变化。

5.4 C++:const 与引用限定

C++ 提供了 const 来限制对象通过特定访问路径被修改。

const int value = 10;

对于对象:

class User {
public:
    void setAge(int value) {
        age = value;
    }

private:
    int age = 20;
};

const User user;

通过 const 对象不能调用非 const 成员函数。

C++ 还支持 const 引用:

User user;

const User& ref = user;

这里限制的是通过 ref 进行修改,并不代表原始对象在其他访问路径下也不可变。

user.setAge(30);

仍然可以通过非 const 引用修改对象。

这体现了 C++ 的一个重要特征:

const-correctness 主要是访问路径和类型系统层面的约束,不一定意味着对象全局不可变。

5.5 Rust:所有权与可变借用

Rust 将可变性与所有权、借用规则紧密结合。

默认情况下,变量不可变:

let value = 10;

需要修改时,必须声明为 mut:

let mut value = 10;

value = 20;

对于引用:

let mut value = 10;

let reference = &value;

reference 是不可变引用。

可变引用:

let mut value = 10;

let reference = &mut value;

*reference = 20;

Rust 的借用规则核心包括:

  • 可以存在多个不可变引用。
  • 同一时间不能同时存在可变引用和其他活动引用。
  • 可变引用要求被借用的数据本身可变。
  • 所有权规则保证引用不会超过数据的有效生命周期。

这类约束可以在编译期减少数据竞争和非法修改。

5.6 Go:值与指针的可变性

Go 的变量默认可以重新赋值:

value := 10
value = 20

对于结构体:

type User struct {
    Name string
    Age  int
}

user := User{
    Name: "Alice",
    Age:  20,
}

user.Age = 21

Go 允许通过结构体值直接修改字段,也可以通过指针修改:

userPtr := &user
userPtr.Age = 22

Go 没有与 Java final 或 Rust 默认不可变绑定完全相同的通用关键字。

在 Go 中,通常通过封装、接口设计和数据复制约定控制对象的修改权限。

5.7 不同语言机制对比

语言 不可变性机制 可变性机制
Java final、不可变类、不可修改集合 普通字段、可变集合
JavaScript const、Object.freeze()、不可变数据结构 let、对象属性修改
Python 不可变内置类型、冻结数据类 list、dict、普通对象
C++ const、constexpr 普通对象、非 const 引用
Rust 默认不可变绑定、不可变借用 mut、可变借用
Go 封装、值语义、只读接口约定 普通变量、指针和可变字段

六、不可变性与值语义、引用语义

不可变性经常与值类型、引用类型一起讨论,但它们并不是同一个概念。

6.1 值语义(Value Semantics)

值语义强调数据在赋值、传递或复制时表现为独立的值。

例如:

a := 10
b := a

b = 20

fmt.Println(a) // 10

修改 b 不会影响 a。

对于结构体:

type Point struct {
    X int
    Y int
}

a := Point{X: 1, Y: 2}
b := a

b.X = 100

a.X 仍然是 1,因为结构体赋值会复制结构体字段。

但如果结构体内部包含指针、切片或映射,复制之后仍可能共享底层数据。

6.2 引用语义(Reference Semantics)

引用语义强调多个变量可以引用同一个对象。

例如 Java:

User a = new User("Alice", 20);
User b = a;

b.setAge(21);

通过 b 修改对象后,a 观察到的也是修改后的状态。

6.3 不可变性与值语义的关系

不可变性和值语义具有较强的关联,但不能画等号。

类型 是否可变 示例
值语义 不可变 整数、不可变结构体
值语义 可变 Go 中的普通结构体变量
引用语义 不可变 Java String
引用语义 可变 Java ArrayList

不可变对象可以通过引用共享,因为共享方不能修改它的逻辑状态。

这也是不可变对象适合缓存、跨模块传递和并发共享的重要原因。

七、不可变性与函数式编程

函数式编程强调通过函数组合构建程序,并尽量减少可变状态和副作用。

不可变性是函数式编程的重要基础之一。

7.1 纯函数(Pure Function)

纯函数满足两个核心特征:

  1. 相同输入始终产生相同输出。
  2. 不产生可观察的外部副作用。

例如:

function add(a, b) {
    return a + b;
}

这个函数不依赖外部状态,也不修改输入。

再看一个非纯函数:

let total = 0;

function add(value) {
    total += value;
    return total;
}

执行结果依赖外部变量 total,并且修改了外部状态。