罗罗编程学习记录
本页内容 展开查看

07.1 阶段 0:环境与 JavaScript 基础

所属:全栈开发面试题库 / 学习路径 / 07 Node.js 全栈

本页目录

一、阶段定位

这是整条路径的起点,解决两个问题:第一,把 Node.js 运行时在本机装好、能切换版本、能跑脚本;第二,把 JavaScript 这门语言在"异步"这个维度上补齐。后面所有阶段——运行时原理、模块体系、TypeScript、Web 框架、数据层——都是跑在 V8 之上的 JavaScript 代码,语言层不过关,后面每一步都会卡在"代码为什么这样执行"上。

与前后阶段的衔接:往上没有前置阶段,本阶段就是从零开始;往下接 阶段 1 运行时原理与核心 API。阶段 1 要讨论事件循环的六个阶段、process.nextTick 与 setImmediate 的执行顺序,前提是你已经能说清"同步代码、Promise 回调、定时器回调三者谁先谁后"。如果这一层模糊,阶段 1 的示例对你只是死记结论;反过来,把本阶段的执行顺序吃透,阶段 1 只是把同一个模型展开到 Node 内部。

本阶段原有的三个卡点,展开成可判断的现象依据:

  1. 分不清同步代码、Promise 回调与定时器的执行先后。判断标准:给你一段代码,里面有 console.log(1)、Promise.resolve().then(() => console.log(2))、setTimeout(() => console.log(3), 0),你能不能不靠运行就说出输出顺序,并解释为什么是这个顺序。如果必须跑一遍才知道、或跑出来也讲不清,就是卡住了。
  2. async/await 没有正确捕获异常。判断标准:写出的 async 函数里,被 await 的调用 reject 之后,进程直接崩掉并打印 UnhandledPromiseRejectionWarning 或 throw new Error 栈;或者用了 try/catch 却把 await 写在 try 外面。
  3. 把 JS 原型链理解成传统类继承。判断标准:被问到"对象的 __proto__ 和函数的 prototype 是什么关系""class 是不是语法糖"时,只能说"类继承",说不出查找路径,也说不清 Object.create 与 new 的差别。

二、阶段目标与投入

学完本页,应当能用可观察的行为证明以下能力:

能力目标(可验证的行为) 验证方式
能用版本管理工具安装并切换 Node.js LTS,在任意目录运行脚本 node -v 显示 LTS 版本;node hello.js 正常输出
能从 process.argv 读取参数、从 process.env 读取环境变量并写进逻辑 不传参数时报错提示用法,传错环境变量时行为不同
能解释同步代码、Promise 回调、setTimeout 回调的执行顺序 手写一段混合代码,预判输出后运行验证
能用 Promise.all 并发三个异步任务并统一处理失败 任一任务 reject 时整体进入 catch,且能说清 allSettled 的差别
能说清原型链查找路径,用 Object.create 实现一个简单的对象继承 被问到 obj.__proto__.__proto__ 时能指出终点是 Object.prototype
能用 Git 提交代码并看到提交记录 git log --oneline 有至少 3 条与练习对应的提交

建议学时:

  • 全职(每天 4–6 小时):2 周,约 50–60 小时。环境与工具 8 小时、语言基础与闭包 15 小时、原型与 this 10 小时、异步与 Promise 20 小时、Git 与工程习惯 5 小时。
  • 在职(每天 2 小时、周末补 4 小时):5 周,约 60 小时。按"一个模块两天"的节奏,异步部分要留够,这是本阶段最容易欠账的地方。

学时分配建议:环境与 CLI 10%、作用域与闭包 20%、原型与 this 15%、数组对象方法 10%、回调与 Promise 30%、错误捕获与执行顺序 10%、Git 5%。Promise 与执行顺序是面试与后续阶段的硬门槛,时间不能省。

三、先修自检

进入本阶段前,逐条自检;任何一条做不到,先按对应方式补齐。

先修项 合格标准 不合格时怎么做
命令行基本操作 能在终端里 cd、看目录、用编辑器保存文件、看懂相对路径与绝对路径 先补命令行基础:文件、目录、当前目录概念
HTTP 基本概念 知道请求方法、状态码、请求头与响应体 先补 01.2 计算机网络 的 HTTP 部分
Git 安装 本机已装 Git,git --version 有输出 先安装 Git,配好 user.name 与 user.email
文本编辑器 有一个能写 JavaScript 的编辑器,知道怎么保存为 .js 文件 装 VS Code 或同等编辑器
数学与类型概念 知道什么是变量、函数、返回值、字符串与数字 先补编程基础概念,不要直接跳到异步

