知了是什么意思

Always handle promise rejections using try/catch or .catch() to prevent unhandled rejections; 2. Use Promise.allSettled() for independent operations to ensure all promises settle regardless of rejection; 3. Implement centralized error handling with higher-order functions like asyncHandler in Express to route errors to middleware; 4. Enforce timeouts on async operations using Promise.race() or AbortController to avoid indefinite hanging; 5. Monitor unhandled rejections via process.on('unhandledRejection') in Node.js as a safety net; 6. Apply retry logic with exponential backoff for transient failures, ensuring operations are idempotent—these techniques collectively enhance resilience in async JavaScript applications by proactively managing errors and enabling recovery.

Handling errors in asynchronous JavaScript is more complex than in synchronous code because errors don’t propagate up the call stack in the same predictable way. Without proper strategies, unhandled rejections can crash your application or lead to silent failures. Here are key advanced error handling techniques to manage async operations effectively.

1. Always Handle Promise Rejections

Every Promise must be either awaited with a try/catch block or have a .catch() handler. Ignoring this leads to unhandled rejections, which may terminate Node.js processes in future versions.

// ? Risky: Unhandled rejection
async function riskyOperation() {
  const result = await fetch('/api/data');
  return result.json();
}

riskyOperation(); // No error handling!

// ? Correct: Handle the error
async function safeOperation() {
  try {
    const response = await fetch('/api/data');
    if (!response.ok) throw new Error(`HTTP ${response.status}`);
    return await response.json();
  } catch (err) {
    console.error('Fetch failed:', err.message);
    // Optionally rethrow or return a fallback
    throw err; // or return { error: true }
  }
}

2. Use Promise.allSettled for Independent Operations

When running multiple independent async tasks, use Promise.allSettled() instead of Promise.all(). The latter fails fast — one rejection cancels the whole batch. allSettled waits for all to complete and gives you control over which succeeded or failed.

const promises = [
  fetch('/api/user'),
  fetch('/api/settings'),
  fetch('/api/analytics')
];

const results = await Promise.allSettled(promises);

results.forEach((result, index) => {
  if (result.status === 'fulfilled') {
    console.log(`Request ${index} succeeded:`, result.value);
  } else {
    console.warn(`Request ${index} failed:`, result.reason);
  }
});

This is especially useful for analytics, logging, or non-critical background tasks.

3. Centralized Error Handling with Higher-Order Functions

Wrap async route handlers or event callbacks in a reusable wrapper to avoid repeating try/catch blocks.

function asyncHandler(fn) {
  return (req, res, next) =>
    Promise.resolve(fn(req, res, next)).catch(next);
}

// Usage in Express
app.get('/data', asyncHandler(async (req, res) => {
  const data = await db.query('SELECT * FROM users');
  res.json(data);
}));

Now all uncaught errors in async handlers go to Express’s error middleware:

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: 'Something went wrong!' });
});

4. Timeout Unresponsive Promises

Async operations like network requests can hang indefinitely. Use Promise.race() to enforce timeouts.

function withTimeout(promise, ms) {
  const timeout = new Promise((_, reject) =>
    setTimeout(() => reject(new Error(`Timeout after ${ms}ms`)), ms)
  );
  return Promise.race([promise, timeout]);
}

// Usage
try {
  const data = await withTimeout(fetch('/api/slow'), 5000);
} catch (err) {
  console.log('Request failed or timed out:', err.message);
}

For more control, consider using AbortController with fetch:

const controller = new AbortController();
const timeout = setTimeout(() => controller.abort(), 5000);

try {
  const response = await fetch('/api/data', { signal: controller.signal });
  const data = await response.json();
} catch (err) {
  if (err.name === 'AbortError') {
    console.log('Request was aborted');
  } else {
    console.error('Fetch error:', err);
  }
} finally {
  clearTimeout(timeout);
}

5. Avoid Unhandled Rejection Events (But Monitor Them)

Even with careful coding, unhandled rejections may occur. In Node.js, listen for unhandledRejection to log and debug:

process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
  // In production: log to error tracking service
});

In modern environments, this is a last resort — aim to handle all rejections explicitly.

6. Retry Failed Async Operations Gracefully

For transient failures (network blips, rate limits), implement retry logic with exponential backoff.

async function retryAsync(fn, retries = 3, delay = 1000) {
  for (let i = 0; i < retries; i  ) {
    try {
      return await fn();
    } catch (err) {
      if (i === retries - 1) throw err;
      console.log(`Attempt ${i   1} failed. Retrying in ${delay}ms...`);
      await new Promise(resolve => setTimeout(resolve, delay));
      delay *= 2; // Exponential backoff
    }
  }
}

// Usage
try {
  const data = await retryAsync(() => fetch('/api/reliable').then(r => r.json()));
} catch (err) {
  console.error('All retries failed:', err);
}

Be cautious with side effects — only retry idempotent operations.

These strategies help you build more resilient async JavaScript applications. The key is being proactive: handle every Promise, isolate failures, and design for recovery. Most bugs in async code stem from ignored edge cases — solid error handling turns those into manageable conditions.

The above is the detailed content of Advanced Error Handling Strategies in Asynchronous JavaScript. For more information, please follow other related articles on the PHP Chinese website!