第五部分：函数式编程核心特性详解 —— 让数据流更清晰
函数式编程（Functional Programming，FP）的三大核心——不可变数据、纯函数与函数组合，如今已成为现代编程语言的标配功能。深入掌握这些特性，能让代码更加简洁高效、易于测试，何乐而不为？
5.1 高阶函数与闭包
首先来看高阶函数。简单来说，高阶函数能够接收函数作为参数，或将函数作为返回值返回。这种灵活性极大增强了代码的表达能力。
示例25：JavaScript中的高阶函数
// 接受函数作为参数
function repeat(times, action) {
for (let i = 0; i < times; i++) {
action(i);
}
}
repeat(3, i => console.log(`Iteration ${i}`));
// 返回函数（闭包）
function multiplyBy(factor) {
return function(number) {
return number * factor;
};
}
const double = multiplyBy(2);
console.log(double(5)); // 10闭包则是函数及其词法环境的打包组合。即使外部函数已经执行完毕，内部函数仍然能够访问外部变量。这种特性在数据隐藏和部分应用场景中尤为实用。
5.2 不可变数据结构与持久化集合
不可变性的优势十分显著——能够有效消除副作用，让并发编程更加省心。许多语言都内置了不可变集合，或者提供了操作不可变数据的便捷方法。
示例26：Java的不可变集合
import ja va.util.List;
import ja va.util.Map;
import ja va.util.Set;
// Ja va 9+ 工厂方法创建不可变集合
List list = List.of("a", "b", "c");
list.add("d"); // 抛出 UnsupportedOperationException
// 使用不可变副本（Ja va 10+）
var mutable = new ArrayList();
mutable.add("x");
var immutable = List.copyOf(mutable); // 不可变副本
// 使用Stream API产生新集合而不修改原集合
var original = List.of(1, 2, 3);
var doubled = original.stream()
.map(i -> i * 2)
.collect(Collectors.toList());
// original 不变 示例27：Python中利用tuple和namedtuple实现不可变数据
from collections import namedtuple
# 普通tuple
point = (10, 20)
# point[0] = 30 # 错误，tuple不可变
# namedtuple
Person = namedtuple('Person', ['name', 'age'])
alice = Person('Alice', 30)
# alice.age = 31 # 错误，不可变
# 要修改需创建新对象
bob = alice._replace(name='Bob') # 返回新实例对于深层嵌套的不可变数据结构，可以借助第三方库如 pyrsistent 来实现。
5.3 纯函数与副作用管理
纯函数的定义非常简洁：相同的输入永远产生相同的输出，且不会访问外部状态或执行 I/O 操作。这类函数测试起来最方便，逻辑也最容易推演。
示例28：区分纯函数与不纯函数
// 纯函数
function add(a, b) {
return a + b;
}
// 不纯：依赖外部状态
let taxRate = 0.1;
function applyTax(price) {
return price * (1 + taxRate);
// taxRate可能变化
}
// 不纯：修改外部状态
let total = 0;
function addToTotal(value) {
total += value;
return total;
}
// 不纯：I/O操作
function logToConsole(message) {
console.log(message); // 副作用
}在实际项目中，应尽量将业务逻辑实现为纯函数，而将有副作用的操作（如数据库访问、网络请求、日志记录）推向系统边界处理。再结合依赖注入，代码的可测试性和可维护性将得到显著提升。
5.4 惰性求值与Stream API
惰性求值的思路非常巧妙——只在真正需要结果时才进行计算。这样可以避免大量无意义的计算，从而提升性能。
示例29：Java Stream的惰性特性
import ja va.util.stream.Stream;
public class LazyDemo {
public static void main(String[] args) {
Stream stream = Stream.of(1, 2, 3, 4, 5)
.peek(x -> System.out.println("原始: " + x))
.map(x -> x * 2)
.peek(x -> System.out.println("翻倍: " + x))
.filter(x -> x > 5);
System.out.println("Stream构建完成，但尚未执行任何操作");
// 终端操作触发计算
long count = stream.count();
System.out.println("结果数量: " + count);
}
}
/* 输出:
Stream构建完成，但尚未执行任何操作
原始: 1
翻倍: 2
原始: 2
翻倍: 4
原始: 3
翻倍: 6
原始: 4
翻倍: 8
原始: 5
翻倍: 10
结果数量: 3
*/ 这里需要说明：中间操作（如 peek、map、filter）都是惰性的，只有当终端操作（如 count）被调用时才会真正开始遍历数据。这种方式既避免了创建临时中间集合，又允许短路操作（如 limit、findFirst）提前终止，从而提高运行效率。
示例30：Python生成器实现惰性序列
def fibonacci():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
# 惰性生成，不会预先计算所有斐波那契数
fib = fibonacci()
for _ in range(10):
print(next(fib)) # 0,1,1,2,3,5,8,13,21,34
# 使用itertools的islice取出前100个中的偶数
import itertools
first_100 = itertools.islice(fibonacci(), 100)
evens = filter(lambda x: x % 2 == 0, first_100)
print(list(itertools.islice(evens, 5))) # 0, 2, 8, 34, 144