另有一条经验判断:如果你写过 Java 或 C#,本阶段最容易犯的错是"把 JS 当强类型语言读"——纠结类型声明、期待块级作用域按 C 语义工作、把 class 当编译期结构。写过 Python 的人容易忽视异步,写成"一行接一行"的直觉代码。这两类偏差都要在练习里主动纠正。

四、知识地图

"掌握程度"分三档:了解(知道有这个东西、能查到)、会用(能写对、能调通)、能讲清原理(能解释执行模型、能回答追问)。

模块 知识点 掌握程度 对应题库章节
环境与运行 Node.js LTS、nvm/fnm、REPL、node script.js、node -e 会用 04.2 Node.js
进程与参数 process.argv、process.env、process.exitCode、退出码 会用 04.2 Node.js
作用域与闭包 var/let/const、词法作用域、闭包、IIFE、变量提升 能讲清原理 03.2 JavaScript
原型与 this 原型链、prototype 与 __proto__、new、this 四种绑定规则 能讲清原理 03.2 JavaScript
数组与对象 map/filter/reduce、展开运算、解构、Object.keys/entries 会用 03.2 JavaScript
回调与 Promise 回调地狱、Promise 三态、then/catch、Promise.all/race/allSettled 能讲清原理 03.2 JavaScript
async/await async 函数返回 Promise、await 暂停语义、try/catch 捕获 能讲清原理 03.2 JavaScript
执行顺序 同步先于微任务、微任务先于宏任务、setTimeout(fn,0) 能讲清原理 03.2 JavaScript

进度管理建议:把这张表复制到笔记里,每学完一个模块把"掌握程度"往下调一档;三档都到位再进阶段 1。《知识点全清单》是本篇更细的全量清单,本表只列本阶段重点。

五、分模块精讲

5.1 Node.js 安装与版本管理

为什么需要它:Node.js 发布节奏快,每年 4 月升主版本,LTS 版本偶数年 10 月进入维护期。项目可能要求 Node 18、Node 20 或 Node 22,直接装一个"最新版"会导致别人跑不起来。版本管理工具让你在多项目之间一键切换,而不是反复卸载安装。

核心机制:

  • Node.js 版本号遵循语义化版本:主版本.次版本.修订号。LTS(Long Term Support)版本获得约 18 个月主动维护,奇数版本(如 Node 19、21)只做当前开发版,生产环境一律用偶数 LTS。
  • nvm(类 Unix)与 nvm-windows、fnm 都是版本管理工具:把不同版本装在各自目录,通过在 shell 里改 PATH 或符号链接切换当前 node 指向。
  • node -v 显示当前版本;which node(类 Unix)或 where.exe node(Windows)显示当前可执行文件路径,切换版本后两者要同步变化。
  • 全局安装的包(npm i -g)按版本隔离,切换 Node 版本后全局工具不可用是正常现象,需要在新版本下重装。

最小可运行示例:

# 用 fnm 安装并切换到 LTS(类 Unix 与 Windows PowerShell 均可)
fnm install --lts          # 安装最新 LTS
fnm use lts-latest         # 切换到最新 LTS
fnm list                   # 查看本机已装版本
node -v                    # 输出 v22.x.x 之类的 LTS 版本号
npm -v                     # npm 随 Node 一起分发

# nvm(类 Unix)等价写法
nvm install --lts
nvm use --lts
nvm ls
# 验证版本切换生效
node -e "console.log('node:', process.version)"
# 输出 node: v22.x.x

常见坑:

现象 原因 修法
node: command not found(Windows: 不是内部或外部命令) 版本管理工具未初始化当前 shell,或安装后未重开终端 重开终端;fnm 需在 shell 配置里加 fnm env --use-on-cd | source
装完新版本,node -v 还是旧的 系统里另有一个旧版 Node(如官网 msi 装的),PATH 优先级更高 卸载系统级 Node,或调整 PATH 顺序让版本管理工具优先
切换版本后全局命令找不到 全局包按版本隔离 在当前版本下重新 npm i -g <pkg>
项目里 npm ci 报 engine 不兼容 package.json 的 engines 字段要求特定版本 用版本管理工具切到要求的版本再装依赖

