数据与函数：deepClone、flatten、curryData and functions: deepClone, flatten, curry
三道递归题。递归的出口、防循环的登记、不污染的攒参数。Three recursion problems: where recursion stops, the record that guards against cycles, and collecting arguments without leaking them.
这一页有什么On this page6
- 手写 deepClone：分支覆盖 Date / Map / Set / 数组 / 对象，循环引用不爆栈Write deepClone by hand, with branches for Date / Map / Set / array / object, and no stack overflow on a circular reference
- 说清 JSON.parse(JSON.stringify(x)) 为什么不算深拷贝的答案Explain why JSON.parse(JSON.stringify(x)) does not count as an answer to deep clone
- 手写 flatten，depth 语义与 Array.prototype.flat 一致Write flatten by hand, with depth behaving the same way as Array.prototype.flat
- 手写 curry，部分应用可复用、互不污染Write curry by hand, so a partly applied function can be reused and does not affect the others
deepClone 是「递归 + 分支 + 防循环」三合一的经典题，面试官用它一次看三个能力。flatten 考递归出口的干净程度。curry 考闭包攒参数 —— 写成共享数组就会在「复用部分应用」这一问上当场翻车。deepClone packs three things into one classic problem — recursion, type branches, and guarding against cycles — so the interviewer sees three skills at once. flatten tests how cleanly you stop the recursion. curry tests collecting arguments in a closure: write it with one shared array and you fail on the spot when asked to reuse a partly applied function.
deepClone：先登记，再递归deepClone: record it first, then recurse
Write a deepClone that survives circular references
一句话：按类型分支递归克隆；每造出一个新容器，立刻在 WeakMap 里登记 「原对象 → 它的克隆」，循环引用一进来就直接还登记过的克隆 —— 这就是不爆栈的全部原理。
分支顺序：原始值和 null 原样返回 → 查 seen → Date → Map /Set → 数组 → 普通对象。「先登记再递归子节点」的次序不能反： 反了，a.self = a 这种结构会在登记之前就递归回自己。
会追问（必问）：「为什么不用JSON.parse(JSON.stringify(x))？」—— 丢 undefined 和函数、Date 变字符串、Map / Set 变空对象、循环引用直接抛TypeError。「那 structuredClone 呢？」—— 生产代码优先用它（原生、支持循环引用），但它克隆不了函数和 DOM 节点，而且这道题考的就是你自己会不会写。
In one line: recurse by type, and the moment you create a new container, register “original → its clone” in a WeakMap — when a circular reference comes back around, you hand out the registered clone instead of recursing forever. That is the entire trick.
Branch order: primitives and null pass through → check seen → Date → Map / Set → arrays → plain objects. “Register first, recurse into children second” must not be flipped: flipped, a structure like a.self = a recurses back into itself before the registration exists.
Follow-up (always asked): “Why not JSON.parse(JSON.stringify(x))?” — it drops undefined and functions, turns Date into a string, turns Map / Set into empty objects, and throws a TypeError on circular references. “And structuredClone?” — prefer it in production code (native, handles cycles), but it cannot clone functions or DOM nodes, and this question exists to see whether you can write the thing yourself.
flatten：递归的出口就是 depthflatten: depth is what stops the recursion
Write a flatten with a depth parameter
一句话：遍历数组，遇到「是数组且 depth > 0」 就递归展开（depth 减一），否则原样收进结果 ——depth 本身就是递归的出口。
两个语义细节要和原生 Array.prototype.flat 对齐， 面试官就在这两处等你：默认 depth 是 1（不是 Infinity），depth 0 返回浅拷贝（不是原数组的引用 —— 不改输入是底线）。
会追问：「不用递归写一遍」—— 用栈：[...arr.map(v => [v, depth])] 形式的工作栈， 弹出时是数组且层数没用完就把子项带着层数压回去。 递归版清晰、迭代版不吃调用栈，说得出取舍就够了。
In one line: walk the array; when an item “is an array and depth > 0”, recurse into it with depth minus one, otherwise push it as-is — depth itself is the recursion exit.
Two semantic details must match the native Array.prototype.flat, and this is exactly where the interviewer waits for you: the default depth is 1 (not Infinity), and depth 0 returns a shallow copy (not the original reference — never mutate the input).
Follow-up: “Now without recursion” — use a work stack of [value, remainingDepth] pairs; when you pop an array with depth left, push its children back with depth minus one. Recursion reads better, iteration does not consume the call stack — naming that trade-off is all they want.
curry：攒参数必须造新数组curry: collecting arguments means building a new array each time
Write a curry; why must partial applications not share state
一句话：攒到的参数够 fn.length就执行，不够就返回一个「接着攒」的新函数 —— 攒的动作必须是 (...more) => curried(...args, ...more)这种拼新数组，不能往共享数组上 push。
为什么这么严：const add1 = curried(1) 之后，add1(2, 3) 和 add1(10, 20)必须都从 [1] 出发。push 版第一次调用后共享数组变成[1, 2, 3]，第二次 add1(10, 20)实际拿到五个参数 —— 部分应用被污染了。 测试里专门有一条抓这个。
会追问：「fn.length 有什么坑？」—— 它数不到默认参数和 rest 参数（(a, b = 1) => 的 length 是 1），所以带默认参数的函数 curry 不动；说得出这一句， 这道题就答干净了。
In one line: once the collected arguments reach fn.length, run; otherwise return a new collector — and collecting must build a fresh array, (...more) => curried(...args, ...more), never a push onto something shared.
Why so strict: after const add1 = curried(1), both add1(2, 3) and add1(10, 20) must start from [1]. With push, the shared array becomes [1, 2, 3] after the first call, so the second call really receives five arguments — the partial application is polluted. One test exists specifically to catch this.
Follow-up: “What is the catch with fn.length?” — it does not count default or rest parameters ((a, b = 1) => {} has length 1), so functions with defaults do not curry cleanly. Saying that one sentence closes the question.
动手做Get your hands on it
填空只是过渡。真正掌握的标准，是在没有答案的时候从头写出来 —— 所以做完 L2 之后一定要往 L3、L4 走。Filling blanks is a stepping stone. The real bar is writing it from nothing, so once L2 is comfortable, push on to L3 and L4.
- 原始值和 null 原样返回Primitives and null come back unchanged
- 嵌套对象 / 数组逐层克隆，每一层都是新引用Nested objects and arrays are cloned level by level, and every level is a new reference
- Date 克隆成新 Date；Map / Set 深克隆A Date becomes a new Date; Map and Set are deep-cloned
- 循环引用不爆栈（WeakMap 登记「原对象 → 克隆」）A circular reference does not recurse forever (a WeakMap records original to clone)
- 不许用 JSON.parse(JSON.stringify(x))JSON.parse(JSON.stringify(x)) is not allowed
看答案之前，先确认你已经自己动手写过一遍。看懂别人的答案和自己写出来，是两种能力。Before you open this, make sure you have written it yourself once. Following someone else's answer and producing your own are two different skills.
.flat()。Grow this shallow-copy version into a real flatten: one level by default, depth decides how many levels, Infinity flattens everything, and the input is never changed. Calling the built-in .flat() is not allowed.- 默认 depth 为 1，与 Array.prototype.flat 一致depth is 1 by default, the same as Array.prototype.flat
- depth 控制展开层数，Infinity 全压平depth decides how many levels are opened up; Infinity flattens everything
- depth 0 返回浅拷贝，不是原数组引用depth 0 returns a shallow copy, not a reference to the input array
- 不改输入数组；不许调用原生 .flat()The input array is never changed, and the built-in .flat() is not allowed
看答案之前，先确认你已经自己动手写过一遍。看懂别人的答案和自己写出来，是两种能力。Before you open this, make sure you have written it yourself once. Following someone else's answer and producing your own are two different skills.
fn.length 就执行，可任意分组， 部分应用复用互不污染。Grow this return-fn-directly version into a real curry: run as soon as fn.length arguments have arrived, accept them in any grouping, and let a partial application be reused without one call affecting another.- 攒够 fn.length 个参数就执行Runs as soon as fn.length arguments have arrived
- 参数可以任意分组：c(1)(2)(3) / c(1, 2)(3) / c(1)(2, 3)Arguments may come in any grouping: c(1)(2)(3), c(1, 2)(3), c(1)(2, 3)
- 部分应用可复用：const add1 = c(1) 之后多次调用互不污染A partial application is reusable: after const add1 = c(1), calling add1 many times gives independent results
看答案之前，先确认你已经自己动手写过一遍。看懂别人的答案和自己写出来，是两种能力。Before you open this, make sure you have written it yourself once. Following someone else's answer and producing your own are two different skills.
初学者常见的几种写法错误Mistakes beginners actually make
下面每一段都是「能编译、但结果不对」或者「一跑就炸」的真实写法。先自己看出问题在哪，再看解释。Every snippet below either compiles and gives the wrong answer, or blows up on the first run. Spot the problem yourself before reading the explanation.
undefined 键消失和 Date 变字符串这两条， 坏了都没报错。练习的检查器直接把它列为禁用写法。In an interview this is not a short answer, it shows you have never written a deep clone. Every cost on that list can turn into data that is quietly wrong in production — above all the two where a undefined key disappears and a Date becomes a string, because neither reports an error. The checker in the exercise rejects this form outright.换一道题也能用Works on other problems too
考试不会原题重考。真正能带走的是「看到这种信号 → 伸手去拿这个解法」。The exam will not reuse the same question. What you take away is the reflex: see this signal, reach for that solution.
- deepClone 的灵魂：先登记再递归。分支顺序：原始值 → seen → Date → Map/Set → 数组 → 对象。The heart of deepClone: record first, then recurse. Branch order: primitive value, then seen, then Date, then Map/Set, then array, then object.
- JSON.parse(JSON.stringify(x)) 的五宗罪要背下来 —— 这是必问的追问。Memorise the five things JSON.parse(JSON.stringify(x)) breaks — the follow-up on this always comes.
- flatten 的出口就是 depth；默认 1、depth 0 浅拷贝，语义对齐原生。depth is what stops flatten; the default is 1, depth 0 is a shallow copy, matching the built-in.
- curry 攒参数必须拼新数组 —— push 版会污染部分应用，有测试专门抓。curry has to join arguments into a new array — the push version leaks into other partly applied functions, and a test looks for exactly that.
- fn.length 数不到默认参数和 rest 参数 —— 说得出这句就答干净了。fn.length does not count default parameters or a rest parameter — saying that line finishes the answer cleanly.