一道柯理化面试题

群里看到一道 JavaScript 面试题:

1
2
3
4
// 实现 add,使下面的输出成立
add(1).value; // 1
add(1)(2).value; // 5
add(1)(2)(3).value; // 14

乍一看像柯里化(curry),但三个输出 1、5、14 其实是 1²、1²+2²、1²+2²+3²,也就是一边链式调用、一边累加"当前参数的平方和"。

网上常见的"链式累加"写法只能得到 1、3、6,并不满足这道题:

1
2
3
4
5
6
7
8
9
function add(a) {
function sum(b) {
sum.value += b;
return sum;
}
sum.value = a;
return sum;
}
add(1)(2)(3).value; // 6,而不是 14

一、先看一个典型错误:可变的闭包

最直觉的写法是用闭包保存累加值,每调用一次就地修改:

1
2
3
4
5
6
7
8
9
10
11
12
function add(a) {
function sum(b) {
sum.value += b * b; // 累加当前参数的平方
return sum;
}
sum.value = a * a;
return sum;
}

add(1).value; // 1
add(1)(2).value; // 5
add(1)(2)(3).value; // 14

输出没错,但这个函数不可复用。第一次调用已经污染了状态:

1
2
3
const h = add(2);
console.log(h(3).value); // 13 ✔ 期望值
console.log(h(3).value); // 22 ✘ 期望仍是 13,实际又累加了 3²

原因:h 指向的那个函数和 value 是共享的,每次 h(3) 都会在原值上继续加。面试中如果写到这一步,基本会被追问:“怎么保证 add 是纯的?”

二、正解一:不可变累加

思路:不做就地修改,每次调用返回一个携带新值的新函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function chainable(sum, f) {
const next = (x) => chainable(f(sum, x), f);
next.value = sum;
return next;
}

const square = (a, b) => a + b * b;
const add = (x) => chainable(x * x, square);

add(1).value; // 1
add(1)(2).value; // 5
add(1)(2)(3).value; // 14

// 验证可复用
const h = add(2);
console.log(h(3).value); // 13
console.log(h(3).value); // 13

这样每个链都是独立的:调用 .value 只是读取当前节点的累积值;若想继续累加,就得到一个新函数,互不干扰。f 参数还顺便说明了——规则可以替换,不该写死平方。

三、正解二:抽象成通用的链式累加器

把"初始值"和"归并规则"都抽出来,就是一个通用版本:

1
2
3
4
5
6
7
8
9
10
11
12
function chainBy(seed, f) {
const next = (x) => chainBy(f(seed, x), f);
next.value = seed;
return next;
}

// 平方和:f(x) = 前值 + x²
const add = chainBy(0, (a, b) => a + b * b);

add(1).value; // 1
add(1)(2).value; // 5
add(1)(2)(3).value; // 14

同一套框架可以换出别的函数:

1
2
3
4
5
const sum = chainBy(0, (a, b) => a + b);
sum(1)(2)(3).value; // 6,普通累加

const times = chainBy(1, (a, b) => a * b);
times(2)(3)(4).value; // 24,累乘

回到原题其实也能用"带下标权重"的方式凑出平方和,比如 b * (++i)(第一个权重为 1);但直接写 x² 语义清楚得多,也更不容易被面试官挑出边界问题。

四、进阶:去掉 .value,支持隐式转换

如果题目升级成:

1
2
3
add(1)(2) == 5;        // true
add(1)(2) + 1 === 6; // true
`结果是 ${add(1)(2)}`; // "结果是 5"

那就需要在返回的函数上实现原始值转换:valueOf / toString。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
function chainable(sum, f) {
const next = (x) => chainable(f(sum, x), f);
next.value = sum;
next.valueOf = () => sum;
next.toString = () => String(sum);
return next;
}

const add = (x) => chainable(x * x, (a, b) => a + b * b);

add(1)(2) == 5; // true
add(1)(2) + 1; // 6
`${add(1)(2)}`; // "5"
add(1)(2)(3).value; // 14

几点说明:

  • ==、+、-、* 这类运算会先对操作数做 ToPrimitive,自定义的 valueOf 会被调用;
  • 字符串模板、String() 优先走 toString;
  • 更现代的写法是实现 Symbol.toPrimitive,由 hint 决定返回原始值还是字符串:
1
2
next[Symbol.toPrimitive] = (hint) =>
hint === 'string' ? String(sum) : sum;
  • 注意 console.log(fn) 会直接打印函数对象,不会自动调用 valueOf——这就是原帖里"Node 环境下得手动调用 toString()"的原因。

五、面试官可能继续追问

  1. add(1)(2) === 5 能做到吗? 不能。=== 不做类型转换,对象(函数)永远不等于原始类型。要 === 成立,只能返回原始值,但那会失去继续链式调用的能力——二者不可兼得。

  2. value 每次都挂在函数上,性能如何? 如果链很长(比如调用十万次),每次都新建一层闭包和对象属性,内存开销明显。可以改成数组收集参数、只在 .value 时归并;或者干脆用真正的柯里化库(lodash/fp、Ramda)按需取值。

  3. 如果输入不是数字怎么办? b * b 会静默把字符串、null 等转成数字。严谨实现应校验类型,或交给 TypeScript 约束。

  4. 为什么不直接用 sum += b ** 2? 可以,但要注意 b ** 2 与 b * b 对负数、运算符优先级(** 优先级高于 *)的行为——本题正数场景无差异。

六、参考资料

  1. MDN:Closures(闭包) —— 共享状态与不可变链;
  2. MDN:Type conversion(类型转换) —— ToPrimitive 与隐式转换;
  3. MDN:valueOf / toString —— 对象转原始值;
  4. MDN:Symbol.toPrimitive —— 现代原始值转换写法;
  5. Lodash:curry —— 工程化柯里化;
  6. Wikipedia:Currying —— 概念背景。

七、小结

1
2
3
4
5
6
function chainBy(seed, f) {
const next = (x) => chainBy(f(seed, x), f);
next.value = seed;
return next;
}
const add = chainBy(0, (a, b) => a + b * b);

这道题真正想考的是四件事:

  • 链式调用:函数返回函数,形成 add(1)(2)(3) 的调用链;
  • 状态传递:用闭包/参数把累积值带到下一层,而不是挂在共享的可变对象上;
  • 纯函数意识:同一条链被复用时结果必须稳定;
  • JS 类型转换:valueOf / toString / Symbol.toPrimitive 的时机,以及 === 的不可妥协。

写答案时先确认题目要的是平方和还是普通累加,再给出通用 chainBy,最后补一句"如需隐式转换可加 valueOf",基本就是满分思路。


一道柯理化面试题
https://bubao.github.io/posts/992b3e08.html
作者
一念
发布于
2021年4月1日
许可协议