JavaScript中的函数式编程：高阶函数与函数组合

描述
高阶函数是函数式编程的核心概念之一，它指的是能够接收函数作为参数或返回函数作为结果的函数。函数组合则是将多个简单函数组合成更复杂函数的技术。理解这两个概念对于编写声明式、可维护的JavaScript代码至关重要。

知识讲解

1. 什么是高阶函数？
高阶函数是对其他函数进行操作的函数，它能够：

• 接收一个或多个函数作为参数
• 返回一个新的函数作为结果

// 接收函数作为参数
function calculate(a, b, operation) {
    return operation(a, b);
}

function add(x, y) { return x + y; }
function multiply(x, y) { return x * y; }

console.log(calculate(5, 3, add));      // 8
console.log(calculate(5, 3, multiply)); // 15

2. 常见的高阶函数示例

数组方法中的高阶函数：

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

// map: 接收函数，对每个元素进行转换
const doubled = numbers.map(x => x * 2);

// filter: 接收函数，根据条件过滤元素
const evens = numbers.filter(x => x % 2 === 0);

// reduce: 接收函数，将元素累积为单个值
const sum = numbers.reduce((acc, x) => acc + x, 0);

返回函数的高阶函数：

// 创建一个乘法器函数
function createMultiplier(factor) {
    return function(x) {
        return x * factor;
    };
}

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

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

3. 函数组合的概念
函数组合是将多个简单函数组合成一个新函数的过程，新函数的输出是前一个函数的输入：

// 简单的函数组合实现
function compose(f, g) {
    return function(x) {
        return f(g(x));
    };
}

// 示例函数
function addOne(x) { return x + 1; }
function double(x) { return x * 2; }
function square(x) { return x * x; }

// 组合函数：先平方，然后加倍，最后加1
const complexOperation = compose(addOne, compose(double, square));

console.log(complexOperation(3)); // (3² × 2) + 1 = 19

4. 更实用的函数组合实现

从左到右的组合（pipe）：

function pipe(...funcs) {
    return function(initialValue) {
        return funcs.reduce((value, func) => {
            return func(value);
        }, initialValue);
    };
}

const processNumber = pipe(
    x => x + 1,      // 加1
    x => x * 2,      // 乘2  
    x => x.toString() // 转字符串
);

console.log(processNumber(5)); // "12"

从右到左的组合（compose）：

function compose(...funcs) {
    return function(initialValue) {
        return funcs.reduceRight((value, func) => {
            return func(value);
        }, initialValue);
    };
}

const processText = compose(
    text => text.toUpperCase(),    // 最后执行：转大写
    text => text.trim(),           // 然后执行：去除空格
    text => ` ${text} `            // 先执行：添加空格
);

console.log(processText("hello")); // " HELLO "

5. 实际应用场景

数据处理管道：

// 数据处理函数
const sanitizeInput = str => str.trim();
const validateEmail = email => email.includes('@') ? email : null;
const normalizeEmail = email => email.toLowerCase();

// 组合成验证管道
const processEmail = pipe(
    sanitizeInput,
    validateEmail,
    normalizeEmail
);

console.log(processEmail("  EXAMPLE@TEST.COM  ")); // "example@test.com"

6. 柯里化与函数组合的结合

// 柯里化函数
function curry(fn) {
    return function curried(...args) {
        if (args.length >= fn.length) {
            return fn.apply(this, args);
        } else {
            return function(...moreArgs) {
                return curried.apply(this, args.concat(moreArgs));
            };
        }
    };
}

// 柯里化版本的函数
const curriedMap = curry((fn, array) => array.map(fn));
const curriedFilter = curry((fn, array) => array.filter(fn));

// 组合柯里化函数
const processData = pipe(
    curriedFilter(x => x > 2),      // 过滤大于2的数
    curriedMap(x => x * 3)          // 每个数乘3
);

const numbers = [1, 2, 3, 4, 5];
console.log(processData(numbers)); // [9, 12, 15]

7. 错误处理与函数组合

// 带有错误处理的组合函数
function safeCompose(...funcs) {
    return function(initialValue) {
        try {
            return funcs.reduce((value, func) => {
                return func(value);
            }, initialValue);
        } catch (error) {
            console.error('组合函数执行出错:', error);
            return null;
        }
    };
}

总结
高阶函数和函数组合是函数式编程的基石，它们让代码更加：

• 声明式：关注"做什么"而不是"怎么做"
• 可复用：小函数可以灵活组合
• 可测试：每个小函数都可以独立测试
• 可维护：代码结构清晰，易于理解

通过掌握这些概念，你可以编写出更加优雅和健壮的JavaScript代码。