面试考法:常见问法是"为什么生产要用 LTS 版本""nvm 和直接装 Node 有什么区别"。答到"LTS 是偶数版本、有 18 个月维护窗口;版本管理工具把多版本隔离在各自目录,靠切换 PATH 指向实现切换,避免全局唯一版本被某个项目绑死"。追问常落在"全局包为什么按版本隔离"。

5.2 REPL、CLI 与脚本运行方式

为什么需要它:写后端不是只在浏览器控制台里玩。你需要知道怎么把一段逻辑写成文件、怎么用命令行参数控制它、怎么在终端里快速试验 API。这是后面所有阶段的"手"。

核心机制:

  • node 不带参数进入 REPL(Read-Eval-Print Loop):输入一行、执行一行、打印结果,适合试 Array.prototype、Promise 行为。
  • node script.js 执行文件;node -e "console.log(1)" 直接执行一段字符串,适合写一行命令。
  • 脚本的运行目录是执行 node 时的当前目录,不是脚本所在目录;所以读相对路径文件时要小心 process.cwd() 与 __dirname(CJS)的差别。
  • 脚本执行完后,事件循环清空就退出;如果还有未完成的定时器或句柄,进程会继续运行直到它们结束。

最小可运行示例:

# REPL 里试数组方法
node
> [1,2,3].map(x => x*2)
[ 2, 4, 6 ]
> .exit
// hello.js:一个最小可运行脚本
// 运行:node hello.js
console.log("脚本开始,当前工作目录:", process.cwd());

// process.argv 是命令行参数数组:
// argv[0] 是 node 可执行文件路径,argv[1] 是脚本路径,argv[2] 起是用户参数
const name = process.argv[2] || "匿名";
console.log("你好," + name);

// process.env 读取环境变量
const env = process.env.NODE_ENV || "development";
console.log("当前环境:", env);

process.exitCode = 0; // 非 0 表示出错,shell 可用 $? 读到
# 传参与环境变量运行
node hello.js 张三
# 你好,张三
NODE_ENV=production node hello.js 张三
# 当前环境:production

常见坑:

现象 原因 修法
读文件用相对路径报 ENOENT: no such file or directory 代码里写 readFile("data.txt"),但当前工作目录不是脚本所在目录 用 path.join(__dirname, "data.txt")(CJS),或 path.join(import.meta.dirname, ...)(ESM)
脚本跑完不退出,挂着 有未关闭的定时器或 socket 用 process._getActiveHandles() 排查,显式清除
node script.js 提示找不到文件 当前目录不对,或文件名拼错 cd 到脚本目录,或用完整相对/绝对路径
Windows 下 NODE_ENV=production node xxx 不生效 cmd/PowerShell 不支持这种内联环境变量写法 PowerShell 用 $env:NODE_ENV="production"; node xxx.js,或用 cross-env

面试考法:常见问法是"process.argv 和 process.env 分别什么时候用""为什么相对路径读文件会出错"。答到"argv 是命令行位置参数,env 是环境变量(部署侧注入),相对路径基于 process.cwd() 而非脚本位置"。追问会到"脚本什么时候不退出"。

5.3 package.json 与脚本组织

为什么需要它:单个脚本还能跑,一旦有依赖、有启动命令、有协作,就需要 package.json 把项目信息、依赖、脚本登记下来。这是 Node 生态里"项目"的身份证。

核心机制:

  • npm init -y 生成默认 package.json;name、version、description 是基本字段。
  • scripts 字段登记快捷命令:npm start 实际执行 node index.js,npm test 执行测试脚本。npm run <name> 可以跑任意命名脚本。
  • dependencies 是生产依赖,devDependencies 是只在开发时用的(测试、构建工具)。
  • type 字段决定模块体系:缺省或 "commonjs" 用 CJS,"module" 用 ESM。这个字段在阶段 2 会展开,这里先认识它。
  • 安装依赖:npm install <pkg> 写入 dependencies;npm install -D <pkg> 写入 devDependencies。

最小可运行示例:

