Back to Details

async-patterns

Compare original and translation side by side

🇺🇸

Original

English
🇨🇳

Translation

Chinese

Async Programming Patterns Skill

异步编程模式技能

Master asynchronous programming - the foundation of Node.js performance and scalability.
掌握异步编程——这是Node.js性能与可扩展性的基础。

Quick Start

快速入门

Three pillars of async JavaScript:
  1. Callbacks - Traditional pattern (error-first)
  2. Promises - Modern chainable pattern
  3. Async/Await - Synchronous-looking async code
JavaScript异步编程的三大支柱：
  1. Callbacks（回调函数） - 传统模式（错误优先）
  2. Promises - 现代链式模式
  3. Async/Await - 类同步的异步代码

Core Patterns

核心模式

Callbacks → Promises → Async/Await Evolution

回调函数 → Promises → Async/Await 的演进

javascript
// 1. Callbacks (old way)
fs.readFile('file.txt', (err, data) => {
  if (err) throw err;
  console.log(data);
});

// 2. Promises (better)
fs.promises.readFile('file.txt')
  .then(data => console.log(data))
  .catch(err => console.error(err));

// 3. Async/Await (modern)
async function readFile() {
  try {
    const data = await fs.promises.readFile('file.txt');
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}
javascript
// 1. Callbacks (old way)
fs.readFile('file.txt', (err, data) => {
  if (err) throw err;
  console.log(data);
});

// 2. Promises (better)
fs.promises.readFile('file.txt')
  .then(data => console.log(data))
  .catch(err => console.error(err));

// 3. Async/Await (modern)
async function readFile() {
  try {
    const data = await fs.promises.readFile('file.txt');
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}

Sequential vs Parallel

串行 vs 并行

javascript
// ❌ Slow: Sequential (300ms total)
async function slow() {
  const a = await fetch('/api/a'); // 100ms
  const b = await fetch('/api/b'); // 100ms
  const c = await fetch('/api/c'); // 100ms
  return [a, b, c];
}

// ✅ Fast: Parallel (100ms total)
async function fast() {
  const [a, b, c] = await Promise.all([
    fetch('/api/a'),
    fetch('/api/b'),
    fetch('/api/c')
  ]);
  return [a, b, c];
}
javascript
// ❌ Slow: Sequential (300ms total)
async function slow() {
  const a = await fetch('/api/a'); // 100ms
  const b = await fetch('/api/b'); // 100ms
  const c = await fetch('/api/c'); // 100ms
  return [a, b, c];
}

// ✅ Fast: Parallel (100ms total)
async function fast() {
  const [a, b, c] = await Promise.all([
    fetch('/api/a'),
    fetch('/api/b'),
    fetch('/api/c')
  ]);
  return [a, b, c];
}

Promise Methods

Promise 方法

javascript
// Promise.all - Wait for all (fails if one fails)
const [users, posts] = await Promise.all([getUsers(), getPosts()]);

// Promise.allSettled - Wait for all (never fails)
const results = await Promise.allSettled([fetch1(), fetch2(), fetch3()]);

// Promise.race - First to complete
const fastest = await Promise.race([server1(), server2()]);

// Promise.any - First to succeed
const result = await Promise.any([tryAPI1(), tryAPI2()]);
javascript
// Promise.all - Wait for all (fails if one fails)
const [users, posts] = await Promise.all([getUsers(), getPosts()]);

// Promise.allSettled - Wait for all (never fails)
const results = await Promise.allSettled([fetch1(), fetch2(), fetch3()]);

// Promise.race - First to complete
const fastest = await Promise.race([server1(), server2()]);

// Promise.any - First to succeed
const result = await Promise.any([tryAPI1(), tryAPI2()]);

Learning Path

学习路径

Beginner (1-2 weeks)

入门阶段（1-2周）

  • ✅ Understand event loop
  • ✅ Master callbacks
  • ✅ Learn Promises basics
  • ✅ Practice async/await
  • ✅ 理解事件循环
  • ✅ 掌握回调函数
  • ✅ 学习Promises基础
  • ✅ 练习使用async/await

Intermediate (3-4 weeks)

进阶阶段（3-4周）

  • ✅ Error handling patterns
  • ✅ Sequential vs parallel execution
  • ✅ Promise composition
  • ✅ Event emitters
  • ✅ 错误处理模式
  • ✅ 串行与并行执行
  • ✅ Promise组合
  • ✅ 事件发射器

Advanced (5-6 weeks)

高级阶段（5-6周）

  • ✅ Streams and backpressure
  • ✅ Concurrency control
  • ✅ Circuit breakers
  • ✅ Performance optimization
  • ✅ 流与背压
  • ✅ 并发控制
  • ✅ 断路器模式
  • ✅ 性能优化

Common Patterns

常见模式

Error Handling

错误处理

javascript
// Try/catch for async/await
async function safeOperation() {
  try {
    const result = await riskyOperation();
    return { success: true, data: result };
  } catch (error) {
    console.error('Operation failed:', error);
    return { success: false, error: error.message };
  }
}

// Process-level handlers
process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled Rejection:', reason);
});
javascript
// Try/catch for async/await
async function safeOperation() {
  try {
    const result = await riskyOperation();
    return { success: true, data: result };
  } catch (error) {
    console.error('Operation failed:', error);
    return { success: false, error: error.message };
  }
}

