1.1 什么是副作用？

副作用（Side Effect）是指函数除了返回值之外，对外部世界产生的影响：

// 有副作用的函数
let counter = 0;

function incrementAndGet(): number {
  counter++;           // 副作用：修改外部状态
  console.log(counter); // 副作用：I/O操作
  return counter;
}

// 多次调用结果不同 - 不是纯函数
console.log(incrementAndGet()); // 1
console.log(incrementAndGet()); // 2
console.log(incrementAndGet()); // 3

常见的副作用：

• 修改全局变量
• 修改输入参数
• I/O 操作（文件、网络、数据库）
• 打印日志
• 抛出异常
• 获取当前时间
• 生成随机数

1.2 纯函数的特性

纯函数（Pure Function）满足两个条件：

1. 引用透明：相同输入总是产生相同输出
2. 无副作用：不改变外部状态

// 纯函数示例
function add(a: number, b: number): number {
  return a + b;
}

// 引用透明：可以用结果替换函数调用
const x = add(2, 3);  // 5
const y = 5;          // 完全等价

// 可以安全地缓存（memoization）
const memoizedAdd = memoize(add);

纯函数的优势：

• ✅ 易于测试：无需 mock 外部依赖
• ✅ 易于推理：局部性强，不依赖上下文
• ✅ 易于并发：无共享状态，天然线程安全
• ✅ 易于优化：编译器可以安全地重排序、缓存

1.3 现实的矛盾：程序必须产生副作用

这里是悖论：有用的程序必然产生副作用。

一个完全没有副作用的程序是无用的——它既不读取输入，也不产生输出，对外界毫无影响。

// 这个程序完全纯函数，但毫无用处
function uselessProgram(): void {
  const result = add(2, 3);
  // 没有输出，没有副作用，计算结果被丢弃
}

函数式编程的实用主义：

• ❌ 目标不是消除副作用
• ✅ 目标是控制和隔离副作用

2.1 函数式核心，命令式外壳

Gary Bernhardt 提出的 "Functional Core, Imperative Shell" 模式：

// === 纯函数核心：业务逻辑 ===

interface Order {
  id: string;
  items: Array<{ price: number; quantity: number }>;
  discount?: number;
}

interface OrderSummary {
  subtotal: number;
  discount: number;
  tax: number;
  total: number;
}

// 纯函数：计算订单总额
function calculateOrderSummary(order: Order): OrderSummary {
  const subtotal = order.items.reduce(
    (sum, item) => sum + item.price * item.quantity,
    0
  );
  
  const discount = order.discount || 0;
  const discountedAmount = subtotal * (1 - discount);
  const tax = discountedAmount * 0.1; // 10% tax
  const total = discountedAmount + tax;
  
  return { subtotal, discount: subtotal * discount, tax, total };
}

// === 命令式外壳：副作用 ===

class OrderService {
  constructor(
    private db: Database,
    private emailService: EmailService,
    private logger: Logger
  ) {}
  
  async processOrder(orderId: string): Promise<void> {
    // 副作用：读取数据库
    const order = await this.db.getOrder(orderId);
    
    // 纯函数计算
    const summary = calculateOrderSummary(order);
    
    // 副作用：写入数据库
    await this.db.saveOrderSummary(orderId, summary);
    
    // 副作用：发送邮件
    await this.emailService.sendOrderConfirmation(order, summary);
    
    // 副作用：记录日志
    this.logger.info(`Order ${orderId} processed, total: ${summary.total}`);
  }
}

关键思想：

• 核心业务逻辑用纯函数实现（易于测试和推理）
• 将所有副作用推到边界（数据库、API、日志等）

2.2 依赖注入：副作用的显式化

通过依赖注入，将副作用从隐式变为显式：

// ❌ 隐式依赖：难以测试
function getCurrentUserAge(): number {
  const now = new Date();        // 隐式依赖：当前时间
  const user = fetchUser();      // 隐式依赖：数据库
  return now.getFullYear() - user.birthYear;
}

// ✅ 显式依赖：易于测试
function calculateUserAge(
  currentYear: number,
  user: { birthYear: number }
): number {
  return currentYear - user.birthYear;
}

// 使用时注入依赖
const age = calculateUserAge(
  new Date().getFullYear(),
  await fetchUser()
);

// 测试时无需 mock
expect(calculateUserAge(2025, { birthYear: 1990 })).toBe(35);

2.3 Effect Systems：类型化的副作用

现代语言使用类型系统追踪副作用：

// TypeScript + Effect-TS 示例
import { Effect } from 'effect';

// 定义副作用类型
type DatabaseError = { _tag: 'DatabaseError'; message: string };
type NetworkError = { _tag: 'NetworkError'; message: string };

// 返回类型明确声明可能的副作用
function getUser(id: string): Effect.Effect<
  User,                          // 成功值
  DatabaseError | NetworkError,  // 可能的错误
  Database | Logger              // 需要的依赖
> {
  return Effect.gen(function* (_) {
    const db = yield* _(Effect.service(Database));
    const logger = yield* _(Effect.service(Logger));
    
    yield* _(logger.info(`Fetching user ${id}`));
    
    const user = yield* _(
      Effect.tryPromise({
        try: () => db.query('SELECT * FROM users WHERE id = ?', [id]),
        catch: (error) => ({
          _tag: 'DatabaseError' as const,
          message: String(error)
        })
      })
    );
    
    return user;
  });
}

// 使用时，所有副作用都在类型中可见
const program = getUser('123').pipe(
  Effect.map(user => user.email),
  Effect.catchAll(error => Effect.succeed('default@email.com'))
);

// 在最外层执行副作用
Effect.runPromise(program);

优势：

• 副作用在类型签名中明确
• 编译器强制处理所有可能的错误
• 副作用的组合是类型安全的

3.1 可变性的陷阱

// ❌ 可变性导致的 bug
function addItem(cart: Cart, item: Item): Cart {
  cart.items.push(item);  // 修改了原对象！
  return cart;
}

const myCart = { items: [] };
const newCart = addItem(myCart, { id: '1', name: 'Book' });

console.log(myCart === newCart);  // true！同一个对象
// 导致难以追踪的状态变化

3.2 结构共享的不可变更新

// ✅ 不可变更新
function addItem(cart: Cart, item: Item): Cart {
  return {
    ...cart,
    items: [...cart.items, item]  // 创建新数组
  };
}

const myCart = { items: [] };
const newCart = addItem(myCart, { id: '1', name: 'Book' });

console.log(myCart === newCart);        // false
console.log(myCart.items.length);       // 0（原对象未改变）
console.log(newCart.items.length);      // 1

3.3 Immer：便捷的不可变更新

import { produce } from 'immer';

// 复杂嵌套结构的更新
interface State {
  users: {
    [id: string]: {
      name: string;
      posts: Array<{ id: string; likes: number }>;
    };
  };
}

// 不使用 Immer：繁琐
function likePost(state: State, userId: string, postId: string): State {
  return {
    ...state,
    users: {
      ...state.users,
      [userId]: {
        ...state.users[userId],
        posts: state.users[userId].posts.map(post =>
          post.id === postId
            ? { ...post, likes: post.likes + 1 }
            : post
        )
      }
    }
  };
}

// 使用 Immer：简洁且类型安全
function likePostWithImmer(state: State, userId: string, postId: string): State {
  return produce(state, draft => {
    const post = draft.users[userId].posts.find(p => p.id === postId);
    if (post) {
      post.likes++;  // 看起来是mutation，实际是不可变的
    }
  });
}

Immer 使用 Proxy 实现"写时复制"（Copy-on-Write），只复制实际修改的路径。

4.1 函数是一等公民

// 函数可以作为参数
function repeat(n: number, fn: () => void): void {
  for (let i = 0; i < n; i++) {
    fn();
  }
}

repeat(3, () => console.log('Hello')); // 打印3次

// 函数可以作为返回值
function multiplier(factor: number): (x: number) => number {
  return (x: number) => x * factor;
}

const double = multiplier(2);
const triple = multiplier(3);

console.log(double(5));  // 10
console.log(triple(5));  // 15

4.2 常见的高阶函数

const numbers = [1, 2, 3, 4, 5];

// map: 转换每个元素
const doubled = numbers.map(x => x * 2);
// [2, 4, 6, 8, 10]

// filter: 筛选元素
const evens = numbers.filter(x => x % 2 === 0);
// [2, 4]

// reduce: 聚合
const sum = numbers.reduce((acc, x) => acc + x, 0);
// 15

// 组合使用
const sumOfEvenSquares = numbers
  .filter(x => x % 2 === 0)
  .map(x => x * x)
  .reduce((acc, x) => acc + x, 0);
// 4 + 16 = 20

4.3 函数组合（Composition）

// 小而专注的函数
const trim = (s: string): string => s.trim();
const toLowerCase = (s: string): string => s.toLowerCase();
const removeSpaces = (s: string): string => s.replace(/\s+/g, '');

