TypeScript 中的函数式编程：基础与实践

TypeScript中的函数式编程：从理论到实践

函数式编程是一种将计算视为数学函数求值，并避免改变状态和可变数据的编程范式。TypeScript作为JavaScript的超集，凭借其严格的类型系统和对高阶函数的支持，非常适合应用函数式编程原则。在本文中，我们将解析TypeScript中函数式编程的核心概念，并展示如何在实际中应用它们。

1. 纯函数与不可变性

纯函数是指满足以下条件的函数：

• 对于相同的参数始终返回相同的结果（确定性）。
• 没有副作用（不修改外部变量、不输出数据、不发起请求）。

纯函数示例：

// Pure function: sums two numbersconst add = (a: number, b: number): number => a + b;

// Always returns 5console.log(add(2, 3)); // 5console.log(add(2, 3)); // 5

不可变性是指数据在创建后不被更改的原则。不修改现有对象，而是创建一个新对象。

// Immutable array updateconst numbers: number[] = [1, 2, 3];

// Bad (mutation):numbers.push(4);

// Good (immutable):const newNumbers = [...numbers, 4]; // [1,2,3,4]

// Immutable object updateinterface User {  name: string;  age: number;}

const user: User = { name: 'Alice', age: 30 };const updatedUser: User = { ...user, age: 31 }; // new object

2. 函数组合与柯里化

函数组合是将两个或多个函数组合成一个新函数。第一个函数的结果作为参数传递给第二个函数。

// Composition of two functionsconst compose = <T, U, V>(f: (x: U) => V, g: (x: T) => U) =>  (x: T): V => f(g(x));

const double = (x: number): number => x * 2;const increment = (x: number): number => x + 1;

const doubleThenIncrement = compose(increment, double);console.log(doubleThenIncrement(3)); // (3*2)+1 = 7

柯里化是将一个接收多个参数的函数转换为一系列接收单个参数的函数。

// Regular functionconst multiply = (a: number, b: number): number => a * b;

// Curried versionconst curriedMultiply = (a: number) => (b: number): number => a * b;

const multiplyBy2 = curriedMultiply(2);console.log(multiplyBy2(5)); // 10console.log(multiplyBy2(7)); // 14

柯里化简化了偏函数应用和函数复用。

3. 函子与单子：Maybe 和 Either

函子是一个实现了map方法的容器，允许将函数应用于容器内的值。在TypeScript中，数组就是一个函子示例：

const numbers = [1, 2, 3];const doubled = numbers.map(x => x * 2); // [2, 4, 6]

单子是一个额外实现了flatMap（或bind）方法和of（或return）方法的函子。单子有助于在不使用异常的情况下处理副作用、空值和错误。

让我们实现一个简单的Maybe单子，用于安全地处理null/undefined：

// Maybe monadclass Maybe<T> {  private constructor(private value: T | null) {}

  static of<T>(value: T): Maybe<T> {    return new Maybe(value);  }

  static none<T>(): Maybe<T> {    return new Maybe<T>(null);  }

  map<U>(fn: (value: T) => U): Maybe<U> {    if (this.value === null || this.value === undefined) {      return Maybe.none();    }    return M