如何将request.post改造为async/await模式？附示例代码求助

Absolutely! You can absolutely apply the same async/await pattern to request.post calls—this approach works consistently across all HTTP methods when using a promise-compatible HTTP client. Let’s walk through how to do this properly, with examples aligned to your existing request.get async setup.

First, A Quick Check: Promise-Compatibility #

The native request library uses callbacks by default, so if you already converted request.get to async/await, you’re probably using a promise-wrapped version like request-promise or request-promise-native, or you’ve used util.promisify to wrap the callback-based methods. Either way, the same logic applies to POST requests.

Example: Callback-Based request.post → Async/Await #

Original Callback Style #

request.post({
  url: "https://api.yourservice.com/submit",
  form: { username: "jdoe", email: "jdoe@example.com" }
}, (error, response, body) => {
  if (error) {
    console.error("Post failed:", error);
    return;
  }
  console.log("Success! Response:", body);
});

Async/Await Version (Using request-promise-native) #

const rp = require("request-promise-native");

async function submitUserData() {
  try {
    const requestOptions = {
      method: "POST",
      uri: "https://api.yourservice.com/submit",
      form: { username: "jdoe", email: "jdoe@example.com" },
      json: true // Automatically parses JSON responses (saves you JSON.parse(body))
    };

    const response = await rp(requestOptions);
    console.log("Post successful! Response:", response);
  } catch (error) {
    console.error("Post request failed:", error.message);
    // Handle HTTP-specific errors (e.g., 404, 500)
    if (error.statusCode) {
      console.error("HTTP Status Code:", error.statusCode);
    }
  }
}

// Execute the async function
submitUserData();

If You’re Using Native request + util.promisify #

If you haven’t switched to a promise-based request library, you can wrap request.post with Node.js’s built-in util.promisify:

const request = require("request");
const { promisify } = require("util");

// Wrap request.post to return a promise
const postAsync = promisify(request.post);

async function submitUserData() {
  try {
    const { body } = await postAsync({
      url: "https://api.yourservice.com/submit",
      form: { username: "jdoe", email: "jdoe@example.com" }
    });
    // Manually parse JSON if needed
    const parsedResponse = JSON.parse(body);
    console.log("Success!", parsedResponse);
  } catch (error) {
    console.error("Post failed:", error);
  }
}

submitUserData();

Key Best Practices to Follow #

• Always Use try/catch: Async/await converts asynchronous errors into synchronous-style exceptions, so wrapping your await calls in try/catch ensures you don’t get unhandled promise rejections.
• Reuse Configuration Patterns: Your existing request.get async setup’s structure (like handling options, response parsing) can be mirrored exactly for POST—just update the method and add request body parameters (e.g., form, json, body).
• Consider Modern Alternatives: Note that the original request library is no longer maintained. For new projects, tools like axios or node-fetch are native promise/async-await compatible and more actively supported—but for maintaining existing code, the above approach works perfectly.

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