// Process-level handlers
process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled Rejection:', reason);
});

Retry with Exponential Backoff

指数退避重试

javascript
async function retryWithBackoff(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      const delay = Math.pow(2, i) * 1000;
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}
javascript
async function retryWithBackoff(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      const delay = Math.pow(2, i) * 1000;
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

Concurrency Limit

并发限制

javascript
async function batchProcess(items, concurrency = 5) {
  const results = [];
  for (let i = 0; i < items.length; i += concurrency) {
    const batch = items.slice(i, i + concurrency);
    const batchResults = await Promise.all(
      batch.map(item => processItem(item))
    );
    results.push(...batchResults);
  }
  return results;
}
javascript
async function batchProcess(items, concurrency = 5) {
  const results = [];
  for (let i = 0; i < items.length; i += concurrency) {
    const batch = items.slice(i, i + concurrency);
    const batchResults = await Promise.all(
      batch.map(item => processItem(item))
    );
    results.push(...batchResults);
  }
  return results;
}

Streams

流

javascript
const { pipeline } = require('stream');
const fs = require('fs');

// Efficient file processing
pipeline(
  fs.createReadStream('input.txt'),
  transformStream,
  fs.createWriteStream('output.txt'),
  (err) => {
    if (err) console.error('Pipeline failed:', err);
    else console.log('Pipeline succeeded');
  }
);
javascript
const { pipeline } = require('stream');
const fs = require('fs');

// Efficient file processing
pipeline(
  fs.createReadStream('input.txt'),
  transformStream,
  fs.createWriteStream('output.txt'),
  (err) => {
    if (err) console.error('Pipeline failed:', err);
    else console.log('Pipeline succeeded');
  }
);

Event Emitters

事件发射器

javascript
const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}
const emitter = new MyEmitter();

emitter.on('event', (data) => {
  console.log('Event fired:', data);
});

emitter.emit('event', { id: 123 });
javascript
const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}
const emitter = new MyEmitter();

emitter.on('event', (data) => {
  console.log('Event fired:', data);
});

emitter.emit('event', { id: 123 });

When to Use

适用场景

Use async patterns when:
  • Handling I/O operations (file, network, database)
  • Building scalable Node.js applications
  • Managing multiple concurrent operations
  • Processing streams of data
  • Creating event-driven architectures
在以下场景使用异步模式：
  • 处理I/O操作（文件、网络、数据库）
  • 构建可扩展的Node.js应用
  • 管理多个并发操作
  • 处理数据流
  • 创建事件驱动架构

Related Skills

相关技能

  • Express REST API (async route handlers)
  • Database Integration (async queries)
  • Testing & Debugging (test async code)
  • Performance Optimization (async performance)
  • Express REST API（异步路由处理器）
  • 数据库集成（异步查询）
  • 测试与调试（测试异步代码）
  • 性能优化（异步性能）

Resources

参考资源