函数式编程是一种编程范式，它将计算视为数学函数的求值，并避免改变状态和可变数据。TypeScript 作为 JavaScript 的超集，完全支持函数式编程范式。以下是 TypeScript 中函数式编程的一些关键概念和技术：
- 不可变性（Immutability）
不可变性是函数式编程的核心原则之一。它意味着一旦创建了一个对象，就不能更改它的状态。
// 使用 readonly 关键字来创建不可变数组
const numbers: readonly number[] = [1, 2, 3, 4, 5];
// 使用 const 断言来创建不可变对象
const person = { name: "Alice", age: 30 } as const;- 纯函数（Pure Functions）
纯函数是没有副作用的函数，对于相同的输入总是产生相同的输出。
// 纯函数
function add(a: number, b: number): number {
return a + b;
}
// 非纯函数（有副作用）
let total = 0;
function addToTotal(value: number): void {
total += value; // 修改了外部状态
}- 高阶函数（Higher-Order Functions）
高阶函数是可以接受函数作为参数或返回函数的函数。
function map<T, U>(array: T[], fn: (item: T) => U): U[] {
return array.map(fn);
}
const numbers = [1, 2, 3, 4, 5];
const doubled = map(numbers, (n) => n * 2);- 函数组合（Function Composition）
函数组合是将多个简单函数组合成更复杂函数的过程。
function compose<T>(...fns: Array<(arg: T) => T>) {
return (x: T) => fns.reduceRight((acc, fn) => fn(acc), x);
}
const add1 = (x: number) => x + 1;
const multiply2 = (x: number) => x * 2;
const add1ThenMultiply2 = compose(multiply2, add1);
console.log(add1ThenMultiply2(3)); // 输出 8- 柯里化（Currying）
柯里化是将一个多参数函数转换为一系列单参数函数的技术。
function curry<T, U, V>(fn: (a: T, b: U) => V): (a: T) => (b: U) => V {
return (a: T) => (b: U) => fn(a, b);
}
const add = (a: number, b: number) => a + b;
const curriedAdd = curry(add);
console.log(curriedAdd(2)(3)); // 输出 5- 递归（Recursion）
递归是函数调用自身的过程，常用于解决可以分解为相似子问题的问题。
function factorial(n: number): number {
return n <= 1 ? 1 : n * factorial(n - 1);
}
console.log(factorial(5)); // 输出 120- Option 类型
Option 类型（有时称为 Maybe 类型）用于处理可能不存在的值，避免空值检查。
type Option<T> = Some<T> | None;
interface Some<T> {
kind: 'Some';
value: T;
}
interface None {
kind: 'None';
}
function divide(a: number, b: number): Option<number> {
if (b === 0) {
return { kind: 'None' };
}
return { kind: 'Some', value: a / b };
}
const result = divide(10, 2);
if (result.kind === 'Some') {
console.log(result.value); // 输出 5
}- 函数式数据结构
使用不可变的数据结构，如不可变列表或树。
class ImmutableList<T> {
constructor(private items: readonly T[] = []) {}
push(item: T): ImmutableList<T> {
return new ImmutableList([...this.items, item]);
}
get(index: number): T | undefined {
return this.items[index];
}
}
const list1 = new ImmutableList([1, 2, 3]);
const list2 = list1.push(4);
console.log(list1.get(3)); // undefined
console.log(list2.get(3)); // 4- 函数式错误处理
使用 Either 类型或 Result 类型来处理错误，而不是抛出异常。
type Either<L, R> = Left<L> | Right<R>;
interface Left<L> {
kind: 'Left';
value: L;
}
interface Right<R> {
kind: 'Right';
value: R;
}
function safeDivide(a: number, b: number): Either<string, number> {
if (b === 0) {
return { kind: 'Left', value: "Cannot divide by zero" };
}
return { kind: 'Right', value: a / b };
}
const result = safeDivide(10, 2);
if (result.kind === 'Right') {
console.log(result.value); // 输出 5
} else {
console.error(result.value);
}这些概念和技术构成了 TypeScript 中函数式编程的基础。通过使用这些原则，你可以编写更加可预测、可测试和可维护的代码。函数式编程鼓励使用声明式编程风格，关注于描述程序的逻辑，而不是详细的控制流程。这种方法通常可以产生更简洁、更易理解的代码，尤其是在处理复杂数据转换和异步操作时。