按理说，

前言

如果你用 Node.js 写过简单的文件读写。你一定见过这样的代码：

fs.readFile => {
// 读完了接下来呢？})，

但如果你需要顺序读取三个文件呢？你可能会写出层层嵌套的“金字塔代码”。再往后你学会了 Promise、async/await，但你有没有想过：

• 为什么 Node.js 要设计成异步的？
• 从回调到 async/await，底层到底发生了什么？按理说，
• 为什么 await 能让异步代码“看起来”像同步。但它真的阻塞了吗，

今天我们就从一段真实的 fs 模块代码出发，把这些问题彻底聊透。

一、主要概念提炼：Node.js 异步 I/O 的“点餐哲学”

Node.js 的 fs模块，本质是一个文件操作工具箱提供了对文件和目录的增删改查能力。

但它的设计初衷才是真正值得玩味的地方：

从打个比方来看。

• 同步读文件: 就像你去食堂打饭，站在窗口前死等阿姨给你盛好，你不走，后面的人全得等着。这就是“阻塞”，
• 异步读文件: 就像你拿了号。先去干别的，等叫到你的号再回来取饭。这就是“非阻塞”，

Node.js 之所以能在高并发场景下表现出色，靠的就是这种“单线程 + 事件循环 + 非阻塞 I/O" 的黄金组合。

二、痛点与场景：为什么需要异步？

从业务场景来看，顺序读取三个配置文件

假设你的服务启动时需要依次读取 file1.txt、file2.txt、file3.txt而且必须按顺序**。不过，**如果用同步方式**写：

const data1 = fs.readFileSync;console.log，const data2 = fs.readFileSync;console.log，const data3 = fs.readFileSync;console.log，

#fs.readFileSync 真正意义上的同步会阻塞主进程#

Pain Point： 代码很清晰，但主线程被阻塞了三次。按理说，If each file takes ~100 ms。那么 300 ms 内服务器"什么都干不了"—新来的请求全部排队。说起来，

三、重难点剖析

从重难点一来看。回调地狱——为什么它“臭名昭著”？

A typical “反面教材”:

// ❌ 回调地狱 —— 横向发展，难以维护
fs.readFile => {
if {
console.log;} else {
console.log;话说回来，}
fs.readFile => {
if {
console.log;
} else {
console.log;}
fs.readFile => {
if {
console.log;} else {
console.log;}
})，});})，

This code has three fatal problems:

1. Pain Point – 可读性极差：The “金字塔”式嵌套让逻辑难以追踪。
2. Pain Point – 错误处理重复：You must manually check err` at every level.
3. Pain Point – 难以组合：A single insertion can ripple through whole call‑stack.

重难点二的观点是。Promise 链式调用——“拍平”了但还不够优雅

// ✅ Promise + n 链式调用 —— 拍平了缩进，但仍是"爬楼梯"
import fs from 'fs/promises';fs.readFile
.n(data => {
console.log;return fs.readFile;// 返回新的 Promise
})
.n(data => {
console.log;return fs.readFile;})
.n(data => {
console.log;})
.catch(err => {
console.error;})，

• Pain Point – 优点：The indentation is flat;errors are centralized in a single .catch.
• Pain Point – 局限：You still have to manually return next Promise in every .n。and complex flows make chain bulky.

重难点三这方面，async/await——"语法糖"背后的微任务真相

// ✅ async/await —— 异步代码，同步写法
import fs from 'fs/promises';怎么说呢，// IIFE让顶层也能使用 await
=> {
try {
const data1 = await fs.readFile;console.log，const data2 = await fs.readFile;console.log，const data3 = await fs.readFile;console.log，} catch {
console.error;}
})，不过，

误解①的观点是。alert

#不是！# alert

• The call returns a Promise.
• alertasync function execution。not event loop.
.
• The main thread continues handling or tasks .
. .

Oops - we need proper html not stray text

Sorry let's correct that portion.

We'll rewrite this section correctly.

If you have ever written simple file read/write code with Node.js,you’ve probably seen something like this:

fs.readFile => {
// read finished…what now，});

If you need to **read three files in order**,you might end up with a deeply nested “pyramid” of callbacks. Later you learn about Promises and 。but have you ever wondered:

• Why does Node.js adopt an asynchronous model?按理说，
• What actually changes under hood when we move from callbacks to async/await?
• Does alert
\endul>

This article starts from a real piece of `fs`<\/cde code and dives deep into those questions.