// 手动组合
function normalizeManual(s: string): string {
  return removeSpaces(toLowerCase(trim(s)));
}

// 使用 pipe（从左到右）
import { pipe } from 'fp-ts/function';

const normalize = (s: string): string =>
  pipe(
    s,
    trim,
    toLowerCase,
    removeSpaces
  );

console.log(normalize('  Hello  World  '));  // "helloworld"

// 使用 compose（从右到左）
import { flow } from 'fp-ts/function';

const normalize2 = flow(
  trim,
  toLowerCase,
  removeSpaces
);

console.log(normalize2('  Hello  World  '));  // "helloworld"

函数组合的优势：

• 小函数易于测试和理解
• 可以灵活重组创建新功能
• 声明式：描述"做什么"而非"怎么做"

5.1 Functor：可 map 的容器

Functor 是可以 map 的数据结构：

// Array 是 Functor
[1, 2, 3].map(x => x * 2);  // [2, 4, 6]

// Promise 是 Functor
Promise.resolve(5).then(x => x * 2);  // Promise<10>

// Option 是 Functor
import { Option, some, none, map } from 'fp-ts/Option';

const maybeNumber: Option<number> = some(5);
const doubled = pipe(maybeNumber, map(x => x * 2));  // some(10)

const noNumber: Option<number> = none;
const stillNone = pipe(noNumber, map(x => x * 2));   // none

实用价值：统一的转换接口，无需关心容器内部结构。

5.2 Monad：可链式调用的容器

Monad 允许链式调用返回相同类型容器的函数：

import { pipe } from 'fp-ts/function';
import * as O from 'fp-ts/Option';

interface User {
  id: string;
  addressId?: string;
}

interface Address {
  id: string;
  zipCode?: string;
}

// 每个函数都可能返回 none
const getUser = (id: string): O.Option<User> => {
  // 数据库查询...
  return O.some({ id: '1', addressId: '100' });
};

const getAddress = (addressId: string): O.Option<Address> => {
  // 数据库查询...
  return O.some({ id: '100', zipCode: '12345' });
};

// ❌ 嵌套的 Option 很难处理
const userOpt = getUser('1');
const addressOpt = pipe(
  userOpt,
  O.map(user => user.addressId ? getAddress(user.addressId) : O.none)
);
// 类型：Option<Option<Address>> ❌

// ✅ flatMap (chain) 扁平化嵌套
const zipCode: O.Option<string> = pipe(
  getUser('1'),
  O.flatMap(user => 
    user.addressId ? getAddress(user.addressId) : O.none
  ),
  O.flatMap(address => 
    address.zipCode ? O.some(address.zipCode) : O.none
  )
);
// 类型：Option<string> ✅

// 使用 getOrElse 提供默认值
const finalZipCode = pipe(
  zipCode,
  O.getOrElse(() => 'Unknown')
);

实用价值：优雅地处理可能失败的操作链。

5.3 实战：Railway-Oriented Programming

Scott Wlaschin 提出的"铁路导向编程"：

import * as E from 'fp-ts/Either';

type ValidationError = string;

// 每个验证函数返回 Either
function validateEmail(email: string): E.Either<ValidationError, string> {
  return email.includes('@')
    ? E.right(email)
    : E.left('Invalid email format');
}

function validateAge(age: number): E.Either<ValidationError, number> {
  return age >= 18
    ? E.right(age)
    : E.left('Must be 18 or older');
}

function validateUsername(username: string): E.Either<ValidationError, string> {
  return username.length >= 3
    ? E.right(username)
    : E.left('Username must be at least 3 characters');
}

interface ValidatedUser {
  email: string;
  age: number;
  username: string;
}

// 组合验证（使用 Applicative）
import { sequenceS } from 'fp-ts/Apply';

function validateUser(
  email: string,
  age: number,
  username: string
): E.Either<ValidationError, ValidatedUser> {
  return pipe(
    sequenceS(E.Applicative)({
      email: validateEmail(email),
      age: validateAge(age),
      username: validateUsername(username)
    })
  );
}

// 使用
const result1 = validateUser('test@example.com', 20, 'john');
// Right({ email: 'test@example.com', age: 20, username: 'john' })

const result2 = validateUser('invalid', 15, 'jo');
// Left('Invalid email format')  // 第一个错误

两条铁轨：

• 成功轨道（Right）
• 失败轨道（Left）

一旦进入失败轨道，后续验证自动跳过。

6.1 Generator：JavaScript 的惰性求值

