函数式编程艺术 / 02 纯函数与副作用

02 纯函数与副作用

“纯函数是函数式编程的基石——它让代码变得可预测、可测试、可组合。”

2.1 什么是纯函数

纯函数（Pure Function） 是满足以下两个条件的函数：

确定性（Deterministic）：相同的输入永远产生相同的输出
无副作用（No Side Effects）：不修改外部状态，不产生可观察的外部影响

2.1.1 形式化定义

∀ x, y: x = y ⟹ f(x) = f(y)     -- 引用透明
f 的求值不改变任何外部状态              -- 无副作用

2.1.2 纯函数 vs 不纯函数

特征	纯函数	不纯函数
相同输入 → 相同输出	✅ 是	❌ 不一定
无副作用	✅ 是	❌ 否
可缓存	✅ 是	❌ 不安全
可并行执行	✅ 是	⚠️ 需要同步
可测试	✅ 简单	⚠️ 需要 mock

2.2 纯函数示例

Haskell：

-- 纯函数：计算圆的面积
circleArea :: Double -> Double
circleArea r = pi * r * r

-- 纯函数：列表求和
sumList :: [Int] -> Int
sumList = foldl (+) 0

-- 纯函数：字符串首字母大写
capitalize :: String -> String
capitalize [] = []
capitalize (x:xs) = toUpper x : xs

JavaScript：

// 纯函数：计算圆的面积
const circleArea = (r) => Math.PI * r * r;

// 纯函数：列表求和
const sumList = (xs) => xs.reduce((a, b) => a + b, 0);

// 纯函数：字符串首字母大写
const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);

// 纯函数：价格计算（含折扣和税）
const calculatePrice = (basePrice, discountRate, taxRate) =>
  basePrice * (1 - discountRate) * (1 + taxRate);

Python：

import math

# 纯函数：计算圆的面积
def circle_area(r):
    return math.pi * r * r

# 纯函数：列表求和
def sum_list(xs):
    return sum(xs)

# 纯函数：价格计算
def calculate_price(base_price, discount_rate, tax_rate):
    return base_price * (1 - discount_rate) * (1 + tax_rate)

Rust：

// 纯函数：计算圆的面积
fn circle_area(r: f64) -> f64 {
    std::f64::consts::PI * r * r
}

// 纯函数：列表求和
fn sum_list(xs: &[i32]) -> i32 {
    xs.iter().sum()
}

// 纯函数：价格计算
fn calculate_price(base_price: f64, discount_rate: f64, tax_rate: f64) -> f64 {
    base_price * (1.0 - discount_rate) * (1.0 + tax_rate)
}

Clojure：

;; 纯函数：计算圆的面积
(defn circle-area [r]
  (* Math/PI r r))

;; 纯函数：列表求和
(defn sum-list [xs]
  (reduce + 0 xs))

;; 纯函数：价格计算
(defn calculate-price [base-price discount-rate tax-rate]
  (* base-price (- 1 discount-rate) (+ 1 tax-rate)))

2.3 副作用（Side Effect）

副作用是指函数在计算结果之外对外部世界产生的任何可观察影响。

2.3.1 常见副作用类型

副作用类型	示例	严重程度
修改可变状态	修改全局变量、修改传入对象	高
I/O 操作	读写文件、网络请求、打印	中
修改数据库	插入、更新、删除记录	高
抛出异常	throw, panic	中
调用不纯函数	`Math.random()`, `Date.now()`	低-高
修改 DOM	网页元素操作	中
日志记录	console.log, logger.info	低

2.3.2 不纯函数示例

JavaScript：

// 不纯：依赖外部可变变量
let taxRate = 0.1;
const calculateTax = (price) => price * taxRate;  // 外部状态依赖

// 不纯：修改输入参数
const addItem = (cart, item) => {
  cart.items.push(item);  // 修改了 cart
  return cart;
};

// 不纯：有 I/O 副作用
const saveUser = async (user) => {
  await db.insert('users', user);  // 数据库操作
  console.log('User saved');        // 日志输出
  return user;
};

// 不纯：依赖随机数
const generateId = () => Math.random().toString(36).substr(2, 9);

// 不纯：依赖时间
const getTimestamp = () => Date.now();

2.3.3 将不纯函数转为纯函数

JavaScript：

// 方案 1：通过参数注入依赖
const calculateTax = (price, taxRate) => price * taxRate;

// 方案 2：返回新对象而非修改输入
const addItem = (cart, item) => ({
  ...cart,
  items: [...cart.items, item],
});

// 方案 3：将随机数作为参数传入
const generateId = (seed) => `id-${seed.toString(36)}`;

// 方案 4：将时间作为参数传入
const getTimestamp = (now) => now;

2.4 引用透明性（Referential Transparency）

引用透明性是指一个表达式可以被它的值替换而不改变程序的行为。这是纯函数最重要的性质。

2.4.1 示例

// 引用透明
const double = (x) => x * 2;
double(5)  // 可以被替换为 10

// 非引用透明
let count = 0;
const increment = () => ++count;
increment()  // 每次调用结果不同，不可替换

2.4.2 引用透明的好处

