Node.js — Run JavaScript Everywhere

2025年了，Node js 怎么写；别有说法。

该有些基本的考量

The Path Forward: Key Takeaways for Modern Node.js (2025)

• As we look at the current state of Node.js development, several key principles emerge:
• Embrace Web Standards: Use node: prefixes, fetch API, AbortController, and Web Streams for better compatibility and reduced dependencies
• Leverage Built-in Tools: The test runner, watch mode, and environment file support reduce external dependencies and configuration complexity
• Think in Modern Async Patterns: Top-level await, structured error handling, and async iterators make code more readable and maintainable
• Use Worker Threads Strategically: For CPU-intensive tasks, worker threads provide true parallelism without blocking the main thread
• Adopt Progressive Enhancement: Use permission models, diagnostics channels, and performance monitoring to build robust, observable applications
• Optimize for Developer Experience: Watch mode, built-in testing, and import maps create a more pleasant development workflow
• Plan for Distribution: Single executable applications and modern packaging make deployment simpler

Node.js 从一个简单的 JavaScript 运行时转变为一个全面的开发平台，这令人瞩目。通过采用这些现代模式，您不仅可以编写现代代码，还可以构建更易于维护、性能更高、并与更广泛的 JavaScript 生态系统保持一致的应用程序。

现代 Node.js 的魅力在于它在不断发展的同时保持了向后兼容性。您可以逐步采用这些模式，并且它们可以与现有代码协同工作。无论您是启动新项目还是对现有项目进行现代化改造，这些模式都能为您提供一条清晰的途径，让您轻松实现更稳健、更愉悦的 Node.js 开发体验。

随着我们进入 2025 年，Node.js 将继续发展，但我们在此探索的基础模式为构建在未来几年内保持现代和可维护的应用程序提供了坚实的基础。

参考案例一一列举如下

Modern Package Management and Module Resolution

        - 现在包管理

现代的动态包管理加载

// Load features based on configuration or environment
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(`Database adapter ${dbType} not available, falling back to sqlite`);
    const fallback = await import('#db/adapters/sqlite');
    return fallback.default;
  }
}

// Conditional feature loading
async function loadOptionalFeatures() {
  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 = await import('#features/monitoring');
    features.push(monitoring.default);
  }

  return features;
}

Advanced Streams with Web Standards Integration

        - 集成 web 高级流

现代流处理

import { Readable, Transform } from 'node:stream';
import { pipeline } from 'node:stream/promises';
import { createReadStream, createWriteStream } from 'node:fs';

// Create transform streams with clean, focused logic
const upperCaseTransform = new Transform({
  objectMode: true,
  transform(chunk, encoding, callback) {
    this.push(chunk.toString().toUpperCase());
    callback();
  }
});

// Process files with robust error handling
async function processFile(inputFile, outputFile) {
  try {
    await pipeline(
      createReadStream(inputFile),
      upperCaseTransform,
      createWriteStream(outputFile)
    );
    console.log('File processed successfully');
  } catch (error) {
    console.error('Pipeline failed:', error);
    throw error;
  }
}

web 流互动操作
现代 Node.js 可以无缝地与 Web Streams 协同工作，从而实现与浏览器代码和边缘运行时环境更好的兼容性：

// Create a Web Stream (compatible with browsers)
const webReadable = new ReadableStream({
  start(controller) {
    controller.enqueue('Hello ');
    controller.enqueue('World!');
    controller.close();
  }
});

// Convert between Web Streams and Node.js streams
const nodeStream = Readable.fromWeb(webReadable);
const backToWeb = Readable.toWeb(nodeStream);

Worker Threads: True Parallelism for CPU-Intensive Tasks

        - 工作线程 : CPU密集型任务

Javascript 是单线程模式，对于 CPU 密集型工作任务，工作线程是提升 Javascript 很简单和好用的模式。

无阻塞后台

// worker.js - Isolated computation environment
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 - Non-blocking delegation
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 stopped with exit code ${code}`));
      }
    });
  });
}

// Your main application remains responsive
console.log('Starting calculation...');
const result = await calculateFibonacci(40);
console.log('Fibonacci result:', result);
console.log('Application remained responsive throughout!');

Enhanced Development Experience

        - 增强开发体验

内置环境管理与工作流配置。

{
  "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"
  }
}

The --watch flag eliminates the need for nodemon, while --env-file removes the dependency on dotenv. Your development environment becomes simpler and faster:

--watch 标志消除了对 nodemon 的依赖，而 --env-file 则消除了对 dotenv 的依赖。您的开发环境将变得更简单、更快捷：

// .env file automatically loaded with --env-file
// DATABASE_URL=postgres://localhost:5432/mydb
// API_KEY=secret123

// app.js - Environment variables available immediately
console.log('Connecting to:', process.env.DATABASE_URL);
console.log('API Key loaded:', process.env.API_KEY ? 'Yes' : 'No');

Modern Security and Performance Monitoring

        - 监听、安全

# Run with restricted file system access
node --experimental-permission --allow-fs-read=./data --allow-fs-write=./logs app.js

# Network restrictions 
node --experimental-permission --allow-net=api.example.com app.js
# Above allow-net feature not avaiable yet, PR merged in node.js repo, will be available in future release

Built-in 内置安全监听

import { PerformanceObserver, performance } from 'node:perf_hooks';

// Set up automatic performance monitoring
const obs = new PerformanceObserver((list) => {
  for (const entry of list.getEntries()) {
    if (entry.duration > 100) { // Log slow operations
      console.log(`Slow operation detected: ${entry.name} took ${entry.duration}ms`);
    }
  }
});
obs.observe({ entryTypes: ['function', 'http', 'dns'] });

// Instrument your own operations
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;
}

Application Distribution and Deployment

        - 应用程序分发

单一文件，Node.js 应用绑定单一配置文件。

# Create a self-contained executable
node --experimental-sea-config sea-config.json

配置缺省

{
  "main": "app.js",
  "output": "my-app-bundle.blob",
  "disableExperimentalSEAWarning": true
}

Modern Error Handling and Diagnostics

        - 错误诊断

高级诊断的逻辑

import diagnostics_channel from 'node:diagnostics_channel';

// Create custom diagnostic channels
const dbChannel = diagnostics_channel.channel('app:database');
const httpChannel = diagnostics_channel.channel('app:http');

// Subscribe to diagnostic events
dbChannel.subscribe((message) => {
  console.log('Database operation:', {
    operation: message.operation,
    duration: message.duration,
    query: message.query
  });
});

// Publish diagnostic information
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;
  }
}

后续 四种结构

 2025年现代Node.js开发模式（续） Modern Node.js Patterns for 2025-CSDN博客

来源 From 

Modern Node.js Patterns for 2025https://kashw1n.com/blog/nodejs-2025/