安装和使用与内置常量（Day6 2/3）

本页对应 Day06_Node，共 5 段视频，约 1 小时 7 分。

学习目标

1. 能独立下载并安装 Node.js LTS 版本，安装后通过 node -v 验证版本并判断安装是否成功。
2. 能在指定目录中通过 CMD、PowerShell、Git Bash 或 VS Code 集成终端打开命令行，解释当前工作目录对执行脚本的影响。
3. 能分别使用 REPL 交互模式和 .js 脚本文件运行 JavaScript 代码，并说明表达式自动输出与 console.log 输出的区别。
4. 能编写代码输出 __dirname 与 __filename，并解释二者分别表示脚本所在目录和脚本文件的绝对路径。
5. 能使用 Buffer.alloc、Buffer.allocUnsafe、Buffer.from 创建 Buffer，并验证其十六进制显示、字节长度、溢出截断及字符串转字节结果。
6. 能通过索引、forEach 和 toString 读取 Buffer 内容，并将二进制数据按指定编码转换为可读字符串。

知识点

先装 Node：为什么不能像浏览器一样直接写

为什么需要：浏览器自带 JavaScript 运行环境，而 Node 需要单独安装；装好后才能在命令行里运行 .js 文件。
怎么想：先选稳定版本，再确认安装成功，最后学会在正确目录打开命令行。
怎么做：到 Node 官网或中文网站下载，两个版本要分清：LTS 是长期支持版，稳定、推荐大多数人使用；current 是最新版，适合想尝鲜或给 Node 反馈的人。课程里用 LTS 18.16。Windows 下载 .msi 安装程序，64 位系统选 x64。
易错点：安装路径不要出现中文；历史老项目可能依赖旧版 Node，后面可用版本管理工具切换，不要误以为装新版本一定兼容老项目。

命令行工具与“当前目录”

为什么需要：Node 要通过命令行运行，而命令默认作用于“当前所在目录”。
怎么想：先看终端地址栏/提示符，确认自己在哪个目录，再决定运行哪个文件。
怎么做：Windows 可用 CMD、PowerShell、Git Bash；VS Code 可右键目录选择“在集成终端中打开”。也可以在资源管理器地址栏输入 cmd 或 powershell，或按住 Shift 右键打开。切换盘符用 D:，切换目录用 cd。
易错点：CMD 不支持下文的 ls，PowerShell 支持；VS Code 快捷键反引号打开的终端可能位于整个项目最外层，不如右键指定目录准确。关闭终端要点删除/终止，不是只关面板。

安装 Node 与验证

为什么需要：只有安装成功，node 命令才可用。
怎么做：双击安装包，点运行，等待 Next 出现；同意协议，选择安装位置，路径不要中文；后续默认下一步，工具可不勾，安装完成后点 Finish。
验证：在任意命令行执行：

node -v

若显示 18.16.0，说明成功。
易错点：若提示“不是内部或外部命令”，通常是没装成功或环境变量/PATH 有问题，需要排查，不要继续往下写代码。

两种运行 JS 的方式：REPL 与脚本

为什么需要：临时算表达式和正式开发是两种场景。
怎么做：第一种是交互式解释器：

node
1 + 1
Math.round(Math.random())

表达式会直接显示结果；退出按两次 Ctrl+C，或输入 .exit。第二种是把代码写入 .js 文件，例如：

for (let i = 0; i < 10; i++) {
  console.log(i);
}

在文件所在目录打开终端，执行：

node 01.js

易错点：REPL 里写表达式会自动显示值；脚本文件里必须写 console.log 才会输出。运行找不到文件时，先检查终端当前目录，或使用绝对路径。

内置常量：__dirname 与 __filename

为什么需要：程序常要知道“当前脚本在哪个目录”，拼接路径时不能靠猜。
怎么做：

console.log(__dirname);
console.log(__filename);

__dirname 是脚本所在目录的绝对路径，__filename 是脚本文件自身的绝对路径。
易错点：它们跟随文件位置变化，不是固定值；换目录运行，结果就不同。理解“位置决定路径”，不要死背。

Buffer 初步：Node 处理二进制数据的类型

为什么需要：读文件、网络传输拿到的常是二进制数据流，Node 用 Buffer 描述它。
怎么想：它类似数组，但每个元素固定 1 字节，大小创建时确定，直接操作内存，性能好。
怎么做：

