返回专栏
· 15 分钟阅读

纯函数与副作用


一、纯函数与副作用的基本概念

函数式编程强调将程序拆分为可独立推理的计算单元,其中最重要的两个概念是纯函数(Pure Function)和副作用(Side Effect)。

纯函数: 相同输入始终产生相同输出,并且执行过程不会产生可观察的外部影响。

副作用: 函数执行过程中,除返回计算结果外,还对外部环境产生可观察的影响。

例如:

def add(a, b):
    return a + b

add 是一个纯函数:

  • 结果只依赖参数 a 和 b。
  • 相同参数始终得到相同结果。
  • 不修改外部变量。
  • 不访问文件、网络或数据库。
  • 不产生其他可观察影响。

再看一个函数:

counter = 0

def increment():
    global counter
    counter += 1
    return counter

increment 不是纯函数:

  • 函数依赖外部变量 counter。
  • 每次调用可能得到不同结果。
  • 函数修改了外部状态。

二者的核心区别:

维度 纯函数 存在副作用的函数
输入依赖 显式参数 可能依赖外部状态
输出确定性 相同输入对应相同输出 结果可能随环境变化
外部状态 不修改外部状态 可能读取或修改
可预测性 高 依赖外部条件
可测试性 通常较简单 可能需要模拟外部环境
可缓存性 适合按输入缓存 需要额外判断
并发安全性 更容易保证 需要管理共享状态
组合能力 通常更强 需要考虑副作用顺序

需要注意:读取外部状态和修改外部状态并不是同一回事。严格意义上的纯函数既不能依赖不受参数控制的外部可变状态,也不能产生可观察的副作用。

二、纯函数(Pure Function)

2.1 纯函数的两个核心条件

纯函数需要同时满足两个条件。

条件一:确定性(Determinism)

对于相同的输入,函数始终产生相同的输出。

数学上可以表示为:

f(x)=y

当输入 x 不变时,输出 y 也不变。

例如:

def square(x):
    return x * x

print(square(5))
print(square(5))
print(square(5))

输出:

25
25
25

条件二:无可观察副作用(No Observable Side Effects)

函数执行不能改变调用方可观察到的外部状态,也不能产生其他外部可观察影响。

例如:

def calculate_tax(price, rate):
    return price * rate

该函数只进行计算,不修改传入对象,也不访问外部资源。

2.2 依赖全局变量的函数不是纯函数

tax_rate = 0.1

def calculate_tax(price):
    return price * tax_rate

虽然这个函数没有修改任何变量,但它依赖外部状态 tax_rate。

如果税率发生变化,相同的 price 就可能得到不同结果。

可以将依赖显式传入:

def calculate_tax(price, tax_rate):
    return price * tax_rate

现在计算结果只依赖两个明确参数。

这种改造有两个价值:

  • 函数依赖关系更加清晰。
  • 测试时可以直接控制输入条件。

2.3 读取时间和随机数的函数

下面两个函数都不是严格意义上的纯函数:

import time
import random

def current_time():
    return time.time()

def generate_code():
    return random.randint(1000, 9999)

原因:

  • current_time() 依赖系统时钟。
  • generate_code() 依赖随机数生成器的内部状态。

即使没有显式修改业务变量,它们的结果也不只由函数参数决定。

可以将外部依赖转化为显式输入:

def format_timestamp(timestamp):
    return f"Timestamp: {timestamp}"

def generate_code_from_seed(seed):
    import random
    rng = random.Random(seed)
    return rng.randint(1000, 9999)

对于相同的 timestamp 或 seed,结果可以保持确定。

但要注意,随机数生成器的创建、使用和状态管理仍需要明确设计。将随机种子作为参数只是控制非确定性的常见方式,并不意味着所有随机操作都天然是纯函数。

2.4 纯函数的形式化理解

可以将纯函数抽象为:

f:X\rightarrow Y

其中:

  • X:输入值集合。
  • Y:输出值集合。
  • f:确定的映射关系。

从函数式编程角度看,函数不应依赖隐式输入,也不应产生隐式输出。

实际程序中的纯函数还需要考虑异常、终止性、资源消耗等边界。例如,一个函数即使没有修改外部状态,如果可能无限循环,也不能简单认为它在所有程序语义下都表现得像一个普通数学函数。

三、副作用(Side Effect)

3.1 副作用的定义

副作用是函数执行过程中,对返回值之外的程序环境产生的可观察影响。

例如:

def save_user(user):
    database.insert(user)

函数的主要目的不是计算一个返回值,而是向数据库写入数据。

数据库状态发生了变化,因此这是一个具有副作用的函数。

副作用并不意味着程序存在错误。

实际软件系统必须与外部世界交互:

  • 读取用户输入。
  • 访问数据库。
  • 发送网络请求。
  • 写入文件。
  • 更新缓存。
  • 输出日志。

这些操作都需要副作用。

真正需要解决的问题不是消除副作用,而是控制副作用的范围和传播方式。

3.2 常见副作用类型

副作用类型 具体表现 示例
状态修改 修改外部变量或共享对象 修改全局计数器
文件操作 读取、写入或删除文件 写入日志文件
网络操作 发送请求或接收响应 调用 HTTP API
数据库操作 修改持久化数据 INSERT、UPDATE
控制台输出 输出信息 print、console.log
随机数 使用随机数生成器状态 random.randint
时间依赖 读取当前时间 获取系统时间
进程操作 创建进程或修改环境 启动子进程
消息通信 向消息队列发送消息 Kafka Producer
异常交互 抛出异常或触发外部处理 抛出业务异常

3.3 读取操作也是副作用吗?

这是一个容易混淆的问题。

从严格的纯函数定义来看,读取外部可变状态也会破坏纯函数的确定性。

例如:

def get_config():
    return config_service.get("tax_rate")

虽然没有修改配置,但函数依赖外部配置服务。

如果配置发生变化,同样的调用可能得到不同结果。

因此:

  • 读取不可变常量通常不会破坏纯函数的确定性。
  • 读取外部可变状态通常不满足纯函数要求。
  • 修改外部状态属于典型副作用。
  • 访问网络、文件和数据库通常属于外部交互。

在工程实践中,通常会将读取和写入都视为需要管理的外部效应。

四、纯函数与副作用的执行对比

4.1 纯函数执行过程

纯函数的输入和输出关系明确,不依赖外部可变状态。

flowchart TB
    A["接收显式输入"] --> B["执行确定性计算"]
    B --> C["产生计算结果"]
    C --> D["返回结果"]
    D --> E["外部状态保持不变"]

    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:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

4.2 副作用函数执行过程

副作用函数除了计算结果,还可能与外部环境交互。

flowchart TB
    A["接收输入"] --> B["执行函数逻辑"]
    B --> C["访问外部资源"]
    C --> D["产生外部影响"]
    D --> E["返回结果或执行状态"]

    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:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

4.3 两者可以同时存在于一个业务流程中

例如,一个订单系统:

  1. 接收订单请求。
  2. 查询商品信息。
  3. 计算商品总价。
  4. 计算折扣。
  5. 写入订单数据。
  6. 发送支付请求。
  7. 返回处理结果。

其中:

  • 商品信息查询涉及外部资源读取。
  • 总价计算可以设计为纯函数。
  • 折扣计算可以设计为纯函数。
  • 订单写入具有副作用。
  • 支付请求具有副作用。

一个良好的架构会尽量让核心业务计算保持纯粹,将外部交互集中在明确的边界。

五、引用透明性(Referential Transparency)

5.1 什么是引用透明性

引用透明性是函数式编程中的重要性质。

如果一个表达式可以被它计算得到的值替换,而不改变程序行为,那么这个表达式具有引用透明性。

例如:

def add(a, b):
    return a + b

result = add(10, 20) * 2

因为:

add(10,20)=30

所以表达式可以替换为:

result = 30 * 2

替换前后,程序的可观察行为保持一致。

5.2 纯函数与引用透明性的关系

两者关系密切,但侧重点不同。

概念 关注重点
纯函数 输入输出确定性与无可观察副作用
引用透明性 表达式能否被计算结果等价替换

纯函数调用通常具有引用透明性。

例如:

def multiply(a, b):
    return a * b

可以将:

multiply(3, 4)

替换为:

12

但下面的表达式不能进行相同替换:

import time

def get_time():
    return time.time()

每次调用可能得到不同结果。

5.3 引用透明性的工程价值

代码重构

可以将复杂表达式拆分或合并,而不改变计算语义。

缓存优化

相同输入的纯函数调用可以复用计算结果。

并行优化

独立表达式可以在满足其他资源约束的情况下并行计算。

编译器优化

编译器可以根据语言语义执行常量折叠、公共子表达式消除等优化。

需要注意,编译器优化仍受语言规范和浮点数语义等因素约束,不能简单认为所有看起来相同的表达式都可以随意重排。

六、不可变性与副作用控制

6.1 可变数据带来的问题

考虑下面的代码:

def update_user(user):
    user["age"] = 30
    return user

调用:

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