{
  "name": "cli-tool",
  "version": "0.1.0",
  "description": "一个命令行小工具",
  "type": "commonjs",
  "scripts": {
    "start": "node index.js",
    "dev": "node index.js 张三",
    "test": "node --test"
  },
  "dependencies": {},
  "devDependencies": {}
}
npm install          # 按 package.json 安装全部依赖
npm install lodash   # 新增一个生产依赖,自动写入 dependencies
npm run dev          # 执行 scripts.dev
npm test             # 执行 scripts.test

常见坑:

现象 原因 修法
npm run xxx 报 Missing script: "xxx" scripts 里没有这个命令 检查 package.json 的 scripts 字段
别人 clone 后 node index.js 报 Cannot find module 没装依赖 先 npm install
改了 package.json 版本号,npm 提示版本冲突 发布到 npm 时版本必须唯一 改更高的语义化版本号
装了依赖但代码里 require 报找不到 装成了 devDependencies 却在生产用,或包名拼错 看 node_modules 下目录名,核对 import 路径

面试考法:常见问法是"dependencies 和 devDependencies 怎么分""npm install 时 package-lock.json 起什么作用"。这里先答第一层,package-lock.json 的语义在阶段 2 展开。

5.4 变量、作用域与闭包

为什么需要它:闭包是 JS 里最容易"看起来懂、写起来错"的概念。回调、Promise 链、模块私有变量都建立在它之上。不理解闭包,后面写中间件、写缓存时会反复出现"变量怎么串了""为什么函数记住了旧值"。

核心机制:

  • var 是函数作用域,有变量提升;let/const 是块级作用域,没有提升到可访问状态(暂时性死区)。const 声明的绑定不可重新赋值,但引用的对象内容可变。
  • 词法作用域:函数的作用域在定义时就确定,不是在调用时。内部函数可以访问定义处的外层变量。
  • 闭包:函数 + 它定义时所在的词法环境。即使外层函数已经返回,内层函数仍然持有对那些变量的引用。
  • 闭包让变量"私有":外层函数的变量不会被外部直接访问,只有通过返回的函数才能操作,这是模块私有性的基础。

最小可运行示例:

// 闭包实现一个计数器:外部无法直接访问 count
function createCounter() {
  let count = 0; // 这个变量被返回的函数闭包持有
  return {
    inc() { count++; },
    get() { return count; }
  };
}

const c = createCounter();
c.inc(); c.inc();
console.log(c.get()); // 2
// console.log(c.count); // undefined:外部访问不到 count

// 经典坑:循环里用 var,三个定时器打印同一个值
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log("var i =", i), 0); // 全部打印 3
}
for (let j = 0; j < 3; j++) {
  setTimeout(() => console.log("let j =", j), 0); // 打印 0 1 2
}

常见坑:

现象 原因 修法
循环里定时器回调拿到的全是最后一个值 var 是函数作用域,所有回调共享同一个 i 改用 let,或用 IIFE (function(k){...})(i) 复制
const obj = {}; obj.x = 1 报错 误以为 const 冻结对象 const 只禁重新赋值;要冻结用 Object.freeze
闭包变量"意外"被改 闭包持有的是引用,不是快照 需要快照时在定义时复制:const v = x
变量声明前使用报 ReferenceError let/const 的暂时性死区 把声明移到使用之前

面试考法:经典问法是"什么是闭包,举一个实际用途""循环里为什么用 var 会打印同一个值"。答到"闭包是函数加词法环境,用途是数据私有、函数工厂;var 循环问题是函数作用域导致共享同一个绑定"。追问会到"闭包会不会造成内存泄漏"——闭包本身不泄漏,是长生命周期函数持有了不该持有的大对象。

5.5 原型、原型链与 this

为什么需要它:JS 的对象系统是基于原型的,不是基于类的。class 只是语法糖。原型链决定了属性查找路径,this 决定了函数调用时的上下文。这两个概念说不清,后面读任何框架源码都会卡在"这个方法哪来的""this 为什么是 undefined"。

核心机制:

  • 每个对象有一个内部槽 [[Prototype]],可通过 obj.__proto__ 访问(浏览器/Node 都可用)。函数有一个 prototype 属性,指向它作为构造函数时 new 出来的实例的 [[Prototype]]。
  • 属性查找:先在对象自身找,找不到沿 __proto__ 往上,直到 null。Object.prototype.__proto__ 是 null,这就是链的终点。
  • new 做了四件事:创建空对象、把它的 [[Prototype]] 指向构造函数的 prototype、把构造函数的 this 绑到这个对象、返回这个对象(除非构造函数自己返回对象)。
  • this 的绑定规则:obj.fn() 中 this 是 obj;fn() 直接调用中 this 是 undefined(严格模式)或全局对象;call/apply/bind 显式指定;箭头函数没有自己的 this,继承定义处的 this。

最小可运行示例:

// 用原型链实现"继承",不写 class
function Animal(name) { this.name = name; }
Animal.prototype.say = function() { return this.name; };

function Dog(name) { Animal.call(this, name); } // 继承属性
Dog.prototype = Object.create(Animal.prototype); // 继承方法
Dog.prototype.constructor = Dog;

const d = new Dog("旺财");
console.log(d.say());          // 旺财
console.log(d.__proto__ === Dog.prototype);          // true
console.log(d.__proto__.__proto__ === Animal.prototype); // true
console.log(d.__proto__.__proto__.__proto__ === Object.prototype); // true
console.log(Object.prototype.__proto__);         // null,链终点

// this 与箭头函数
const obj = {
  name: "obj",
  regular() { console.log(this.name); },
  arrow: () => console.log(this.name)
};
obj.regular(); // obj:this 是 obj
obj.arrow();   // undefined:箭头函数 this 来自外层作用域(模块顶层)

常见坑:

现象 原因 修法
obj.fn() 抽出来单独调用 fn() 后 this 是 undefined 严格模式下直接调用 this 为 undefined 用 obj.fn.bind(obj),或箭头函数包裹
找不到方法却能调用 方法在原型链上层 用 obj.hasOwnProperty("x") 判断是否自有
class 里方法 this 丢失 把类方法当回调传给事件,调用者不是实例 构造函数里 this.fn = this.fn.bind(this),或用箭头函数属性
Dog.prototype = Animal.prototype 改了 Dog 也改了 Animal 两边指向同一个对象 用 Object.create(Animal.prototype) 做中间层

面试考法:高频题是"原型链是什么,画出来""class 是语法糖吗""箭头函数和普通函数 this 有什么差别"。要能画出 实例 → 构造函数.prototype → Object.prototype → null 的路径,并说清箭头函数没有自己的 this。

5.6 回调、Promise 与 async/await

为什么需要它:Node 是事件驱动的,几乎所有 IO(网络、文件、子进程)都是异步的。你不能写"等它返回再往下走"的同步代码,必须用回调、Promise 或 async/await 组织流程。这是 Node 与传统后端最大的思维差异。

核心机制:

  • 回调是最早的异步范式:fs.readFile(path, (err, data) => { ... })。缺点是嵌套多层后形成回调地狱,错误处理分散。
  • Promise 是一个状态容器:pending(进行中)、fulfilled(成功)、rejected(失败)。状态一旦改变就不可逆。.then 注册成功回调,.catch 注册失败回调,链上任何一个 reject 都会跳到最近的 catch。
  • Promise.all([...]) 全部成功才成功,任一失败立即失败;Promise.allSettled([...]) 等全部结束(无论成败),返回每个结果;Promise.race([...]) 取第一个结束的。
  • async 函数返回一个 Promise;await 暂停函数执行,直到后面的 Promise settle,把结果作为表达式的值。await 只能在 async 函数(或模块顶层,Node 14.8+)里用。
  • 错误捕获:await 抛错等价于 reject,必须用 try/catch 包住,否则变成 unhandledRejection。

最小可运行示例:

// 一个模拟异步任务:延迟 ms 后返回结果
function delay(ms, value, shouldThrow = false) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (shouldThrow) reject(new Error(value));
      else resolve(value);
    }, ms);
  });
}

// async/await + try/catch:顺序执行两个任务
async function main() {
  try {
    const a = await delay(100, "第一步");
    console.log(a); // 第一步

    // 并发:Promise.all 同时发起三个任务
    const results = await Promise.all([
      delay(50, "任务1"),
      delay(30, "任务2"),
      delay(80, "任务3")
    ]);
    console.log(results); // [ '任务1', '任务2', '任务3' ],顺序与数组一致

    // 任一失败的任务会让 all 整体 reject
    await Promise.all([
      delay(10, "ok"),
      delay(20, "失败了", true)
    ]);
  } catch (err) {
    console.error("捕获到错误:", err.message); // 捕获到错误:失败了
  }
}

main();
// 执行顺序经典题:同步 > 微任务(Promise.then)> 宏任务(setTimeout)
console.log("1 同步");
Promise.resolve().then(() => console.log("2 微任务"));
setTimeout(() => console.log("3 宏任务"), 0);
console.log("4 同步");
// 输出顺序:1 同步 → 4 同步 → 2 微任务 → 3 宏任务

常见坑:

现象 原因 修法
UnhandledPromiseRejectionWarning / (node:xxx) UnhandledPromiseRejection 一个 Promise reject 了但没有 catch 每个 await 都在 try/catch 里,或链尾加 .catch
三个 await 写成串行,总耗时是三者之和 写成 await a; await b; await c; 一个接一个 并发场景用 Promise.all([a, b, c])
await 在普通函数里报 SyntaxError await 只能在 async 函数或模块顶层 包一层 async IIFE:(async () => { ... })()
Promise.all 一个失败全挂,但想拿到成功的结果 用了 all 而不是 allSettled 需要部分结果时用 Promise.allSettled,按 status 过滤

面试考法:高频题是"这段代码输出什么顺序""Promise.all 和 allSettled 的差别""async/await 怎么捕获错误"。要能背出"同步代码先跑完,再清空微任务队列(Promise.then、queueMicrotask),然后才进入宏任务(setTimeout、setImmediate、IO 回调)"。追问会到"为什么 await delay(100) 不会阻塞整个进程"。

六、分层练习

三档练习逐档升级,上一档没做完不要跳。

6.1 复现型(照着做,目标是跑通 + 能解释)

练习 要求 验收标准 预计耗时
装好 Node LTS 并切换 用 fnm 或 nvm 装一个 LTS,在 REPL 里打印 process.version node -v 显示偶数 LTS 版本号 0.5 小时
写一个带参数的脚本 接收 argv[2] 作为名字,读 NODE_ENV 输出环境 不传参数走默认值,传错环境变量行为不同 0.5 小时
复现执行顺序题 写一段含同步、Promise.then、setTimeout 的代码,先手写输出再运行验证 预判与实际输出完全一致,并能解释 1 小时
闭包计数器 用 IIFE 或闭包实现 inc/get/reset,外部访问不到内部 count 直接 obj.count 为 undefined 1 小时
Promise.all 并发小工具 并发请求三个模拟延迟任务,总耗时约等于最长那个而非三者之和 用 console.time 证明耗时在最长任务量级 1 小时

6.2 改造型(给出现成代码,改出正确行为)

练习 要求 验收标准 预计耗时
修循环定时器 给定 var 版本循环打印同一个值的代码,改成 let 打印 0 1 2 0.5 小时
修未捕获错误 给定一个会 reject 但没 catch 的 async 函数,加上 try/catch 不再出现 unhandledRejection 警告 0.5 小时
串行改并发 给定三个串行 await 的代码,改成 Promise.all 总耗时从三者之和降到最长那个 1 小时
this 绑定修复 给定一个类方法被当回调后 this 为 undefined 的例子,用 bind 或箭头函数修 回调里 this 指向正确实例 1 小时
相对路径改对 给定在不同目录运行报 ENOENT 的脚本,改成基于脚本目录 任意目录执行都能读到文件 0.5 小时

6.3 设计型(自己定方案,目标是能交付、能讲清取舍)

练习 要求 验收标准 预计耗时
命令行待办工具 用 argv 支持 add/list/done,数据存 JSON 文件 任意目录运行都能正确读写数据文件;错误参数有提示 4 小时
闭包模块封装 用闭包实现一个有私有状态的小缓存(get/set/has),不暴露内部 map 外部无法直接修改内部 map;有基本测试 3 小时
异步并发抓取器 并发抓取三个 URL(用 setTimeout 模拟),任一失败不影响其他成功结果,用 allSettled 失败任务标记为 rejected,成功任务结果可用 3 小时
Git 提交规范练习 把以上练习分别提交,commit message 写清楚改了什么 git log --oneline 至少 5 条可读提交 1 小时

七、排障表

现象 可能原因 排查步骤 解决办法
node: command not found / 不是内部或外部命令 Node 未装或版本管理工具未初始化 重开终端;where.exe node(Windows)看有没有路径 初始化 fnm/nvm,或重装 Node
Error: Cannot find module 'xxx' 依赖未安装、包名拼错、相对路径错 看 node_modules 下是否有该目录;看 require 路径 npm install;核对路径大小写
ENOENT: no such file or directory 相对路径基于当前工作目录,文件不在那里 console.log(process.cwd()) 看运行目录 用 path.join(__dirname, ...)
UnhandledPromiseRejectionWarning 某 Promise reject 了没人 catch 从栈信息定位是哪个 await / then 链 加 try/catch 或 .catch
SyntaxError: await is only valid in async functions await 写在普通函数里 看报错行所在函数是不是 async 包 async IIFE 或改函数签名
脚本跑完不退出,挂在那里 有未关闭的定时器/句柄 node -e "process._getActiveHandles()" 或在脚本末尾打印 清除定时器,或显式 process.exit()
this 在回调里是 undefined 严格模式下方法被抽离调用 看回调是怎么被调用的 bind、箭头函数或正确调用方式
版本切换后全局命令找不到 全局包按 Node 版本隔离 npm ls -g --depth=0 看当前版本有哪些全局包 在当前版本下重装该全局包

八、出口条件

全部勾选后再进入 阶段 1 运行时原理与核心 API。

  • [ ] 能用版本管理工具安装并切换 Node LTS,在任意目录运行脚本
  • [ ] 能从 process.argv 与 process.env 读取输入,写一个带参数的命令行小工具
  • [ ] 能手写一段含同步、Promise.then、setTimeout 的代码,预判输出顺序并运行验证
  • [ ] 能用 Promise.all 并发三个任务,任一失败能被 try/catch 捕获
  • [ ] 能画出原型链路径:实例 → 构造函数.prototype → Object.prototype → null
  • [ ] 能说清 this 的四种绑定规则,并修掉一个"回调里 this 为 undefined"的 bug
  • [ ] Git 仓库里有至少 5 条与练习对应的可读提交记录
  • [ ] 排障表里的八个现象,随机抽三个能在 5 分钟内给出排查路径

自测题(先自己想,再看要点):

  1. console.log(1); Promise.resolve().then(() => console.log(2)); setTimeout(() => console.log(3), 0); console.log(4); 的输出顺序是什么?
    • 要点:1 → 4 → 2 → 3。同步代码先跑完,再清空微任务队列,最后才进入宏任务(setTimeout 回调)。
  2. const obj = { n: 1, fn() { return this.n; } }; const f = obj.fn; f() 的返回值是什么?
    • 要点:严格模式下 this 是 undefined,访问 this.n 抛 TypeError。因为函数被抽离后直接调用,调用者不是 obj。
  3. var a = []; for (var i = 0; i < 3; i++) { a.push(() => i); } 之后 a[0]() 返回什么?为什么?
    • 要点:返回 3。var 是函数作用域,三个箭头函数共享同一个 i,循环结束后 i 是 3。改用 let 才能得到 0、1、2。
  4. 闭包为什么能让函数"记住"外层变量?这会导致内存问题吗?
    • 要点:内层函数持有外层词法环境的引用,外层函数返回后环境不被回收;本身不泄漏,只有长生命周期函数持有大对象且不再需要时才会内存常驻。
  5. Promise.all([a, b, c]) 和 Promise.allSettled([a, b, c]) 在 b 失败时行为有什么差别?
    • 要点:all 立即 reject(拿不到 a 和 c 的结果,除非另做处理);allSettled 等全部结束,返回 [{status:'fulfilled',value}, {status:'rejected',reason}, ...]。
  6. 在 /tmp 目录运行 node ~/project/app.js,代码里写 readFile("data.txt"),文件会从哪里找?
    • 要点:从 process.cwd() 即 /tmp 找,不是从脚本所在目录。改成 path.join(__dirname, "data.txt") 才能定位到脚本旁边。
  7. new Dog("旺财") 里 Dog 函数没写 return,为什么 d 是对象?
    • 要点:new 会自动创建空对象、把 [[Prototype]] 指向 Dog.prototype、绑定 this,并在构造函数没有显式 return 对象时返回这个新对象。