Node.js 面试必答基础：类型判断、作用域、引用传递、内存释放与 ES6 新特性（node-interview 指南）

• 文档
• 教程
• 后端

本指南围绕饿了么前端团队（ElemeFE）开源面试提纲 node-interview 中「Common / Js Basic」一节（sections/en-us/common.md）展开，系统梳理后端 Node.js 面试中最常被考察的 JavaScript 基础五问：类型判断、作用域、引用传递、内存释放与 ES6 新特性。读完本文，你将掌握每个考点的标准回答口径、追问方向和可落地的代码实验，并能结合 V8 内存机制、调试快照等后端实战工具给出有深度的回答。

一、后端视角下的 JavaScript 基础：为什么「Common」如此重要

前端 JavaScript 大量工作围绕 DOM 展开，而后端除了 SSR（服务端渲染）与爬虫场景外几乎不接触 DOM，因此在 node-interview 的面试提纲中，DOM 相关知识点基本不会被讨论。与浏览器端很少直接面对内存压力不同，Node.js 后端几乎是直面服务器内存的：一次内存泄漏、一次 GC 停顿、一次 Buffer 失控，都可能直接导致线上进程崩溃。所以后端面试更偏向内存、引用、闭包这类「更基础」的问题。

原文档也坦诚地说明：JavaScript 知识点太多，《JavaScript 权威指南》的厚度足以说明问题，因此这份提纲并不打算完整带读者过一遍 JS 基础，而是列出饿了么面试 Node.js 程序员时通常会问的 JS 基础问题，并给出书名或博文作为深入路径。建议读者「带着本文抛出的问题去学习」，而不是期待本文把所有答案列出来。

二、类型判断（Type Judgement）

2.1 为什么类型判断是面试开场常客

JavaScript 的类型判断是个相当折磨人的话题——不然也不会有 TypeScript 的出现。这类问题一般只是面试过程中简单的开场，不会因为你不知道undefined == null的结果是true就一票否决一个人；但根据饿厂面试官的个人经验，这类问题答不清楚的候选人，有较大概率属于基础较差。如果你对这种问题完全没有概念，可能确实需要找一本 JS 基础书系统过一遍。

在类型判断问题上，原文档给出的基础建议是：阅读 lodash 的源代码。lodash 中诸如isArray、isObject、isPlainObject、isRegExp等方法的实现，几乎是学习健壮类型判断的最佳范本。

2.2 从typeof到Object.prototype.toString

JavaScript 的类型判断有多个层次，从浅到深：

面试中值得记住的关键结论：

• undefined == null的结果是true（抽象相等比较时null与undefined相等），而undefined === null是false。
• typeof null返回'object'，这是历史遗留 bug。
• Object.prototype.toString.call([])返回'[object Array]'，这是实现isArray类判断的核心手段。

2.3 加分项：TypeScript 与 Flow

原文档特别指出：在这个问题上，对熟悉 TypeScript 以及 Flow 的候选人会有一定加分。因为类型判断的痛点正是 TypeScript 与 Flow 这类静态类型方案试图解决的——在编译期就消除大量运行时类型判断需求，同时保留了对联合类型、可空类型的表达能力。

三、作用域（Scope）

3.1 为什么面试要从let与var入手

在面试时，作用域并不是一个很好直接提问的知识点，但实际上它是 JavaScript 中一个非常重要的底层概念。饿厂一般开篇会问「ES6 中let与var的区别」这一类问题，或者列举一段代码，让候选人逐行解读，从而考察其对作用域的掌握程度。

let与var的核心区别：

• var是函数作用域，let/const是块级作用域（{}内有效）；
• var存在变量提升（hoisting），声明会被提升到作用域顶部并初始化为undefined；let/const存在暂时性死区（TDZ），在声明语句执行之前访问会抛出ReferenceError；
• let/const不允许在相同作用域重复声明，var可以；
• 在全局作用域用var声明会挂到global/window上，let不会。

3.2 推荐精读《你不知道的 JavaScript》前五章

原文档推荐细读《你不知道的 JavaScript》（You Don't Know JS）关于作用域的章节，并给出了该书的部分目录，建议精读前五章：

1. 第 1 章 作用域是什么：引擎、编译器与作用域三者的协作模型，理解变量查找的机制；
2. 第 2 章 词法作用域：作用域由代码书写位置（词法）决定，而不是调用位置决定；
3. 第 3 章 函数作用域和块作用域：var的函数作用域 vslet/const的块级作用域，IIFE 的意义；
4. 第 4 章 提升：声明提升的规则与let的暂时性死区；
5. 第 5 章 作用域闭包：闭包的本质是函数记住并访问其词法作用域，即使函数在其词法作用域之外执行。

这几章读完，配合下面的「引用传递」和「内存释放」两节，就能把作用域从概念串成完整的运行时行为链条。

四、引用传递（Reference）

面试原题：JS 中什么类型是引用传递，什么类型是值传递？如何将值类型的变量以引用的方式传递？

4.1 标准回答：对象引用传递，基本类型值传递

简单回答：对象是引用传递，基础类型是值传递；可以通过将基础类型包装（boxing）来以引用的方式传递。所谓 boxing，就是利用对象包装原始值——例如new Number(1)、new String('a')，或把基础类型放进数组/对象里传递，这样传递的是对象的引用，修改对象内部即可「影响外部」。

引用传递和值传递是一个非常基础的问题，但它是理解 JavaScript 内存行为的地基。如果不了解引用，后续的内存分析、深拷贝、==/===陷阱都很难理解。

4.2 高级回答：JavaScript 没有引用传递，只有「按共享传递」（call by sharing）

原文档在注释①中给出一个重要提示：对于技术好的候选人，希望能直接反驳这个问题本身是有问题的——JavaScript 中并不存在真正的「引用传递」，更准确的说法是**「按共享传递」（call by sharing）：函数参数接收的是引用值的副本**，因此你无法通过重新赋值参数来改变调用方绑定的变量，但可以修改引用指向的对象内部。

举例说明：

function reassign(obj) { obj = { name: 'new' }; // 只改变参数自身的绑定，不影响外部 } function mutate(obj) { obj.name = 'mutated'; // 修改的是引用指向的同一个对象，外部可见 } const a = { name: 'old' }; reassign(a); console.log(a.name); // 'old'，reassign 无效 mutate(a); console.log(a.name); // 'mutated'，mutate 生效

虽然这属于进阶理解，但原文档直言：对于有 3 年以上经验的开发者，这应该是很简单的问题。如果候选人简历里写了 C++，面试官几乎必问「指针与引用的区别」——C++ 中引用是变量的别名且不能重新绑定，指针是保存地址的变量可以重新指向，这与 JS 的按共享传递形成鲜明的对比考点。

4.3 写代码考察：JSON 对象拷贝函数

面试写代码时，可以通过「如何编写一个 JSON 对象的拷贝函数」来考察对引用的理解。常见层次：

• 浅拷贝：Object.assign({}, obj)或展开运算符{...obj}——只拷贝第一层，嵌套对象仍是同一引用；
• 深拷贝：JSON.parse(JSON.stringify(obj))——简单但会丢失undefined、函数、Symbol、Date等；
• 手写递归深拷贝：需要处理数组、对象、循环引用（WeakMap 记录已拷贝对象）等边界情况。

追问时，面试官往往会接着问==与===的区别，然后抛出经典陷阱题：

[1] == [1] // false

==与===的区别是：===比较类型和值，不做类型转换；==会先做类型转换（隐式 coercion）再比较。而数组是对象，两个不同的数组对象即使内容相同，引用也不同，因此[1] == [1]的结果是false。基础不好的候选人容易被「==会做类型转换」的结论带偏，得出true的错误结论——这正是考察「引用」与「比较规则」两个知识点的交叉点。

五、内存释放（Memory Release）

面试原题：JavaScript 中不同类型以及不同环境下变量的内存都是何时释放？

5.1 标准回答：引用类型靠 GC，值类型看闭包与新生代

原文档给出的回答口径：

• 引用类型：在没有引用之后，通过V8 的 GC 自动回收；
• 值类型：如果处于闭包环境中，要等闭包本身没有被引用才会被 GC 回收；
• 值类型：如果是非闭包环境（普通局部变量），在 V8新生代（new space）切换的时候回收。

这与 V8 的分代式 GC（generational GC）直接相关：新分配的对象放在新生代（Scavenger/副标记清除），经历若干次存活后被晋升到老生代；新生代空间较小、回收频繁，普通局部变量随新生代切换即被回收；而闭包通过词法环境（Context）持有对外层变量的引用，只要闭包仍被引用，其捕获的变量就不会被回收。

5.2 与前端对比：后端必须开始关注内存

与前端 JS 不同，2 年以上经验的 Node.js 开发者一定要开始注意内存：即使不要求对 V8 GC 有多深入的了解，基础的内存释放概念必须有，并且要开始警惕内存泄漏问题。原文档指出，你需要了解哪些操作一定会导致内存泄漏，或者可以崩掉内存。

5.3 三个经典的「爆内存」实验

原文档给出了三组渐进式实验代码，面试时会被要求逐个分析区别：

实验一：推入基础类型

let arr = []; while(true) arr.push(1);

结果：数组不断增长，1是 SMI（小整数），V8 会先尝试用固定容量、按 2 倍增长的数组存储，最终撑爆 V8 的堆内存（进程因 OOM 崩溃或被系统杀死）。

实验二：推入undefined

let arr = []; while(true) arr.push();

结果：arr.push()不传参等价于推入undefined。由于数组有空洞/稀疏特性（arr[1]这类位置可以被标记为 hole），V8 的数组存储会针对 hole 做特殊处理，undefined这种「无值」在部分存储模式下不占用新分配的槽位内存，因此不一定像实验一那样迅速爆掉内存——这就是两者之间的区别所在。

实验三：推入 Buffer

let arr = []; while(true) arr.push(new Buffer(1000));

结果：每个Buffer在 V8 堆之外分配一块1000 字节的 C++ 内存，同时堆内只保存一个几十字节的对象头。因此内存消耗来自堆外（off-heap）原生内存，process.memoryUsage()里的external字段会飞速增长。这类堆外内存不归 V8 的堆 GC 管，一旦泄漏，用堆快照（heap snapshot）很难直接看到，需要使用--trace-gc、--expose-gc或 Native 内存分析工具来定位——这正是后端面试官想听到的深度回答。

说明：new Buffer(size)是旧版 Node.js 的写法，现代 Node.js 中Buffer.alloc(size)/Buffer.from(...)是推荐的等价替代，但内存模型一致。

思考完这三组实验后，原文档进一步引导：可以尝试找找别的「爆掉 V8 内存」的方式，例如：

• 字符串拼接（+=）产生大量中间字符串；
• Map/Set中不断新增键而不删除；
• 事件监听器反复on而从不off（EventEmitter 的 listeners 数组泄漏）；
• 全局变量/全局缓存不断累积；
• setInterval回调中捕获大对象，定时器从不清除。

5.4 闭包泄漏的经典示例

function out() { const bigData = new Buffer(100); inner = function () { void bigData; } }

闭包会引用到父级函数中的变量，如果闭包未释放，就会导致内存泄漏。上面这个例子的关键点是：inner在没有声明的情况下直接挂到了全局（root）上（非严格模式下隐式全局），导致inner永远可达，其词法环境中捕获的bigData也就永远不会被 GC 回收——即使inner从未被真正调用。

正确写法应当是：要么let inner声明在局部作用域、用完置null，要么避免隐式全局。这与本指南第五节「闭包与私有化」话题紧密关联：闭包中的数据什么时候释放？答案是：当闭包函数本身不再被任何可达引用持有，并且其词法环境不再被需要时。

5.5 高级要求：V8 GC 机制与内存快照

原文档对高水平候选人的要求是：能清楚了解 V8 内存 GC 的机制，懂得内存快照。仓库中 sections/en-us/error.md 的「V8」与「Memory snapshots」小节正好提供了配套工具：

• V8 模块接口：v8.getHeapStatistics()获取堆信息、v8.getHeapSpaceStatistics()获取堆空间信息（新生代/老生代各空间占用）、v8.setFlagsFromString(string)动态设置 V8 选项（如--trace_gc打印 GC 事件）；
• 查看 V8 选项：运行node --v8-options可查询当前 Node.js 环境支持的 V8 命令行选项；
• 内存快照：内存快照常用于定位内存泄漏，仓库推荐用heapdump保存快照，用devtool查看快照；注意用 heapdump 保存的快照只包含 Node.js 中的对象；
• CPU 剖析：node --prof app.js开启内置剖析，运行结束后生成isolate-*.log，再用node --prof-process isolate-*.log生成报告。

例如在代码中临时开启 GC 跟踪：

const v8 = require('v8'); v8.setFlagsFromString('--trace_gc'); setTimeout(function() { v8.setFlagsFromString('--notrace_gc'); }, 60e3);

在系统层面，仓库 sections/en-us/os.md 还补充了内存排查的系统命令：系统级看free -m（Mem/Swap 行）、vmstat 1（si/so 交换量）、sar -r（%memused）；进程级用top/htop看RES（常驻内存）与VIRT（虚拟内存）；OOM 杀手事件用dmesg | grep killed排查。这些命令配合堆快照，是完整的「内存泄漏定位工具箱」。

六、ES6 新特性（ES6+ Features）

6.1 入门题：let与var、箭头函数与function

比较简单的面试题会问let与var的区别（已在第三节详述），以及箭头函数与function的区别：

6.2 进阶题：结合引用的const语义

深入下去，ES6 有太多细节可以深挖。原文档特别强调可以结合「引用」的知识点来询问const方面的知识：

面试原题：const定义的 Array 中间元素能否被修改？如果可以，那const修饰对象有什么意义？

答案：其中的值可以被修改。const保护的是绑定（binding）——即变量名与对象引用之间的关系不可被重新赋值（arr = [...]会抛TypeError），但对象内部的可变性不受影响，所以arr[0] = 2、arr.push(3)都是合法的。

const的意义在于保护引用不被修改：例如Map这类接口对引用变化很敏感——用同一个Map实例作为键容器时，如果引用被替换，缓存命中逻辑、比较逻辑都会失效；使用const保证引用始终如一是有意义的。同时const也适合用在 immutable（不可变）场景：配合函数式编程风格，把引用声明为const可以从语言层面杜绝「变量名被重新指向」这类意外。

6.3 结合{}谈Set、Map、Symbol与私有化

原文档指出，可以结合{}的使用与缺点来谈Set、Map。经典讨论点：

• {}的缺点：键只能是字符串（或 Symbol），数字键会被隐式转成字符串；原型链污染（{}继承Object.prototype，key为constructor、__proto__时行为怪异）；没有迭代顺序保证、没有内置的 size/遍历 API。因此在做缓存、频次统计、去重等场景时，Map（键可以是任意类型、has/delete语义清晰）和Set（天然去重）是更优选择。
• Set去重：[...new Set(arr)]一行实现数组去重，面试中使用Set可以加分。

而私有化的问题与symbol：传统上用闭包实现数据私有（外部无法直接访问闭包内的变量）；ES6 之后可以用Symbol作为「半私有」键（外部不知道 Symbol 就无法访问，但通过Object.getOwnPropertySymbols仍可枚举），class中的#私有字段（现代规范）则提供真正的私有语义。

6.4 闭包的应用场景：不背定义，考应用

原文档特别强调一个面试理念：「闭包是什么」这种问烂了的问题已经没必要问了，取而代之的是询问闭包的应用场景更加合理。典型追问链：

1. 如果你通常用闭包实现数据的私有，那么 ES6 的新特性（例如class、symbol）能否实现私有？
2. 如果能实现，那为什么还要用闭包？（回答方向：闭包除了私有化还能维持状态、惰性计算、函数工厂；且Symbol私有化并非真正不可枚举）
3. 闭包中的数据/私有化的数据的内存什么时候释放？（回答方向：见第五节——闭包函数本身不再可达时，其词法环境连同捕获变量一起被 GC 回收；只要闭包一直挂在 root 上，捕获的数据就永远不释放）

这类问题把「定义」升级为「原理 + 权衡 + 内存」，正是后端面试考察深度的方式。

6.5...展开运算符与数组去重

...的使用上，原文档给出一道实操题：如何实现一个数组的去重？最简洁的方案：

const arr = [1, 2, 2, 3, 3, 4]; const unique = [...new Set(arr)]; console.log(unique); // [1, 2, 3, 4]

Set保证元素唯一，展开运算符...把Set重新展开为数组。追问可以涉及：Set去重的比较语义（SameValueZero，NaN与NaN相等、-0与+0相等）、去重后元素顺序保持插入顺序等。

七、复习清单：把这些答案串成「基础闭环」

综合原文档，饿了么后端面试的 JS 基础部分实际考察的是一条完整的知识链：

1. 类型判断：typeof/toString/instanceof的能力边界、undefined == null、TS/Flow 加分项；
2. 作用域：var/let/const、词法作用域、提升与暂时性死区、闭包的本质；
3. 引用：值类型/引用类型、boxing、按共享传递（call by sharing）、[1] == [1]陷阱、深拷贝实现；
4. 内存释放：V8 分代 GC、新生代切换、闭包与全局引用导致的泄漏、Buffer 堆外内存、v8.getHeapStatistics与内存快照、系统级free -m/vmstat/top排查；
5. ES6 新特性：let/var、箭头函数、const保护引用、Set/Map替代{}、Symbol与私有化、...去重、闭包的应用场景与释放时机。

这五块内容环环相扣：作用域决定了变量的可见性与生命周期，引用决定了赋值与传参的语义，两者共同决定了内存何时释放，而 ES6 新特性又为前四者提供了新的写法与边界。仓库中的 sections/en-us/common.md 是这份提纲的原文，sections/en-us/error.md 的 V8 模块与内存快照小节、sections/en-us/os.md 的系统监控小节则提供了配套的排查工具。建议带着本文的每一个问题去写代码验证、去阅读 V8 文档，把这些基础真正变成自己的底层能力。

• 文档
• 教程
• 后端