result = update_user(user)

print(user)
print(result)

输出:

{'name': 'Alice', 'age': 30}
{'name': 'Alice', 'age': 30}

函数直接修改了传入的字典。

调用方可能并不知道 user 已经被改变,这会让程序行为产生隐式依赖。

6.2 使用不可变更新方式

可以创建一个新对象:

def update_user(user):
    return {
        **user,
        "age": 30
    }

调用:

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

result = update_user(user)

print(user)
print(result)

输出:

{'name': 'Alice', 'age': 20}
{'name': 'Alice', 'age': 30}

原始对象保持不变,新的对象表示更新后的状态。

6.3 不可变性与纯函数的关系

不可变性有助于实现纯函数,但二者不是同一个概念。

  • 不可变性关注数据能否被修改。
  • 纯函数关注输入输出关系以及外部可观察影响。

例如:

def calculate(items):
    return sum(items)

即使 items 是可变列表,只要函数只读取数据、不修改数据,也不依赖其他外部状态,它仍然可以是纯函数。

反过来,即使函数只操作不可变对象,如果它读取当前时间或写入文件,也不是纯函数。

因此,不可变性是一种重要的设计手段,但不是纯函数的充分条件。

七、副作用隔离(Side Effect Isolation)

7.1 为什么要隔离副作用

在大型系统中,副作用无法避免。

如果所有业务逻辑都直接访问数据库、网络、文件系统和全局状态,代码就会产生复杂的环境依赖。

例如:

def create_order(user_id, product_id):
    user = database.get_user(user_id)
    product = database.get_product(product_id)

    price = product.price
    discount = discount_service.calculate(user, price)

    database.save_order(user_id, product_id, price - discount)

    payment_service.pay(user_id, price - discount)

这个函数同时承担:

  • 数据查询。
  • 业务计算。
  • 折扣计算。
  • 订单持久化。
  • 支付请求。

任何外部依赖出现问题,都可能影响整个函数。

测试时也需要准备数据库、支付服务和折扣服务等多个依赖。

7.2 将纯计算与外部交互分离

可以把业务计算抽取为纯函数:

def calculate_discount(price, rate):
    return price * rate

def calculate_final_price(price, discount):
    return price - discount

外部交互由应用服务负责:

def create_order(user_id, product_id):
    user = database.get_user(user_id)
    product = database.get_product(product_id)

    discount = calculate_discount(
        product.price,
        user.discount_rate
    )

    final_price = calculate_final_price(
        product.price,
        discount
    )

    database.save_order(
        user_id,
        product_id,
        final_price
    )

    payment_service.pay(user_id, final_price)

虽然应用服务仍然存在副作用,但核心计算逻辑已经独立出来。

这样可以分别测试:

  • 折扣计算是否正确。
  • 最终价格是否正确。
  • 订单服务是否正确调用外部依赖。
  • 支付失败时是否执行正确的异常处理。

7.3 纯计算与副作用隔离架构

flowchart TB
    A["外部请求"] --> B["应用服务层"]
    B --> C["读取外部数据"]
    C --> D["构建业务计算输入"]
    D --> E["纯函数计算层"]
    E --> F["返回计算结果"]
    F --> G["应用服务层处理结果"]
    G --> H["持久化或调用外部服务"]
    H --> I["返回响应"]

    subgraph S["副作用边界"]
        B
        C
        G
        H
    end

    subgraph P["纯计算核心"]
        D
        E
        F
    end

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

这里体现了一种重要的架构思想:

将业务决策与外部交互分离。

纯计算核心负责回答业务规则应该产生什么结果;外部边界负责完成数据读取、持久化和系统交互。

八、函数式核心与命令式外壳

函数式核心与命令式外壳(Functional Core, Imperative Shell)是一种常见的软件设计模式。

它强调:

  • 核心业务逻辑尽可能使用纯函数实现。
  • 外层应用流程负责输入、输出和副作用。
  • 通过明确的数据接口连接两部分。

8.1 架构分层

层次 主要职责 副作用
输入适配层 接收 HTTP、消息、命令 有
应用服务层 组织业务流程 通常有
纯函数核心 业务规则和计算 无
输出适配层 数据库、网络、消息发送 有

8.2 实际示例

假设需要计算订单最终金额。

纯函数核心:

def calculate_order_total(items, discount_rate, tax_rate):
    subtotal = sum(
        item["price"] * item["quantity"]
        for item in items
    )

    discounted = subtotal * (1 - discount_rate)

    total = discounted * (1 + tax_rate)

    return round(total, 2)

应用服务: