如何从Node.js http(s)请求提取数据并在请求作用域外获取？

Hey Vince, let's tackle your two Node.js HTTP/HTTPS questions head-on. I know you checked that existing SO thread and found it unhelpful (since it relied on a third-party library that changes the response object entirely), so I'll stick strictly to the native http and https modules here—no external dependencies needed.

The native http.get() and https.get() methods work with streams, which means you can't just grab the response body directly from the returned object. Instead, you need to listen for the data and end events to collect and process the full response:

const https = require('https');

https.get('https://api.example.com/data', (res) => {
  let rawResponse = '';

  // Collect chunks of data as they come in
  res.on('data', (chunk) => {
    rawResponse += chunk;
  });

  // Once the stream ends, process the full data
  res.on('end', () => {
    try {
      // If the response is JSON, parse it
      const parsedData = JSON.parse(rawResponse);
      console.log('Extracted data:', parsedData);
    } catch (error) {
      console.error('Failed to parse response:', error.message);
    }
  });
}).on('error', (error) => {
  console.error('Request failed:', error.message);
});

A quick note: The res parameter here is an IncomingMessage object—a readable stream. You have to assemble the chunks manually because the response is sent in pieces over the network.

I get why you tried using await directly—async/await makes async code feel synchronous—but the problem is https.get() doesn't return a Promise by default. It returns a ClientRequest object instead. To fix this, wrap the request in a Promise so you can use await and access the data outside the request's callback scope:

const https = require('https');

// Wrap https.get in a reusable Promise function
function fetchExternalData(url) {
  return new Promise((resolve, reject) => {
    https.get(url, (res) => {
      let rawResponse = '';

      res.on('data', (chunk) => {
        rawResponse += chunk;
      });

      res.on('end', () => {
        try {
          const parsedData = JSON.parse(rawResponse);
          resolve(parsedData); // Pass the data to the Promise's resolve handler
        } catch (error) {
          reject(new Error(`Parsing error: ${error.message}`));
        }
      });
    }).on('error', (error) => {
      reject(new Error(`Request error: ${error.message}`));
    });
  });
}

// Now you can access the data outside the request scope using async/await
async function processData() {
  try {
    const externalData = await fetchExternalData('https://api.example.com/data');
    // Use the data anywhere in this function (or pass it to other functions)
    console.log('Data outside request scope:', externalData);
    doSomethingWithData(externalData);
  } catch (error) {
    console.error(error);
  }
}

function doSomethingWithData(data) {
  // Example function to use the data elsewhere
  console.log('Processing data:', data);
}

processData();

By wrapping the request in a Promise, you're able to "carry" the response data out of the request's callback scope. The resolve() method passes the parsed data to the await call, making it accessible in the processData() function (and any other functions you pass it to).

内容的提问来源于stack exchange，提问作者Vince