纯函数详解

作者头像东城·2026-01-31 23:27:46·
理解函数式编程
函数式编程是一种编程风格或范式，专注于通过创建和组合函数来构建软件。这样想：您编写小的、自包含的代码片段（函数），它们接受输入，执行一些操作，然后产生输出。一个核心思想是，对于相同的输入，您总是会得到相同的输出，使代码可预测。
为什么使用函数式编程？
可重用：函数被设计为独立的，这意味着您可以轻松地在代码的不同部分或各种模块中重用它们，只要您需要它们的特定输出
无状态：函数式程序旨在"无状态"。这意味着函数的输出完全取决于其输入，而不是任何可变的内部或外部状态。无论您用相同的输入运行函数多少次，您总是会得到相同的输出
更容易测试：因为函数是自包含的、可预测的，并且不会产生副作用（自身之外的变化），所以它们更容易测试和调试
并发友好：函数式编程的无状态和不可变特性使得编写在并行环境中正确运行的代码更容易，减少了多线程应用程序中的常见问题
纯函数
函数式编程严重依赖于一个称为纯函数的概念。那么，到底是什么让一个函数变得"纯"呢？纯函数必须严格遵循这3个规则：
规则1：总是返回单个值
纯函数必须始终产生恰好一个输出值。
错误示例：
  1. static char getFirstCharacter(String s) {
  2. return s.charAt(0);
  3. }
java
这是"错误"的，因为根据字符串s是否为空或null，它可能返回第一个字符或抛出错误。这意味着它的"返回"有多个可能的结果。
正确示例：
  1. static int increment(int x) {
  2. return x + 1;
  3. }
java
这是"正确"的，因为它可预测地返回单个值：输入x加一。
规则2：仅基于其参数（输入）计算返回值
纯函数的输出应该仅由作为参数传递给它的值决定。它不能依赖或受任何可能改变的外部数据、变量或系统状态的影响。
错误示例：
  1. static double randomPart(double x){
  2. return x + Math.random();
  3. }
java
这是"错误"的，因为Math.random()每次调用时都会生成不同的随机数。这使得即使使用相同的x输入，函数的返回值也是不可预测的。这种由函数外部事物引起的不可预测变化被称为"副作用"。
正确示例：
  1. static int add(int a, int b){
  2. return a + b;
  3. }
java
这是"正确"的，因为对于相同的输入a和b，它总是返回相同的和。
规则3：不改变（变异）任何现有值或外部状态
纯函数不能修改传递给它的任何数据，也不应该改变其自身作用域之外的任何变量或对象。它产生新数据而不是改变旧数据。
错误示例：
  1. public static void addTag(User user, String tag) {
  2. user.tags.add(tag);
  3. }
java
虽然这段代码有效，但在纯函数上下文中被认为是"错误"的，因为它直接修改了传入的user对象。如果您用相同的user对象多次调用此函数，user.tags列表将不断变化。这种对现有对象的修改被称为变异值（副作用），违反了规则#3。
正确示例：
  1. public static User addTag(User user, String tag) {
  2. List<String> newTags = new ArrayList<>(user.tags);
  3. newTags.add(tag);
  4. return new User(newTags);
  5. }
java
这是"正确"的，因为addTag函数不会改变原始user对象。相反，它创建一个新列表（newTags），将新标签添加到该新列表中，然后返回一个包含这些更改的新User对象。原始user对象保持完全不变，从而避免任何副作用并遵守"无变异"规则。
纯函数示例
这是一个明确遵循纯函数所有3个规则的函数示例：
  1. public static int calculateTotalPrice(int pricePerItem, int quantity, int discountPercent) {
  2. int total = pricePerItem * quantity;
  3. int discount = total * discountPercent / 100;
  4. return total - discount;
  5. }

  7. public static void main(String[] args) {
  8. int result = calculateTotalPrice(100, 5, 10); // 100 * 5 = 500 - 10% = 450
  9. System.out.println("折扣后总价: " + result);
  10. }
java
如果一个函数违反了这3个规则中的任何一个，它就变成了非纯函数。虽然非纯函数可以存在于您的代码中（特别是由于第三个规则），但它们可能不会完全符合函数式编程的目标。
处理大数据和性能
有时，在处理大量数据时，比如列表或集合，复制所有内容以创建新的、不可变版本可能会损害性能。在这种情况下，您可能必须接受使数据可变来解决性能问题。这是您需要考虑的权衡。如果性能不受影响，保持数据不可变总是更好。
一些语言（如JavaScript或Scala）有默认不可变的内置集合，所以您不需要手动复制它们来防止变异。但Java需要复制到新集合以实现不可变。
这是在函数内创建新集合以防止变异原始集合的示例：
  1. public static List<Integer> doubleAllValues(List<Integer> numbers) {
  2. List<Integer> result = new ArrayList<>(); // 创建新集合以避免改变原始集合
  3. for (int num : numbers) {
  4. result.add(num * 2);
  5. }
  6. return result;
  7. }

  9. public static void main(String[] args) {
  10. List<Integer> original = new ArrayList<>();
  11. original.add(1);
  12. original.add(2);
  13. original.add(3);

  15. List<Integer> doubled = doubleAllValues(original);

  17. System.out.println("原始列表: " + original); // 输出: 原始列表: [1, 2, 3] (未改变)
  18. System.out.println("翻倍列表: " + doubled); // 输出: 翻倍列表: [2, 4, 6]
  19. }
