如何在Node-Express中链式调用Promise并装饰API返回对象？

Hey there! Let's break this down step by step so you can wrap your head around Promise chaining and decorating objects with data from multiple APIs in your Node-Express project. I'll start with the basics, then jump into concrete code examples that match your use case.

First, a Quick Promise Primer (No Jargon!) #

Think of a Promise as a "placeholder" for an asynchronous task that will eventually finish (either successfully or fail). When it succeeds, it resolves with a value; when it fails, it rejects with an error. The .then() method lets you handle the successful result, and you can chain multiple .then()s to sequence async tasks.

Let's Build Your Solution #

Let’s assume your existing "get Item" code looks something like this (I’ll use a simulated API call for clarity—you can swap this with your real API request later):

// Mock: First API that fetches basic Item data
function getItem(itemId) {
  return new Promise((resolve, reject) => {
    // In your project, this would be an actual API call (e.g., axios.get)
    setTimeout(() => {
      resolve({
        id: itemId,
        name: "Vintage Camera",
        price: 149.99
      });
    }, 800);
  });
}

Now, let’s add a second function to fetch the description and address from your other API:

// Mock: Second API that fetches Item details
function getItemDetails(itemId) {
  return new Promise((resolve, reject) => {
    // Again, replace with your real API call here
    setTimeout(() => {
      resolve({
        description: "1980s film camera with manual focus and light meter",
        address: "456 Retro Lane, Brooklyn, NY"
      });
    }, 600);
  });
}

Chaining Promises to Decorate the Object #

The goal is to:

1. Fetch the basic Item data first
2. Use that Item’s ID to fetch the details
3. Merge the two datasets into one decorated object

Here’s how to do this with Promise chaining in an Express route:

const express = require('express');
const app = express();

// ... (include the getItem and getItemDetails functions above)

app.get('/items/:id', (req, res) => {
  const itemId = req.params.id;

  getItem(itemId)
    // First: Handle the basic Item data
    .then(baseItem => {
      // Now call the second API, and return a new Promise that resolves with the merged object
      return getItemDetails(itemId).then(details => {
        // Merge the base item with the details (two easy ways to do this)
        // Option 1: Spread operator (cleanest)
        return { ...baseItem, ...details };
        // Option 2: Object.assign
        // return Object.assign({}, baseItem, details);
      });
    })
    // Second: Handle the decorated object and send it to the client
    .then(decoratedItem => {
      res.json(decoratedItem);
    })
    // Catch ANY errors that happen in the entire chain
    .catch(error => {
      console.error('Something went wrong:', error);
      res.status(500).json({ error: 'Failed to load item data' });
    });
});

app.listen(3000, () => console.log('Server running on port 3000'));

Even Cleaner: Use Async/Await (Promise Syntax Sugar) #

If you find chaining .then()s hard to read, async/await is a friendlier way to write the same logic—it makes async code look like sync code:

app.get('/items/:id', async (req, res) => {
  try {
    const itemId = req.params.id;
    // Wait for the first API to resolve
    const baseItem = await getItem(itemId);
    // Wait for the second API to resolve
    const details = await getItemDetails(itemId);
    // Merge and send
    const decoratedItem = { ...baseItem, ...details };
    res.json(decoratedItem);
  } catch (error) {
    console.error('Something went wrong:', error);
    res.status(500).json({ error: 'Failed to load item data' });
  }
});

Key Takeaways #

• Promise Chaining: Each .then() receives the result of the previous Promise, and can return a new Promise to keep the chain going.
• Object Merging: The spread operator ({...a, ...b}) or Object.assign lets you combine two objects into one without mutating the original.
• Error Handling: Always include a .catch() (or try/catch for async/await) to handle failures in any part of your async workflow—this prevents your Express server from crashing.

内容的提问来源于stack exchange，提问作者Adrián E.