24. 说说你对函数柯里化和组合函数的理解？
问题解析
函数柯里化（Currying）和函数组合（Function Composition）是函数式编程中两个密切相关的重要概念。柯里化让函数更灵活，函数组合让多个小函数协作完成复杂任务。理解它们的原理和应用，对于编写可维护、可复用的代码非常重要。
核心概念
柯里化（Currying）
柯里化是把一个多参数函数转化成一个嵌套的一元函数的过程。
函数组合（Function Composition）
函数组合是将多个函数组合成一个函数，使得数据能够像管道一样流经这些函数。
两者的关系
柯里化为函数组合提供了基础。柯里化后的函数每次只接受一个参数，更容易与其他函数组合使用。
详细解答
柯里化的实现
// 普通函数
const add = (a, b, c) => a + b + c;
// 柯里化函数
const curriedAdd = a => b => c => a + b + c;
curriedAdd(1)(2)(3); // 6
// 通用柯里化函数
const curry = fn =>
curried = (...args) =>
args.length >= fn.length
? fn(...args)
: (...nextArgs) => curried(...args, ...nextArgs);
const curriedAdd = curry(add);
curriedAdd(1)(2)(3); // 6
curriedAdd(1, 2)(3); // 6
curriedAdd(1)(2, 3); // 6
函数组合的实现
// 从右到左组合（数学函数组合方式）
const compose = (...fns) => (value) =>
fns.reduceRight((acc, fn) => fn(acc), value);
// 从左到右组合（管道，更符合阅读习惯）
const pipe = (...fns) => (value) =>
fns.reduce((acc, fn) => fn(acc), value);
// 示例函数
const add5 = x => x + 5;
const multiply2 = x => x * 2;
const toString = x => String(x);
// compose从右到左执行
const composed = compose(toString, multiply2, add5);
composed(3); // '16' (3 + 5 = 8, 8 * 2 = 16, String(16) = '16')
// pipe从左到右执行
const piped = pipe(add5, multiply2, toString);
piped(3); // '16' (3 + 5 = 8, 8 * 2 = 16, String(16) = '16')
柯里化与函数组合的结合
// 柯里化的高阶函数
const map = fn => arr => arr.map(fn);
const filter = predicate => arr => arr.filter(predicate);
const reduce = (fn, initial) => arr => arr.reduce(fn, initial);
// 数据处理函数
const isEven = x => x % 2 === 0;
const double = x => x * 2;
const sum = (a, b) => a + b;
// 组合数据处理管道
const processNumbers = pipe(
filter(isEven), // 筛选偶数
map(double), // 翻倍
reduce((a, b) => a + b, 0) // 求和
);
processNumbers([1, 2, 3, 4, 5, 6]); // 24
// 步骤：[2, 4, 6] -> [4, 8, 12] -> 24
深入理解
点-free风格（Point-free Style）
点-free风格是一种编程风格，函数定义不直接提及要操作的数据（参数）。
// 非点-free风格
const getUserNames = users => users.map(user => user.name);
// 点-free风格
const map = fn => arr => arr.map(fn);
const prop = key => obj => obj[key];
const getUserNames = map(prop('name'));
// 没有提及users参数
// 更复杂的例子
const users = [
{ name: 'John', age: 25, active: true },
{ name: 'Jane', age: 30, active: false },
{ name: 'Bob', age: 35, active: true }
];
const getActiveUserNames = pipe(
filter(propEq('active', true)),
map(prop('name')),
sortBy(identity)
);
getActiveUserNames(users); // ['Bob', 'John']
实际应用：数据处理管道
// 构建数据处理管道
const dataProcessingPipeline = {
// 验证
validate: schema => data => {
// 验证逻辑
return isValid(schema, data) ? data : throwError('Validation failed');
},
// 转换
transform: transformer => data => transformer(data),
// 过滤
filter: predicate => data =>
Array.isArray(data) ? data.filter(predicate) : data,
// 日志
log: label => data => {
console.log(`[${label}]:`, data);
return data;
},
// 缓存
cache: keyFn => data => {
const key = keyFn(data);
if (cacheStore.has(key)) {
return cacheStore.get(key);
}
cacheStore.set(key, data);
return data;
}
};
// 使用管道处理API数据
const processApiResponse = pipe(
dataProcessingPipeline.validate(userSchema),
dataProcessingPipeline.log('After validation'),
dataProcessingPipeline.transform(normalizeUserData),
dataProcessingPipeline.filter(user => user.active),
dataProcessingPipeline.cache(user => user.id),
dataProcessingPipeline.log('Final result')
);
函数组合与异步
// 异步函数组合
const asyncPipe = (...fns) => (value) =>
fns.reduce(async (acc, fn) => fn(await acc), value);
const asyncCompose = (...fns) => (value) =>
fns.reduceRight(async (acc, fn) => fn(await acc), value);
// 使用
const fetchUser = async (id) => {
const response = await fetch(`/api/users/${id}`);
return response.json();
};
const fetchUserPosts = async (user) => {
const response = await fetch(`/api/users/${user.id}/posts`);
const posts = await response.json();
return { ...user, posts };
};
const enrichUserData = async (userWithPosts) => {
// 添加额外数据
return {
...userWithPosts,
postCount: userWithPosts.posts.length,
lastActive: new Date()
};
};
const getEnrichedUserData = asyncPipe(
fetchUser,
fetchUserPosts,
enrichUserData
);
// 使用
const userData = await getEnrichedUserData(123);
最佳实践
1. 使用Ramda或Lodash/FP
import R from 'ramda';
// Ramda的所有函数都是自动柯里化的
const add = R.add;
const add5 = add(5); // 柯里化
add5(3); // 8
// 函数组合
const processData = R.pipe(
R.filter(R.propEq('active', true)),
R.map(R.prop('name')),
R.sortBy(R.toLower),
R.join(', ')
);
const users = [
{ name: 'John', active: true },
{ name: 'Jane', active: false },
{ name: 'Bob', active: true }
];
processData(users); // 'Bob, John'
2. 创建可复用的函数组合工具
// 条件组合
const when = (predicate, fn) => (value) =>
predicate(value) ? fn(value) : value;
const unless = (predicate, fn) => (value) =>
!predicate(value) ? fn(value) : value;
const ifElse = (predicate, trueFn, falseFn) => (value) =>
predicate(value) ? trueFn(value) : falseFn(value);
// 使用
const isEmpty = arr => arr.length === 0;
const getDefault = () => ['default'];
const processArray = ifElse(
isEmpty,
getDefault,
arr => arr.map(x => x * 2)
);
processArray([]); // ['default']
processArray([1, 2, 3]); // [2, 4, 6]
// 分支组合
const converge = (after, fns) => (value) =>
after(...fns.map(fn => fn(value)));
const average = converge(
(sum, count) => sum / count,
[
arr => arr.reduce((a, b) => a + b, 0),
arr => arr.length
]
);
average([1, 2, 3, 4, 5]); // 3
3. 在React中使用
import { useCallback, useMemo } from 'react';
import { pipe, map, filter } from 'ramda';
function UserList({ users, filterText, sortKey }) {
// 使用函数组合处理数据
const processedUsers = useMemo(() => {
const processUsers = pipe(
filter(user =>
user.name.toLowerCase().includes(filterText.toLowerCase())
),
map(user => ({
...user,
displayName: `${user.firstName} ${user.lastName}`
})),
users => [...users].sort((a, b) =>
a[sortKey].localeCompare(b[sortKey])
)
);
return processUsers(users);
}, [users, filterText, sortKey]);
return (
<ul>
{processedUsers.map(user => (
<li key={user.id}>{user.displayName}</li>
))}
</ul>
);
}
4. 避免过度组合
// 过度组合：难以阅读和维护
const process = R.pipe(
R.filter(R.propEq('active', true)),
R.map(R.evolve({ age: R.add(1) })),
R.groupBy(R.prop('department')),
R.map(R.sortBy(R.prop('name'))),
R.map(R.take(5)),
R.map(R.pluck('email')),
R.map(R.join(', '))
);
// 更好的做法：分步骤并命名
const getActiveUsers = R.filter(R.propEq('active', true));
const incrementAge = R.map(R.evolve({ age: R.add(1) }));
const groupByDepartment = R.groupBy(R.prop('department'));
const getTop5EmailsPerDept = R.map(
R.pipe(
R.sortBy(R.prop('name')),
R.take(5),
R.pluck('email'),
R.join(', ')
)
);
const processUsers = R.pipe(
getActiveUsers,
incrementAge,
groupByDepartment,
getTop5EmailsPerDept
);
面试要点
- 柯里化定义：将多参数函数转为嵌套单参数函数的过程
- 函数组合定义：将多个函数组合成一个函数，数据流经这些函数
- 两者关系：柯里化为函数组合提供便利，使函数更易组合
- 实现方式：能够手写柯里化和函数组合函数
- 实际应用：数据处理管道、中间件、React高阶组件等
常见问题
Q：什么是柯里化？ A：柯里化是把一个多参数函数转化成一个嵌套的一元函数的过程，允许分批次传递参数。
Q：什么是函数组合？ A：函数组合是将多个函数组合成一个新函数，使得数据能够依次流经这些函数，前一个函数的输出作为后一个函数的输入。
Q：柯里化和函数组合有什么关系？ A：柯里化让函数每次只接受一个参数，更容易与其他函数组合使用。柯里化是函数组合的基础。
Q：compose和pipe有什么区别？ A：compose从右到左执行函数（数学函数组合方式），pipe从左到右执行（更符合代码阅读习惯）。
Q：在实际开发中如何使用这些概念？ A：可以使用Ramda或Lodash/FP等库，在数据处理、状态管理、API调用链等场景中使用柯里化和函数组合来构建可复用的数据处理管道。