Node.js request模块：多POST请求（不同请求体）的正确实现方法

Hey there! Let's break down the best ways to handle multiple POST requests in Node.js, especially since you mentioned your current implementation feels off. First, a critical note: the request module has been deprecated for several years now, so it's strongly recommended to switch to modern, maintained alternatives like axios or Node.js's built-in fetch API (available in v18+). That said, I'll cover solutions for both request (using promises to avoid callback hell) and the newer tools.

为什么你的当前实现可能不合理？ #

Chances are your current code is using nested callbacks (callback hell) which makes it hard to read and maintain, or it's not handling errors properly, or it's firing all requests at once without controlling concurrency (which can get you rate-limited or crash the target server). Let's fix that.

方案1：用Promise封装request模块（兼容旧代码） #

Since request is callback-based by default, we can wrap it in a Promise to use modern async/await syntax. Here's how:

第一步：封装request.post为Promise #

const request = require('request');

const postRequest = (url, body) => {
  return new Promise((resolve, reject) => {
    request.post({
      url: url,
      json: true,
      body: body
    }, (error, response, data) => {
      if (error) {
        reject(error);
      } else if (response.statusCode >= 400) {
        reject(new Error(`Request failed with status ${response.statusCode}: ${JSON.stringify(data)}`));
      } else {
        resolve(data);
      }
    });
  });
};

第二步：批量处理请求 #

假设你有一个请求体数组requestBodies，和目标URL：

const targetUrl = 'https://your-api-endpoint.com/post';
const requestBodies = [
  { id: 1, data: 'foo' },
  { id: 2, data: 'bar' },
  // ... more bodies
];

// 用Promise.all并发处理
async function sendAllRequests() {
  try {
    const results = await Promise.all(
      requestBodies.map(body => postRequest(targetUrl, body))
    );
    console.log('All requests succeeded:', results);
  } catch (error) {
    console.error('At least one request failed:', error);
    // 注意：Promise.all会在第一个失败时终止，如果你想获取所有结果（包括失败），用Promise.allSettled
  }
}

sendAllRequests();

方案2：用axios（推荐，更简洁） #

Axios is promise-based out of the box, has better error handling, and is actively maintained. Here's the same logic with axios:

安装axios #

npm install axios

批量请求代码 #

const axios = require('axios');

const targetUrl = 'https://your-api-endpoint.com/post';
const requestBodies = [
  { id: 1, data: 'foo' },
  { id: 2, data: 'bar' },
  // ... more bodies
];

async function sendAllRequests() {
  try {
    // 映射请求体到axios.post Promise数组
    const requests = requestBodies.map(body => 
      axios.post(targetUrl, body, {
        headers: { 'Content-Type': 'application/json' }
      })
    );

    // 等待所有请求完成
    const responses = await Promise.all(requests);
    const results = responses.map(res => res.data);
    console.log('All requests succeeded:', results);
  } catch (error) {
    console.error('Request failed:', error.response?.data || error.message);
  }
}

sendAllRequests();

方案3：控制并发数（避免限流） #

If you have hundreds of requests, firing them all at once with Promise.all can trigger rate limits or overwhelm the target server. Use a concurrency limiter like p-limit:

安装p-limit #

npm install p-limit

带并发控制的示例 #

const axios = require('axios');
const pLimit = require('p-limit');

// 限制同时最多5个请求
const limit = pLimit(5);

const targetUrl = 'https://your-api-endpoint.com/post';
const requestBodies = [/* ... your large array of bodies ... */];

async function sendAllRequests() {
  // 用limit包装每个请求，控制并发
  const limitedRequests = requestBodies.map(body => 
    limit(() => axios.post(targetUrl, body))
  );

  // 获取所有结果（包括失败）
  const results = await Promise.allSettled(limitedRequests);

  // 处理成功和失败的结果
  results.forEach((result, index) => {
    if (result.status === 'fulfilled') {
      console.log(`Request ${index + 1} succeeded:`, result.value.data);
    } else {
      console.error(`Request ${index + 1} failed:`, result.reason.message);
    }
  });
}

sendAllRequests();

关键注意点 #

• Error Handling: Use Promise.allSettled instead of Promise.all if you want to process all results regardless of failures.
• Concurrency Control: Always limit the number of simultaneous requests if you're sending a large batch—most APIs have rate limits.
• Use Modern Tools: Ditch request for axios or fetch (Node.js 18+) to get better support and cleaner code.

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