java
JavaScript中的纯函数示例
让我们看看JavaScript中的纯函数示例：
  1. // 纯函数示例
  2. function add(a, b) {
  3. return a + b;
  4. }

  6. function multiply(a, b) {
  7. return a * b;
  8. }

  10. function calculateDiscount(price, discountPercent) {
  11. return price * (1 - discountPercent / 100);
  12. }

  14. // 非纯函数示例
  15. let total = 0;

  17. function addToTotal(amount) {
  18. total += amount; // 修改外部状态
  19. return total;
  20. }

  22. function getRandomNumber() {
  23. return Math.random(); // 依赖外部随机数生成器
  24. }

  26. function updateUser(user, newName) {
  27. user.name = newName; // 直接修改传入的对象
  28. return user;
  29. }

  31. // 纯函数版本
  32. function createUpdatedUser(user, newName) {
  33. return {
  34. ...user,
  35. name: newName
  36. };
  37. }
javascript
纯函数的优势
1. 可预测性
  1. // 纯函数 - 总是可预测
  2. function square(x) {
  3. return x * x;
  4. }

  6. console.log(square(5)); // 25
  7. console.log(square(5)); // 25 (总是相同)
  8. console.log(square(5)); // 25 (总是相同)
javascript
2. 易于测试
  1. // 纯函数易于测试
  2. function isEven(num) {
  3. return num % 2 === 0;
  4. }

  6. // 测试
  7. console.log(isEven(2) === true); // true
  8. console.log(isEven(3) === false); // true
  9. console.log(isEven(0) === true); // true
javascript
3. 可缓存性
  1. // 纯函数的结果可以被缓存
  2. const cache = new Map();

  4. function expensiveCalculation(x) {
  5. if (cache.has(x)) {
  6. return cache.get(x);
  7. }
  9. const result = x * x + 2 * x + 1; // 模拟昂贵计算
  10. cache.set(x, result);
  11. return result;
  12. }
javascript
实际应用场景
1. 数据处理
  1. // 纯函数处理数据
  2. function filterUsers(users, age) {
  3. return users.filter(user => user.age >= age);
  4. }

  6. function sortUsers(users, field) {
  7. return [...users].sort((a, b) => a[field].localeCompare(b[field]));
  8. }

  10. function mapUserNames(users) {
  11. return users.map(user => user.name);
  12. }
javascript
2. 状态管理
  1. // Redux中的纯reducer函数
  2. function todoReducer(state = [], action) {
  3. switch (action.type) {
  4. case 'ADD_TODO':
  5. return [...state, {
  6. id: Date.now(),
  7. text: action.text,
  8. completed: false
  9. }];
  10. case 'TOGGLE_TODO':
  11. return state.map(todo =>
  12. todo.id === action.id
  13. ? { ...todo, completed: !todo.completed }
  14. : todo
  15. );
  16. default:
  17. return state;
  18. }
  19. }
javascript
最佳实践
1. 避免副作用
  1. // ❌ 非纯函数 - 有副作用
  2. function updateCounter() {
  3. counter++; // 修改外部变量
  4. return counter;
  5. }

  7. // ✅ 纯函数 - 无副作用
  8. function incrementCounter(currentCount) {
  9. return currentCount + 1;
  10. }
javascript
2. 不修改输入参数
  1. // ❌ 非纯函数 - 修改输入
  2. function addToArray(arr, item) {
  3. arr.push(item); // 修改原始数组
  4. return arr;
  5. }

  7. // ✅ 纯函数 - 不修改输入
  8. function addToArray(arr, item) {
  9. return [...arr, item]; // 返回新数组
  10. }
javascript
3. 避免依赖外部状态
  1. // ❌ 非纯函数 - 依赖外部状态
  2. let taxRate = 0.1;
  3. function calculateTax(amount) {
  4. return amount * taxRate; // 依赖外部变量
  5. }

  7. // ✅ 纯函数 - 不依赖外部状态
  8. function calculateTax(amount, rate) {
  9. return amount * rate;
  10. }
javascript
总结
理解纯函数及其3个规则是编写函数式代码的一个很好的起点。纯函数只是函数式编程拼图中的一个部分；还有许多其他概念需要探索！
关键要点：
纯函数总是返回单个值
纯函数仅基于输入参数计算输出
纯函数不修改任何现有值或外部状态
纯函数使代码更可预测、更易测试、更易维护
在性能允许的情况下，优先使用纯函数
掌握纯函数的概念将帮助您编写更可靠、更可维护的代码，特别是在处理复杂的数据转换和状态管理时。