好处	说明
等式推理	可以用数学方式推导程序行为
编译优化	编译器可安全内联、消除重复计算
缓存（Memoization）	相同输入直接返回缓存结果
并行安全	无共享可变状态，无需同步
重构安全	替换等价表达式不会引入 bug

2.4.3 Memoization 示例

JavaScript：

const memoize = (fn) => {
  const cache = new Map();
  return (...args) => {
    const key = JSON.stringify(args);
    if (cache.has(key)) return cache.get(key);
    const result = fn(...args);
    cache.set(key, result);
    return result;
  };
};

// 纯函数可以安全地 memoize
const fibonacci = memoize((n) => {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
});

fibonacci(100)  // 快速计算，因为中间结果被缓存

Python：

from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

fibonacci(100)  # 快速计算

Rust：

use std::collections::HashMap;
use std::cell::RefCell;

thread_local! {
    static CACHE: RefCell<HashMap<u64, u64>> = RefCell::new(HashMap::new());
}

fn fibonacci(n: u64) -> u64 {
    CACHE.with(|cache| {
        if let Some(&result) = cache.borrow().get(&n) {
            return result;
        }
        let result = if n <= 1 { n } else { fibonacci(n - 1) + fibonacci(n - 2) };
        cache.borrow_mut().insert(n, result);
        result
    })
}

Clojure：

;; Clojure 内置 memoize
(def fibonacci
  (memoize
    (fn [n]
      (if (<= n 1) n
        (+ (fibonacci (- n 1)) (fibonacci (- n 2)))))))

(fibonacci 100)  ;; 快速计算

2.5 幂等性（Idempotency）

幂等性是指一个操作执行一次和执行多次的结果相同。

2.5.1 幂等 vs 纯函数

概念	定义	举例
纯函数	f(x) ≡ f(x)，无副作用	`abs(-5)` 永远返回 5
幂等函数	f(f(x)) ≡ f(x)	HTTP GET 请求
关系	纯函数一定是幂等的，幂等函数不一定是纯的	`deleteUser(42)` 幂等但有副作用

2.5.2 幂等性示例

JavaScript：

// 幂等：设置值
const setValue = (key, value, store) => ({
  ...store,
  [key]: value,
});
// setValue('x', 1, {}) === setValue('x', 1, setValue('x', 1, {}))

// 非幂等：增加值
const increment = (key, store) => ({
  ...store,
  [key]: (store[key] || 0) + 1,
});
// increment('x', {}) !== increment('x', increment('x', {}))

// HTTP 中的幂等性
// GET    /users/42  → 幂等
// PUT    /users/42  → 幂等（完整替换）
// POST   /users     → 非幂等（创建新资源）
// DELETE /users/42  → 幂等

2.6 副作用的隔离策略

既然副作用不可避免，关键是如何隔离和管理它们。

2.6.1 洋葱架构（Onion Architecture）

外部世界（I/O、数据库、网络）
    ↓ 副作用层（Impure Shell）
        ↓ 核心业务逻辑（Pure Functions）
    ↑ 副作用层（Impure Shell）
外部世界

2.6.2 策略对比

策略	描述	适用场景
参数注入	将副作用结果作为参数传入	简单场景
依赖反转	通过接口抽象外部依赖	中大型项目
IO Monad	用类型系统标记副作用	Haskell
Effect System	专用效果系统管理副作用	Koka, Eff, Unison
纯函数内核	核心逻辑纯函数，外壳处理副作用	大型系统

2.6.3 纯函数内核示例

JavaScript：

// 纯函数核心 — 业务逻辑
const processOrder = (order, products) => {
  const items = order.items.map(item => ({
    ...item,
    product: products.find(p => p.id === item.productId),
    subtotal: item.quantity * products.find(p => p.id === item.productId).price,
  }));
  const total = items.reduce((sum, i) => sum + i.subtotal, 0);
  return { ...order, items, total };
};

// 不纯外壳 — I/O 操作
const handleOrderRequest = async (orderId) => {
  const order = await db.getOrder(orderId);           // 副作用：数据库读
  const products = await db.getProducts();             // 副作用：数据库读
  const result = processOrder(order, products);        // 纯函数调用
  await db.saveOrder(result);                          // 副作用：数据库写
  await email.sendConfirmation(result.customerEmail);  // 副作用：邮件发送
  return result;
};

Haskell（使用 IO Monad）：

-- 纯函数核心
processOrder :: Order -> [Product] -> ProcessedOrder
processOrder order products =
  let items = map (enrichItem products) (orderItems order)
      total = sum $ map subtotal items
  in order { processedItems = items, orderTotal = total }

-- IO 外壳
handleOrderRequest :: OrderId -> IO ProcessedOrder
handleOrderRequest orderId = do
  order <- getOrderFromDB orderId        -- IO Action
  products <- getProductsFromDB          -- IO Action
  let result = processOrder order products  -- 纯计算
  saveOrderToDB result                   -- IO Action
  sendConfirmationEmail result           -- IO Action
  return result

2.7 可测试性

纯函数最大的工程优势之一是卓越的可测试性。

2.7.1 测试对比