const b1 = Buffer.alloc(12);        // 12 字节，默认清零
const b2 = Buffer.alloc(10, 20);    // 10 字节，每字节填 20
const b3 = Buffer.allocUnsafe(12);  // 不清零，可能带旧数据
const b4 = Buffer.from('hello高小乐');
const b5 = Buffer.from([12, 23, '乐']);

读取与解码：

console.log(b4[0]);        // 读取为十进制
b4.forEach((item, index) => console.log(item, index));
console.log(b4.toString()); // 按字符串解码

易错点：终端显示 Buffer 常用十六进制，读取单个元素是十进制；UTF-8 下一个汉字占 3 字节，所以 hello高小乐 是 6+9=15 字节；allocUnsafe 不清零；写入超过 255 会溢出，只保留低位，如 257 显示为 01。Buffer 抽象但必须学，因为后续读文件、收网络数据都会遇到它。

先认识两个“拿来就用”的路径常量

本节笔记只有两个内置常量：

__dirname		获取JS脚本所在目录的绝对路径
__filename		获取JS脚本自己的绝对路径

为什么需要：后面写Node代码时，经常要读文件、写文件、拼接路径。比如脚本旁边有一个数据文件，代码要知道“当前这个JS文件在哪个目录”，不能靠猜，也不能靠命令行当前所在目录。Node提供了这两个常量，就是为了让代码能拿到脚本自身的位置信息。

怎么想：把“目录”和“文件”分开看。__dirname 是脚本所在目录，__filename 是脚本文件自己。它们给出的都是绝对路径，不是相对路径。它们由Node在模块代码中直接提供，拿来用即可，不要自己声明，也不要试图改它的值。

怎么做：新建一个JS文件，例如 02-内置常量.js，写两行输出：

// 02-内置常量.js
console.log(__dirname);
console.log(__filename);

然后在终端运行：

node 02-内置常量.js

终端会输出两行路径：第一行是脚本所在目录的绝对路径，第二行是脚本文件自己的绝对路径。

易错点：笔记里的两行是说明，不是可执行JS；真正运行时必须用 console.log 输出。终端里看到两行路径，不是报错，那就是程序输出。不要给这两个常量重新赋值，按“内置常量”直接使用。

__dirname：脚本所在目录的绝对路径

为什么需要：当你要找“和当前JS文件放在同一个目录里的文件”时，最需要的是目录。例如后续读文件，如果只知道命令行当前在哪，换个地方打开终端就可能找错；__dirname 取的是JS脚本所在目录，和脚本位置绑定。

怎么想：它回答的问题是“我这个脚本放在哪个文件夹里”。注意它到目录为止，不包含后面的文件名。转写里演示时，新建 02-内置常量.js，输出 __dirname，运行 node 02-内置常量.js，终端显示的就是脚本所在目录的绝对路径。调试时可以把脚本换到别的位置再运行，观察结果会跟着脚本位置变化，这样就不用死记。

怎么做：

console.log(__dirname);

在VS Code里可以在脚本目录右键“在集成终端中打开”，再执行 node 02-内置常量.js；终端目录不对时，就用相对路径或绝对路径指定这个JS文件。

易错点：不要把“命令行在哪个目录打开”当成 __dirname。转写里反复强调命令行有“所在目录”，但 __dirname 看的是JS脚本自己的位置。脚本换位置，值会变；不要把它理解成固定不变的某个盘符路径。它也不包含文件名，拼同目录文件时用它更合适。

__filename：脚本自己的绝对路径

为什么需要：有时你要知道“当前执行的到底是哪个JS文件”，或者要把文件自身的完整路径打印出来排查问题。__filename 给出的是脚本文件自己的绝对路径，包含文件名。

怎么想：它回答的问题是“这个脚本文件本身在哪里”。和 __dirname 对比记：一个到目录，一个到文件。转写中把两个变量一起输出，终端里能直接看出第二行比第一行多了文件名，这就是最直观的区分。

怎么做：

console.log(__dirname);
console.log(__filename);

运行后对比两行输出：__dirname 是目录，__filename 是目录加文件名。

易错点：不要把 __filename 当成目录去拼“同目录文件”，否则容易把文件名也带进去。也不要以为在JS文件里光写 __filename 就会自动输出；在文件中必须写 console.log，这一点和交互式命令行里写表达式自动显示结果不一样。终端输出的是绝对路径，不是相对路径；文件换位置，结果也会变。

一起验证与常见坑