// 无限序列生成器
function* naturals(): Generator<number> {
  let n = 0;
  while (true) {
    yield n++;
  }
}

function* fibonacci(): Generator<number> {
  let a = 0, b = 1;
  while (true) {
    yield a;
    [a, b] = [b, a + b];
  }
}

// 惰性转换
function* map<T, U>(
  gen: Generator<T>,
  fn: (x: T) => U
): Generator<U> {
  for (const value of gen) {
    yield fn(value);
  }
}

function* filter<T>(
  gen: Generator<T>,
  predicate: (x: T) => boolean
): Generator<T> {
  for (const value of gen) {
    if (predicate(value)) {
      yield value;
    }
  }
}

function* take<T>(gen: Generator<T>, n: number): Generator<T> {
  let count = 0;
  for (const value of gen) {
    if (count++ >= n) break;
    yield value;
  }
}

// 使用：前10个偶数的斐波那契数
const evenFibs = filter(fibonacci(), x => x % 2 === 0);
const first10 = take(evenFibs, 10);

for (const n of first10) {
  console.log(n);
}
// 0, 2, 8, 34, 144, 610, 2584, 10946, 46368, 196418

6.2 实际应用：数据流处理

// 惰性处理大文件
async function* readLargeFile(path: string): AsyncGenerator<string> {
  const stream = fs.createReadStream(path);
  const reader = readline.createInterface({ input: stream });
  
  for await (const line of reader) {
    yield line;
  }
}

// 处理管道
async function processLogs(filePath: string) {
  const lines = readLargeFile(filePath);
  
  const errors = filter(lines, line => line.includes('ERROR'));
  const parsed = map(errors, line => JSON.parse(line));
  const recent = filter(parsed, log => log.timestamp > Date.now() - 3600000);
  
  for await (const log of take(recent, 100)) {
    console.log(log);
  }
}
// 内存效率高：一次只处理一行

7.1 React：UI as a Function

// React组件本质上是纯函数
function UserProfile({ user }: { user: User }) {
  // 输入：props（不可变）
  // 输出：虚拟DOM（不可变）
  return (
<div>
<h1>{user.name}</h1>
<p>{user.email}</p>
</div>
  );
}

// UI = f(state)
// 相同的 state 总是渲染相同的 UI

7.2 Redux：纯函数状态管理

// Reducer 是纯函数
type State = { count: number };
type Action = { type: 'INCREMENT' } | { type: 'DECREMENT' };

function counterReducer(state: State = { count: 0 }, action: Action): State {
  switch (action.type) {
    case 'INCREMENT':
      return { count: state.count + 1 };  // 不可变更新
    case 'DECREMENT':
      return { count: state.count - 1 };
    default:
      return state;
  }
}

// newState = reducer(oldState, action)
// 可预测、可测试、可回放

7.3 管道式API设计

// 流式 API
const result = await database
  .table('users')
  .where('age', '>', 18)
  .where('country', '=', 'US')
  .orderBy('created_at', 'desc')
  .limit(10)
  .get();

// 函数式管道
import { pipe } from 'fp-ts/function';
import * as A from 'fp-ts/Array';

const result2 = pipe(
  users,
  A.filter(u => u.age > 18),
  A.filter(u => u.country === 'US'),
  A.sortBy([descending(u => u.createdAt)]),
  A.take(10)
);

8.1 何时使用函数式编程

✅ 适合的场景：

• 数据转换和处理
• 业务逻辑计算
• 配置和规则引擎
• 并发和并行任务

❌ 不太适合的场景：

• 性能关键的循环（可变性可能更快）
• 大量DOM操作
• 游戏引擎的主循环

8.2 实用建议

1. 从小处开始：不要强制一切都纯函数
2. 优先考虑不可变性：默认用 const，明确需要时才用 let
3. 将副作用推到边界：核心逻辑保持纯洁
4. 使用类型系统：让编译器帮助你
5. 团队共识：确保团队理解FP的价值

8.3 性能考量

// ❌ 过度使用不可变性可能低效
function updateArray(arr: number[], index: number, value: number): number[] {
  return [...arr.slice(0, index), value, ...arr.slice(index + 1)];
  // O(n) 复制整个数组
}

// ✅ 当性能重要时，使用可变操作
function updateArrayMutable(arr: number[], index: number, value: number): void {
  arr[index] = value;  // O(1)
}

// ✅ 或者使用持久化数据结构（Immer, Immutable.js）
import { produce } from 'immer';

const updated = produce(arr, draft => {
  draft[index] = value;  // 高效的结构共享
});