测试需求	纯函数	不纯函数
输入输出测试	✅ 直接断言	⚠️ 需要验证副作用
Mock 外部依赖	❌ 不需要	✅ 必须 mock
测试顺序依赖	❌ 无	✅ 有
并行测试	✅ 安全	⚠️ 可能冲突
测试速度	✅ 快	⚠️ 可能慢（I/O）

2.7.2 测试示例

JavaScript（使用 Jest）：

// 纯函数测试 — 非常简单
describe('calculatePrice', () => {
  test('applies discount and tax correctly', () => {
    expect(calculatePrice(100, 0.1, 0.08)).toBe(97.2);
  });

  test('zero discount', () => {
    expect(calculatePrice(100, 0, 0.08)).toBe(108);
  });

  test('zero tax', () => {
    expect(calculatePrice(100, 0.1, 0)).toBe(90);
  });
});

// 可以轻松进行 Property-based Testing
const fc = require('fast-check');

describe('sumList properties', () => {
  test('identity: sum of empty list is 0', () => {
    expect(sumList([])).toBe(0);
  });

  test('commutativity: order does not matter', () => {
    fc.assert(fc.property(
      fc.array(fc.integer()),
      (arr) => sumList(arr) === sumList([...arr].reverse())
    ));
  });
});

Python（使用 pytest）：

import pytest

def test_calculate_price_basic():
    assert calculate_price(100, 0.1, 0.08) == 97.2

def test_calculate_price_no_discount():
    assert calculate_price(100, 0, 0.08) == 108.0

def test_calculate_price_no_tax():
    assert calculate_price(100, 0.1, 0) == 90.0

# Property-based testing with Hypothesis
from hypothesis import given, strategies as st

@given(st.lists(st.integers()))
def test_sum_list_empty(xs):
    # sum of reversed list equals sum of original
    assert sum_list(xs) == sum_list(list(reversed(xs)))

2.8 业务场景

2.8.1 电商价格计算引擎

// 纯函数：完整的价格计算规则
const applyPromotionRules = (rules, cart) =>
  rules.reduce((acc, rule) => rule(acc), cart);

const buyOneGetOneFree = (cart) => ({
  ...cart,
  items: cart.items.map(item =>
    item.category === 'books'
      ? { ...item, price: item.price * Math.ceil(item.quantity / 2) / item.quantity }
      : item
  ),
});

const bulkDiscount = (cart) => ({
  ...cart,
  items: cart.items.map(item =>
    item.quantity >= 10
      ? { ...item, price: item.price * 0.8 }
      : item
  ),
});

// 组合规则
const cart = { items: [{ category: 'books', price: 50, quantity: 3 }] };
const finalCart = applyPromotionRules([buyOneGetOneFree, bulkDiscount], cart);
// 每个规则都是纯函数，可以单独测试

2.8.2 数据验证管道

def validate_email(email):
    if '@' not in email:
        return Left("Invalid email: missing @")
    return Right(email)

def validate_age(age):
    if not (0 <= age <= 150):
        return Left(f"Invalid age: {age}")
    return Right(age)

def validate_name(name):
    if len(name.strip()) == 0:
        return Left("Name cannot be empty")
    return Right(name.strip())

# 纯函数：可独立测试、可组合
def validate_user(user):
    return (
        validate_name(user['name'])
        .flat_map(lambda n: validate_email(user['email'])
        .flat_map(lambda e: validate_age(user['age'])
        .map(lambda a: {'name': n, 'email': e, 'age': a})))
    )

2.9 注意事项

2.9.1 常见陷阱

陷阱	说明	解决方案
隐式依赖	函数依赖全局变量	通过参数传入所有依赖
对象变异	修改传入的对象	返回新对象或深拷贝
数组变异	push/splice 修改原数组	使用展开运算符或 concat
Date 陷阱	`new Date()` 产生不同结果	将时间作为参数传入
随机数	`Math.random()` 不确定	将种子作为参数传入
异常	抛出异常是副作用	使用 Result/Either 类型

2.9.2 容易被忽略的不纯操作

// 看起来纯，实际不纯的操作
const obj = { a: 1, b: 2 };

// 不纯：Object.keys 的顺序在某些引擎中依赖内部状态
Object.keys(obj);  // 可能因引擎实现而异

// 不纯：Array.prototype.sort 修改原数组
const arr = [3, 1, 2];
arr.sort();  // arr 被修改了！

// 纯版本
const sorted = [...arr].sort((a, b) => a - b);

2.10 小结

要点	说明
纯函数	相同输入 → 相同输出，无副作用
引用透明	表达式可被其值替换，程序行为不变
副作用	I/O、可变状态修改、异常等
隔离策略	参数注入、依赖反转、IO Monad、纯函数内核
幂等性	执行多次与执行一次结果相同
可测试性	纯函数无需 mock，可直接测试

扩展阅读

《Functional-Light JavaScript》 — Kyle Simpson，第 5 章 Pure Functions
Why Functional Programming Matters — John Hughes
Purity is Compelling — Matt Parsons
《计算机程序的构造和解释》 — Abelson & Sussman，第 1 章

下一章：03 不可变数据 — 理解不可变性如何让代码更安全