最稳的验证方式就是“只输出、先观察”：建 02-内置常量.js，写上面两行 console.log，在脚本所在目录打开终端，执行 node 02-内置常量.js。如果终端提示找不到文件，先检查终端当前目录和命令里的文件名；也可以改用相对路径或绝对路径。转写里的调试思路是：先看输出是不是两个绝对路径，再把脚本放到别的位置运行，观察路径随脚本位置变化。这样就能理解它们不是死记的字符串，而是由运行环境根据脚本位置给出的信息。

最后记住三点：__dirname 是目录，__filename 是文件；两者都是绝对路径；它们跟着JS脚本文件的位置走，不要拿命令行当前目录替代。

一、为什么 Node 要单独讲 Buffer

为什么需要：浏览器里有 window、document，但 Node 里没有；Node 要读文件、接收网络请求，拿到的往往不是普通字符串，而是二进制数据流。转写里反复说的“八份、巴ffer、八赫”都是 Buffer，它是 Node 用来描述这种二进制数据的内置类型。
怎么想：把 Buffer 想成“字节数组”：它像数组一样有长度、能按下标访问，但每个元素固定占 1 字节，专门保存二进制数据。
怎么做：先接受一个事实——终端里打印 Buffer 时常用十六进制显示，而按下标读出来是十进制数字。
易错点：不要把它当普通字符串或普通数组；它的长度创建时确定，不能随意调整。

二、Buffer 的本质：字节数组与单位

为什么需要：计算机底层存的是二进制，网线里传的也是二进制；JS 需要一种能直接操作这些字节的类型。
怎么想：1 字节 = 8 比特，8 个二进制位能表示 0~255。所以 Buffer 每个元素的范围是 0 到 255；超过就截断高位。
怎么做：用 Buffer.alloc(12) 创建一个 12 字节的 Buffer，终端会显示 12 个 00。
易错点：终端显示 00、14、61 是十六进制；b[0] 读出来是十进制。比如 0x48 显示为 48，读出来是 72，不是“48 变成了 72”这么玄。

三、创建 Buffer：alloc、allocUnsafe、from

为什么需要：不同场景创建方式不同：要安全清零、要快但不清零、要从字符串或数组转。
怎么想：alloc 创建并初始化；allocUnsafe 只开辟内存、不保证清零；from 从字符串/数组转成 Buffer。
怎么做：

const b1 = Buffer.alloc(12);
console.log(b1); // 12 个 00

const b2 = Buffer.alloc(10, 20);
console.log(b2); // 每个字节是 0x14，即十进制 20

const b3 = Buffer.alloc(10, 'a');
console.log(b3); // 每个字节是 0x61，即十进制 97

const b4 = Buffer.alloc(1, 257);
console.log(b4); // 01，257 截断高位后只剩 1

const b5 = Buffer.allocUnsafe(12);
console.log(b5); // 可能含旧数据，不保证全是 00

易错点：allocUnsafe 名字里的“Unsafe”就是“可能带旧数据”，不能假设它是空的；Buffer.alloc(10, 20) 显示 14 是十六进制，不是 14 个字节；257 超过 255 会溢出成 01。

四、读写 Buffer：索引、forEach、toString

为什么需要：拿到 Buffer 后要能读某个字节、遍历所有字节，也要能把二进制按 UTF-8 解码回字符串。
怎么想：Buffer 像数组，可以用下标读；forEach 能拿到值和索引；toString() 会按编码解码。
怎么做：

const b = Buffer.from('Hello 高小乐');
console.log(b.length); // 15
console.log(b[0]);     // 72，对应十六进制 0x48
console.log(b[6]);     // 233，是“高”的第一个字节

b.forEach((v, i) => {
  console.log(i, v);   // 输出索引和十进制字节值
});

console.log(b.toString()); // Hello 高小乐

调试时看终端：<Buffer 48 65 6c 6c 6f ...> 里的 48 是十六进制；b[0] 输出 72，因为 0x48 = 72。
易错点：一个汉字在 UTF-8 下通常占 3 字节，b[6] 只是“高”的第一个字节，不能单独解码成完整汉字；toString() 才能整体解码。

五、字符串、数组与常见调试结论

为什么需要：实际数据来源不同：字符串、数组、数字都可能被转成 Buffer。
怎么想：字符串按 UTF-8 编码成字节；数组转 Buffer 时一个数组元素对应一个字节。
怎么做：Buffer.from('Hello 高小乐') 的长度是 15，因为 Hello 5 个字母 + 1 个空格 + 高小乐 3 个汉字×3 字节 = 15。
易错点：不要以为“字符数 = 字节数”；中文在 UTF-8 下是 3 字节。转写里的“阿洛克”是 alloc，“按safe”是 allocUnsafe，“兔子俊”是 toString，纠正过来再写代码就不容易混。

先把 Node 的运行环境确认清楚

本节笔记只有一条核心结论：Node 中的模块分为内置模块、第三方模块和自定义模块；不论哪一种，使用时都必须先引入模块。转写稿前半段大量在讲 Node 下载、安装和命令行，看似离“模块”很远，其实是在补一个前提：Node 不像浏览器自带运行环境，必须先安装，后面才谈得上使用模块。

为什么需要：如果 Node 没装好，或者命令行所在目录不对，后面无论引入内置模块还是运行 JS 文件都会失败。怎么想：先确认“Node 能不能运行”，再谈“模块怎么引入”。怎么做：转写稿中安装的是 LTS 长期维护版 18.16.0，安装完成后桌面不一定出现客户端，要在命令行执行：

node -v

能显示版本号，说明安装成功。再在目标目录打开终端，用 node 文件名 运行脚本。易错点：把 Node 当成浏览器自带环境；安装路径带中文；在错误目录打开命令行；把 node -v 写成其他命令。转写稿还提醒，CMD、PowerShell、Git Bash、VS Code 集成终端都能用，但要注意终端“所在目录”，否则找不到文件。

三种模块要按“来源”区分

为什么需要：Node 的代码不是全写在一个文件里，模块就是组织代码的方式。先按来源分类，才不会把 Node 自带的能力、别人写的包、自己写的文件混在一起。怎么想：内置模块是 Node 自带的；第三方模块是安装或下载来的；自定义模块是自己项目里的文件。三者来源不同，但使用原则相同——先引入，再使用。怎么做：本节先建立分类意识：看到 fs、path 这类 Node 自带能力，要知道它属于内置模块；看到项目里自己写的 .js 文件，要知道它属于自定义模块；看到通过包管理器安装的依赖，要知道它属于第三方模块。具体引入语法本节笔记没有展开，不能凭空补写；本节要记牢的是“使用前必须先引入”这个顺序。易错点：不引入就直接使用模块；把内置模块误认为第三方模块；把第三方模块当成 Node 自带；把全局对象、内置常量误当成“模块”。

“先引入”先建立什么意识

为什么需要：初学者常见错误是“看到名字就直接用”。Node 中并不是所有东西都像浏览器里的 console 一样随手可用，模块必须先引入。怎么想：先判断来源，再决定引入方式；本节只强调原则，不提前编造后续语法。怎么做：读代码时先找引入语句，再找使用位置；自己写代码时先写引入，再写调用。转写稿中演示的 __dirname、__filename 可以直接输出，是因为它们是 Node 环境中的内置常量，不是“模块引入”的示例；Buffer 也是 Node 自有数据类型，不能拿来证明“模块不用引入”。易错点：把 __dirname、__filename、Buffer 当成三种模块的替代例子；把“全局可用”和“模块已引入”混为一谈。

用转写稿的调试过程校验理解

转写稿的调试过程可以借来练“先验证环境，再验证代码”。运行脚本时用：

node 02

如果文件在目标目录中，相对路径即可；不在目标目录，就要写绝对路径。交互模式里写 1 + 1 会自动显示结果，但脚本文件中必须写 console.log 才会输出，这一点很容易错。转写稿还演示了 Buffer.alloc 输出十六进制、读取元素得到十进制、一个 UTF-8 汉字占三个字节、写入 257 会溢出并舍去高位。这些说明 Node 自有数据类型有底层规则，但它们不是本节“模块分类”的主体，只作为边界提醒：不要把 Node 的全局能力、内置常量、Buffer 和“模块引入”混为一谈。本节最终要落下的动作是：先确认 Node 环境，再按来源识别模块，最后记住“使用前先引入”。

课堂画面

代码示例

1. 脚本方式运行 JS：01-node使用演示.js

// 文件名：01-node使用演示.js
// 运行方式：在该文件所在目录打开终端，执行  node 01-node使用演示.js
// 相对路径、绝对路径都可以，但终端所在目录要能定位到这个文件

for (let i = 0; i < 10; i++) {
  console.log(i);
}

要点解释：

• console.log 在 Node 里就是输出，node 文件名 即可执行，不需要浏览器、不需要 HTML。
• 易错点：脚本文件里光写一个 100 是不会有任何输出的，必须用 console.log 输出；只有交互式 REPL 里写表达式才会自动显示值。
• 易错点：终端所在目录不对会报“找不到模块/文件”，要么先 cd 到目录，要么写绝对路径。

2. 内置常量：02-内置常量.js

// 文件名：02-内置常量.js
// 运行：node 02-内置常量.js

console.log(__dirname);   // 当前 JS 脚本所在目录的绝对路径
console.log(__filename);  // 当前 JS 脚本自身的绝对路径

要点解释：

• __dirname 和 __filename 是 Node 内置常量（全局可用），值随运行环境变化，把文件换个位置再运行，输出就变了。
• 易错点：两个下划线，前后各两个，写成一个下划线会直接报未定义。
• 易错点：二者都是绝对路径，不是相对路径；__dirname 是“目录”，__filename 是“文件自己”。
• 注意：window、location、document 在 Node 中不可用，Node 的全局对象是 global。

3. Buffer 创建、读取与转换

// 文件名：02-buffer/01-创建一个buffer感受感受.js
// 运行：node 01-创建一个buffer感受感受.js

// 1) alloc：指定长度创建，会被初始化（清空），内容全为 00
const b1 = Buffer.alloc(12);
console.log(b1); // <Buffer 00 00 00 00 00 00 00 00 00 00 00 00>

// 2) alloc 带第二个参数：用该值填充每个字节
const b2 = Buffer.alloc(10, 20); // 20 是十进制，显示为十六进制 14
console.log(b2);

// 3) alloc 填充字符：按编码存
const b3 = Buffer.alloc(10, 'A'); // 'A' 的编码 97，十六进制 61
console.log(b3);

// 4) allocUnsafe：不初始化，可能带旧数据（快，但不安全）
const b5 = Buffer.allocUnsafe(12);
console.log(b5);

// 5) from 字符串：UTF-8 下一个汉字占 3 个字节
const b6 = Buffer.from('hello高小乐');
console.log(b6);      // 15 个字节：5 个字母 + 3 个汉字 × 3
console.log(b6.length);

// 6) from 数组：一个数组元素对应一个字节
const b7 = Buffer.from([12, 23, 0x41, '乐']);
console.log(b7);

// 7) 读取：像数组一样按索引取，得到的是十进制数字
console.log(b6[0]);      // 72（即十六进制的 0x48，字母 h）
console.log(b6[6]);      // 233，汉字“高”的第一个字节

// 8) 遍历 + 转回字符串
b6.forEach((item, index) => {
  console.log(index, item);
});
console.log(b6.toString()); // hello高小乐

// 9) 溢出：一个字节最大 255，超出部分舍去高位
const b8 = Buffer.alloc(1);
b8[0] = 257;
console.log(b8); // <Buffer 01>

要点解释：

• Buffer 是专门存二进制数据的类数组对象，每个元素固定 1 字节，创建时长度固定、不能调整；console.log 默认以十六进制显示。
• 易错点：打印是十六进制（48），按索引读取是十进制（72），同一个值两种写法，别被绕晕；alloc(10, 20) 显示 14 也是这个原因。
• 易错点：Buffer.from('汉字') 是 3 个字节（UTF-8），而 Buffer.from([...]) 一个元素就是一个字节，两者规则不同。
• 易错点：allocUnsafe 不会清空内存，可能残留旧数据，只要求性能时才用；alloc 是安全版。
• 易错点：赋值超过 255 会溢出并舍去高位，257 只剩 01。
• toString() 会按编码解码成字符串，这是把文件读取/网络收到的 Buffer 变成可读内容的关键。

常见错误

1. node -v 提示"不是内部或外部命令"

• 现象：装完 Node 后在任何终端敲 node -v 都报错，但安装过程没报错。
• 原因：安装时没勾选加入 PATH；或安装路径里带了中文/空格；或装完后没有重开终端，旧终端读的还是旧环境变量。
• 修法：重装并勾选 Add to PATH、路径换成纯英文（如 D:\nodejs）；关掉所有终端窗口重新打开再试；仍不行就手动把安装目录加进系统环境变量 Path。

2. node xxx.js 报 Cannot find module

• 现象：文件明明存在，Node 却说找不到模块。
• 原因：终端当前所在目录不是 js 文件所在目录，xxx.js 被当成相对当前目录的路径。
• 修法：先 pwd / 看终端提示符确认目录，cd 过去；或在目标文件夹里右键"在集成终端中打开"；或直接给绝对路径 node D:\code\demo\01.js。

3. 脚本里只写 100 却没有任何输出

• 现象：同样的代码在 REPL 里回车就出结果，写成 js 文件运行却一片空白。
• 原因：REPL 会自动回显表达式求值结果，脚本文件不会，必须有显式输出。
• 修法：脚本里用 console.log(100)；把"REPL 自动回显"和"脚本需手动输出"当成两条不同规则记。

4. REPL 里 Ctrl+C 一次退不出去

• 现象：按一下 Ctrl+C 只是出现 (To exit again, press Ctrl+C)，人还卡在里面。
• 原因：REPL 把单次 Ctrl+C 当作"取消当前输入"，需要第二次才退出。
• 修法：连按两次 Ctrl+C，或输入 .exit 回车；终端被占住时优先用 .exit 更稳。

5. Buffer.allocUnsafe 读出来不是全 0

• 现象：以为和 alloc 一样是空的，结果偶尔出现乱七八糟的旧数据。
• 原因：allocUnsafe 只分配内存不清零，可能残留上一次的数据；alloc 才会清零。
• 修法：需要确定性内容一律用 Buffer.alloc(len, fill)；只有明确追求性能且会立刻整体覆写时才用 allocUnsafe。

6. Buffer.from([12, 23, 300]) 结果和预期不符

• 现象：数组里放大于 255 的数，得到的字节不是那个数。
• 原因：每个元素固定 1 字节，超过 255 的部分被截断（只保留低位）。
• 修法：数组元素保证在 0–255；要存大数改用 Buffer.alloc 后按位写入或用多字节编码。

7. Buffer.from('高小乐').length 得到 9 而不是 3

• 现象：以为一个汉字一个元素。
• 原因：默认 UTF-8 编码，一个汉字占 3 字节。
• 修法：按字节数思维处理 Buffer，toString() 解码回字符串再按字符操作；不要把 Buffer 长度当字符数。

练习

练习 1｜环境自检 在三个不同位置（用户目录、桌面、某个项目文件夹）分别打开终端，运行 node -v，并说出每个终端当前的"所在目录"是什么；再用 cd 切到另一个盘符下的目录并验证。

练习 2｜两种运行方式对比 新建 demo.js，里面只写 1 + 1。先用 node demo.js 运行，再进入 REPL 敲 1 + 1，记录两次输出差异，并补一行代码让脚本也能输出结果。

练习 3｜路径常量实验 写一个 js 文件输出 __dirname 和 __filename，分别用「相对路径运行」和「在另一个目录用绝对路径运行」两种方式执行，比较两次输出是否变化，并解释原因。

练习 4｜Buffer 创建三连 分别用 Buffer.alloc(8)、Buffer.alloc(8, 20)、Buffer.from('hello高小乐') 创建三个 Buffer 并打印，数出各自的元素个数，说明每个数字为什么是这个值。

练习 5｜Buffer 读写与解码 对 Buffer.from('hello高小乐') 依次做：取下标 0 和下标 7 的值、用 forEach 打印每个字节及其索引、最后用 toString() 还原字符串。要求说明"打印出来是十六进制、取值出来是十进制"这件事。

原视频对照

#	视频	时长
1	Node下载和命令行工具	14:45
2	Node安装	04:19
3	Node中运行js代码	07:08
4	内置常量	03:44
5	Buffer	37:23

小结

1. Node 必须自己装，选 LTS 长期维护版即可；Current 只适合想尝鲜或给官方反馈的人。
2. 安装的两条硬性要求：路径不含中文、装完能通过 node -v 验证；验证失败基本是 PATH 问题。
3. 命令行工具用哪个都行，但要先看清"当前所在目录"——所有相对路径操作都基于它，这是新手最容易翻车的地方。
4. 在 VS Code 里右键"在集成终端中打开"是最省事的做法，能保证终端目录就是文件目录。
5. Node 跑 JS 有两条路：REPL 适合临时算表达式（会自��回显，Ctrl+C 两次或 .exit 退出），脚本文件才是真正开发方式（必须手动 console.log）。
6. __dirname / __filename 是内置常量，跟随文件实际位置变化，用来定位脚本自身和所在目录，不能赋值修改。
7. Buffer 是 Node 独有的二进制数据类型，长度固定、元素固定 1 字节（0–255），对外默认以十六进制显示、取值时是十进制。
8. alloc 清零、allocUnsafe 不清零可能残留旧数据、from 可从字符串或数组创建；后面读文件、收网络请求拿到的都是 Buffer，toString() 是把它变回可读内容的关键一步。