一、纯函数与副作用的基本概念
函数式编程强调将程序拆分为可独立推理的计算单元,其中最重要的两个概念是纯函数(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)
对于相同的输入,函数始终产生相同的输出。
数学上可以表示为:
当输入 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 纯函数的形式化理解
可以将纯函数抽象为:
其中:
- 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 两者可以同时存在于一个业务流程中
例如,一个订单系统:
- 接收订单请求。
- 查询商品信息。
- 计算商品总价。
- 计算折扣。
- 写入订单数据。
- 发送支付请求。
- 返回处理结果。
其中:
- 商品信息查询涉及外部资源读取。
- 总价计算可以设计为纯函数。
- 折扣计算可以设计为纯函数。
- 订单写入具有副作用。
- 支付请求具有副作用。
一个良好的架构会尽量让核心业务计算保持纯粹,将外部交互集中在明确的边界。
五、引用透明性(Referential Transparency)
5.1 什么是引用透明性
引用透明性是函数式编程中的重要性质。
如果一个表达式可以被它计算得到的值替换,而不改变程序行为,那么这个表达式具有引用透明性。
例如:
def add(a, b):
return a + b
result = add(10, 20) * 2
因为:
所以表达式可以替换为:
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)
应用服务: