前言Node.js 在 2025 年已经迈出了传统的回调模式，转向了更现代的开发模式。今日由@Ashwin 分享，前端早读课@飘飘编译。
自 Node.js 诞生以来，它已经发生了翻天覆地的变化。如果你已经使用 Node.js 编写代码数年，那你一定亲身经历过这种演变 —— 从早期大量使用回调函数、以 CommonJS 模块为主，到如今更加简洁、符合标准的开发体验。
这些变化不仅仅是表面上的，它们代表了我们在构建服务端 JavaScript 应用方式上的根本转变。现代的 Node.js 更加拥抱 Web 标准，减少对外部依赖的需求，并带来了更直观的开发体验。下面我们来看看这些转变，以及它们为什么对 2025 年的应用开发至关重要。
1. 模块系统：ESM 成为新标准
模块系统可能是变化最大的一块。虽然 CommonJS 曾经非常实用，但现在 ES Modules（ESM）已经成为更理想的选择，带来了更好的工具支持，并与 Web 标准保持一致。
旧方式（CommonJS）
来看一下我们过去是如何组织模块的。这种方式需要显式导出，并通过同步方式导入模块：
// math.js
function add(a, b){
return a + b;
}
module.exports = { add };
// app.js
const{ add } = require('./math');
console.log(add(2,3));这种写法虽然可用，但存在一些局限性 —— 无法进行静态分析、不能进行 tree-shaking（按需打包优化），而且也不符合浏览器的模块标准。
现代方式（使用 node: 前缀的 ES 模块）
现代的 Node.js 更推荐使用 ES 模块，并且有一个关键的补充 —— 内置模块前加上 node: 前缀。这种显式命名可以避免混淆，让依赖关系更加清晰：
// math.js
export functionadd(a, b){
return a + b;
}
// app.js
import { add } from './math.js';
import { readFile } from 'node:fs/promises';// 使用 node: 前缀
import { createServer } from 'node:http';
console.log(add(2,3));node: 前缀不仅仅是个约定，它明确告诉开发者和工具：这是导入 Node.js 的内置模块，而不是来自 npm 的第三方包。这样可以防止潜在的冲突，让代码的依赖更明确。
顶层 await：简化初始化流程
另一个极具颠覆性的特性是 “顶层 await”。现在你不再需要为了在模块中使用 await 而把整个应用包在一个异步函数里了：
// app.js - 直接使用 await，无需包装函数
import{ readFile }from'node:fs/promises';
const config =JSON.parse(awaitreadFile('config.json','utf8'));
const server =createServer(/* ... */);
console.log('App started with config:', config.appName);这种写法摆脱了过去到处可见的 “立即执行的异步函数（IIFE）” 模式，让你的代码更加线性、逻辑更清晰，也更容易理解。
2. 内置 Web API：减少外部依赖
Node.js 正在大力拥抱 Web 标准，把很多 Web 开发者熟悉的 API 直接引入到运行时环境中。这带来的最大好处就是：减少了对外部依赖的需求，让不同平台之间的开发体验更一致。
Fetch API：不再依赖 HTTP 请求库
还记得以前每个项目都要安装 axios、node-fetch 或类似库来发起 HTTP 请求吗？现在这些都不再必要了，Node.js 已经原生支持 Fetch API：
// 旧写法 - 依赖外部库
const axios = require('axios');
const response = await axios.get('https://api.example.com/data');
// 新写法 - 使用内置 fetch，功能更强大
const response = await fetch('https://api.example.com/data');
const data = await response.json();不过，现代的用法不仅仅是替代 HTTP 请求库那么简单，它还内置了更高级的超时和取消功能：
async function fetchData(url){
try{
const response = await fetch(url,{
signal: AbortSignal.timeout(5000)// 内置超时支持
});
if(!response.ok){
throw newError(`HTTP ${response.status}: ${response.statusText}`);
}
return await response.json();
}catch(error){
if(error.name ==='TimeoutError'){
throw newError('请求超时');
}
throw error;
}
}这种写法不需要再使用第三方超时处理库，同时提供了一致且清晰的错误处理方式。AbortSignal.timeout() 方法尤其优雅 —— 它会在设定的时间后自动触发取消信号。
AbortController：优雅地取消操作
现代应用程序常常需要优雅地处理取消操作，无论是用户主动取消，还是因为超时等原因。AbortController 提供了一种标准化的方式来终止异步操作：
// 干净地取消耗时较长的操作
const controller = new AbortController();
// 设置自动取消
setTimeout(()=> controller.abort(),10000);
try{
const data = await fetch('https://slow-api.com/data',{
signal: controller.signal
});
console.log('获取到的数据：', data);
}catch(error){
if(error.name ==='AbortError'){
console.log('请求被取消——这是预期行为');
}else{
console.error('发生了意外错误：', error);
}
}这种模式不仅适用于 fetch，还适用于 Node.js 中的许多其他 API，比如文件操作、数据库查询，或任何支持取消的异步操作。你可以用同一个 AbortController 来统一管理这些异步任务的中止逻辑。
3. 内置测试功能：无需外部依赖的专业测试
过去进行测试时，通常需要在 Jest、Mocha、Ava 等测试框架中做出选择。而现在，Node.js 自带了功能完整的测试运行器，能够满足大多数测试需求，而且不再依赖任何第三方库。
使用 Node.js 内置测试运行器进行现代化测试
Node.js 自带的测试运行器提供了简洁而现代的 API，使用起来熟悉又强大：
// test/math.test.js
import { test, describe } from 'node:test';
import assert from 'node:assert';
import { add, multiply } from '../math.js';
describe('Math functions',()=>{
test('adds numbers correctly',()=>{
assert.strictEqual(add(2,3),5);
});
test('handles async operations',async()=>{
const result =awaitmultiply(2,3);
assert.strictEqual(result,6);
});
test('throws on invalid input',()=>{
assert.throws(()=>add('a','b'),/Invalid input/);
});
});这个测试框架最大的优势在于，它无缝集成在 Node.js 的开发流程中：
# 使用内置测试运行器运行所有测试
node --test
# 开发时启用 watch 模式（自动重新运行测试）
node --test --watch
# 查看测试覆盖率（Node.js 20+ 支持）
node --test --experimental-test-coverage其中的 watch 模式 对开发尤为有用，代码一旦变更就会自动运行测试，无需额外配置，能够提供即时反馈。
4. 更先进的异步编程模式
虽然 async/await 不是新特性，但围绕它的使用模式已经变得更加成熟。现代 Node.js 开发不仅更高效地使用这些模式，还与新 API 深度结合。
async/await + 错误处理增强
现代的错误处理方式结合了 async/await、高级错误恢复机制和并发执行：
import { readFile, writeFile } from 'node:fs/promises';
async function processData(){
try{
// 并行执行互不依赖的操作
const [config, userData] = await Promise.all([
readFile('config.json','utf8'),
fetch('/api/user').then(r=> r.json())
]);
const processed = processUserData(userData,JSON.parse(config));
await writeFile('output.json',JSON.stringify(processed,null,2));
return processed;
}catch(error){
// 有上下文的结构化错误日志
console.error('处理失败：',{
error: error.message,
stack: error.stack,
timestamp:newDate().toISOString()
});
throw error;
}
}这种模式不仅提升了性能（通过 Promise.all 实现并发），还通过统一的 try/catch 提供了结构化的错误管理和日志记录，方便后续排查。
使用 AsyncIterator 进行现代事件处理
事件驱动编程已经不仅仅是绑定事件监听器了。通过 AsyncIterator，可以更强大、更有控制地处理事件流：
import { EventEmitter, once } from 'node:events';
class DataProcessor extends EventEmitter{
async *processStream(){
for(let i =0; i <10; i++){
this.emit('data',`chunk-${i}`);
yield`processed-${i}`;
// 模拟异步处理延迟
await new Promise(resolve=>setTimeout(resolve,100));
}
this.emit('end');
}
}
// 使用 async iterator 消费事件
const processor = new DataProcessor();
for await(const result of processor.processStream()){
console.log('处理结果：', result);
}这种方式结合了事件的灵活性和 async 迭代的控制力。你可以顺序处理事件、自然应对背压（backpressure），还能优雅地中断处理流程。
5. 高级流处理：与 Web 标准无缝集成
流（Streams）一直是 Node.js 最强大的特性之一，如今它们已经演变为更加符合 Web 标准的形态，并提供了更好的互操作性。
现代流处理方式
得益于更直观的 API 和更清晰的编程模式，流处理变得更加易于理解与维护：
import { Readable, Transform } from 'node:stream';
import { pipeline } from 'node:stream/promises';
import { createReadStream, createWriteStream } from 'node:fs';
// 创建一个用于转换的流，实现逻辑简洁明确
const upperCaseTransform = new Transform({
objectMode:true,
transform(chunk, encoding, callback){
this.push(chunk.toString().toUpperCase());
callback();
}
});
// 使用健壮的错误处理逻辑处理文件流
async function processFile(inputFile, outputFile){
try{
await pipeline(
createReadStream(inputFile),
upperCaseTransform,
createWriteStream(outputFile)
);
console.log('文件处理成功');
}catch(error){
console.error('流处理失败：', error);
throw error;
}
}使用 pipeline（带 Promise 支持）可以自动清理资源、捕获错误，避免了传统流处理中的许多麻烦。
Web 流的互操作性
现代 Node.js 能够与 Web Streams 无缝配合，实现与浏览器端代码及边缘计算环境的更好兼容：
// 创建一个 Web 标准的可读流（可在浏览器中运行）
const webReadable = new ReadableStream({
start(controller){
controller.enqueue('Hello ');
controller.enqueue('World!');
controller.close();
}
});
// 在 Web Stream 和 Node.js Stream 之间进行转换
const nodeStream = Readable.fromWeb(webReadable);
const backToWeb = Readable.toWeb(nodeStream);这种互操作能力对于那些需要在多个平台（如服务器、浏览器、边缘环境）中复用代码的应用来说至关重要。
6. Worker 线程：为 CPU 密集型任务实现真正的并行处理
JavaScript 的单线程特性在处理 CPU 密集型任务时常常成为瓶颈。Worker 线程可以有效利用多核 CPU，同时保持 JavaScript 简单的编程模型。
后台处理，主线程无阻塞
当你需要执行耗时计算，又不想阻塞主线程时，Worker 线程就是最佳选择：
// worker.js - 独立的计算环境
import { parentPort, workerData } from 'node:worker_threads';
function fibonacci(n){
if(n <2)return n;
return fibonacci(n -1)+fibonacci(n -2);
}
const result = fibonacci(workerData.number);
parentPort.postMessage(result);主程序中将重计算任务交由子线程处理，主线程可以继续响应其他操作：
// main.js - 非阻塞任务委托
import { Worker } from 'node:worker_threads';
import { fileURLToPath } from 'node:url';
async function calculateFibonacci(number){
return new Promise((resolve, reject)=>{
const worker = new Worker(
fileURLToPath(new URL('./worker.js',import.meta.url)),
{workerData:{ number }}
);
worker.on('message', resolve);
worker.on('error', reject);
worker.on('exit',(code)=>{
if(code !==0){
reject(new Error(`Worker 线程异常退出，代码：${code}`));
}
});
});
}
// 主应用依然保持响应性
console.log('开始计算...');
const result = await calculateFibonacci(40);
console.log('斐波那契结果：', result);
console.log('应用在整个过程中保持了响应性！');这种模式让你可以充分利用多核 CPU 的性能，同时保留 async/await 带来的简洁逻辑，构建既高效又易维护的服务端应用。
7. 更优的开发体验
现代 Node.js 更加注重开发者体验，许多以前需要借助外部工具实现的功能，如今已成为内置能力，无需复杂配置。
Watch 模式与环境变量管理
现在的开发流程更加高效，得益于内置的 watch 模式和对 .env 文件的原生支持：
{
"name": "modern-node-app",
"type": "module",
"engines": {
"node": ">=20.0.0"
},
"scripts": {
"dev": "node --watch --env-file=.env app.js",
"test": "node --test --watch",
"start": "node app.js"
}
}--watch标志取代了
nodemon等工具--env-file让你不再依赖
dotenv，环境变量自动加载
// .env 文件内容自动被加载
// DATABASE_URL=postgres://localhost:5432/mydb
// API_KEY=secret123
// app.js 中立即可用
console.log('连接数据库：', process.env.DATABASE_URL);
console.log('API Key 是否加载成功：', process.env.API_KEY?'是':'否');这些功能减少了配置负担，也省去了频繁重启的步骤，让开发流程更顺畅。
8. 现代安全性与性能监控
安全性与性能现在成为 Node.js 的核心关注点，平台内置了多个工具用于控制权限与监控运行状态。
权限模型：增强安全控制（实验功能）
通过实验性权限模型，你可以限制应用程序的资源访问权限，遵循最小权限原则：
# 限制文件系统访问权限
node --experimental-permission --allow-fs-read=./data --allow-fs-write=./logs app.js
# 限制网络访问
node --experimental-permission --allow-net=api.example.com app.js这对于需要执行不可信代码，或需要通过安全审计的应用来说非常实用。
内置性能监控
现在无需外部 APM 工具，Node.js 内置了性能监控工具，可以帮助你快速定位性能瓶颈：
import { PerformanceObserver, performance } from 'node:perf_hooks';
const obs = new PerformanceObserver((list)=>{
for(const entry of list.getEntries()){
if(entry.duration >100){
console.log(`慢操作警告：${entry.name} 耗时 ${entry.duration}ms`);
}
}
});
obs.observe({entryTypes:['function','http','dns']});
// 自定义性能测量
async function processLargeDataset(data){
performance.mark('processing-start');
const result = await heavyProcessing(data);
performance.mark('processing-end');
performance.measure('data-processing','processing-start','processing-end');
return result;
}这种方式在开发早期就能发现性能瓶颈，不依赖第三方依赖，使用简单。
9. 应用分发与部署方式现代化
现代 Node.js 支持将应用打包为单一可执行文件，使得部署和分发更加轻松。
单个可执行应用程序
你可以将整个 Node.js 应用打包成一个独立可运行的文件，无需目标机器上事先安装 Node.js：
# 创建独立的可执行文件
node --experimental-sea-config sea-config.json示例配置文件 sea-config.json：
{
"main": "app.js",
"output": "my-app-bundle.blob",
"disableExperimentalSEAWarning": true
}这种方式对于 CLI 工具、桌面应用或需要 “一键运行” 的程序场景非常适用。
10. 现代化错误处理与诊断
错误处理已经不再局限于 try/catch，Node.js 提供了结构化错误与高级诊断能力。
结构化错误处理
现代应用程序可以通过自定义错误类，提供更丰富的调试和监控信息：
class AppError extends Error{
constructor(message, code, statusCode =500, context ={}){
super(message);
this.name ='AppError';
this.code = code;
this.statusCode = statusCode;
this.context = context;
this.timestamp =newDate().toISOString();
}
toJSON(){
return{
name:this.name,
message:this.message,
code:this.code,
statusCode:this.statusCode,
context:this.context,
timestamp:this.timestamp,
stack:this.stack
};
}
}
// 带上下文的异常抛出
throw new AppError(
'数据库连接失败',
'DB_CONNECTION_ERROR',
503,
{host:'localhost',port:5432,retryAttempt:3}
);这种方式让错误信息更加结构化，有助于日志分析和远程监控系统统一处理。
高级诊断机制
Node.js 还提供了 diagnostics_channel 模块，可以发布与订阅内部诊断信息：
import diagnostics_channel from'node:diagnostics_channel';
// 创建诊断通道
const dbChannel = diagnostics_channel.channel('app:database');
const httpChannel = diagnostics_channel.channel('app:http');
// 订阅数据库操作日志
dbChannel.subscribe((message)=>{
console.log('数据库操作记录：',{
operation: message.operation,
duration: message.duration,
query: message.query
});
});
// 发布数据库诊断信息
async function queryDatabase(sql, params){
const start = performance.now();
try{
const result =await db.query(sql, params);
dbChannel.publish({
operation:'query',
sql,
params,
duration: performance.now()- start,
success:true
});
return result;
}catch(error){
dbChannel.publish({
operation:'query',
sql,
params,
duration: performance.now()- start,
success:false,
error: error.message
});
throw error;
}
}这种机制可以与监控工具结合，也可以用于日志记录或自动化故障响应，帮助你深入了解应用运行情况。
11. 现代化包管理与模块解析
包管理和模块解析的能力日益增强，现代 Node.js 对于 monorepo 项目结构、内部模块 和 灵活的模块加载机制 提供了更完善的支持。
Import Maps 与内部模块解析
Node.js 现已支持 Import Maps，让你可以为内部模块定义简洁、稳定的导入路径：
{
"imports": {
"#config": "./src/config/index.js",
"#utils/*": "./src/utils/*.js",
"#db": "./src/database/connection.js"
}
}这样你可以在项目中使用清晰、可维护的内部模块导入方式：
// 简洁的内部导入，即使重构目录结构也不会出错
import config from '#config';
import{ logger, validator } from '#utils/common';
import db from '#db';这种方式清晰地区分了项目内部模块与外部依赖，有助于维护与重构，特别是在大型项目或 monorepo 中更显优势。
动态导入：实现灵活的加载策略
动态导入（import()）使你可以基于配置或运行时环境按需加载模块，支持更复杂的加载模式，如条件加载和代码拆分：
// 根据配置或环境变量加载数据库适配器
async function loadDatabaseAdapter(){
const dbType = process.env.DATABASE_TYPE||'sqlite';
try{
const adapter = await import(`#db/adapters/${dbType}`);
return adapter.default;
}catch(error){
console.warn(`找不到数据库适配器 ${dbType}，使用 sqlite 作为备选`);
const fallback = await import('#db/adapters/sqlite');
return fallback.default;
}
}
// 按需加载可选功能模块
async functionloadOptionalFeatures(){
const features =[];
if(process.env.ENABLE_ANALYTICS==='true'){
const analytics = await import('#features/analytics');
features.push(analytics.default);
}
if(process.env.ENABLE_MONITORING==='true'){
const monitoring =awaitimport('#features/monitoring');
features.push(monitoring.default);
}
return features;
}这种模式让应用具备 “自适应加载” 能力，只加载真正需要的代码，提高性能并减少初始开销。
前瞻总结：2025 年现代 Node.js 的关键理念
综合整个 Node.js 的现代化演进，我们可以归纳出以下几个核心原则：
拥抱 Web 标准：使用
node:前缀、Fetch API、AbortController 和 Web Streams 等标准接口，提高兼容性，减少依赖。充分利用内置工具：内置测试运行器、
--watch模式、环境变量支持，显著简化开发配置，提升效率。采用现代异步模式：使用顶层 await、结构化错误处理、异步迭代器，使代码更简洁、可读性更强。
策略性使用 Worker 线程：在 CPU 密集型任务中使用 Worker 实现真正的并行处理，避免主线程阻塞。
渐进式增强设计：使用权限模型、诊断通道和性能监控，构建更加健壮且可观测的应用系统。
优化开发体验：结合 Watch 模式、内置测试框架和 Import Maps，让开发过程更轻松愉快。
简化部署流程：通过单文件可执行应用和现代打包技术，显著降低部署和分发的复杂度。
Node.js 的未来：从运行时走向全能开发平台
Node.js 从一个简单的 JavaScript 运行时，逐步演进为功能强大、生态完善的现代开发平台。这种转变不仅体现了技术的进步，也展现了对开发者需求的深度理解。
通过采用这些现代化模式，你写下的代码将不仅更具现代风格，还更容易维护、性能更优，同时与更广泛的 JavaScript 生态系统保持同步。
现代 Node.js 的魅力在于：不断进化，同时保持向后兼容。你可以逐步引入这些现代特性，它们能与现有代码和谐共存。不论是新项目，还是对旧项目的现代化改造，这些模式都为你提供了一条明确、稳健的升级路径。
关于本文
译者：@飘飘
作者：@Ashwin
原文：https://kashw1n.com/blog/nodejs-2025/
扫一扫
1109
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
