Hey there! Let's work through how to properly send an HTTP POST request in Node.js, handle the response, and also cover how to parse incoming POST parameters if you're building a server to receive such requests. I'll adjust your code snippet to make it complete and functional.

Your code already has a good start—let's fill it out and optimize it:

First, note a few key fixes and improvements:

• The & in your post_params is an HTML escape character; replace it with plain &
• Most JSON-RPC services prefer receiving request bodies in JSON format instead of x-www-form-urlencoded, but I'll cover both approaches starting with your original form-based setup.

Complete Client Code #

var http = require("http");

// Your parameters
var email = "email";
var password = '12345';
var response_string='010000000157065146a6b32b224b87d47c1b0283b1ae2fa5bd4f9af9ebc45928110f87fbae00000000700';
// Fix escape characters and encode special values
var post_params = "jsonrpc=1.0&id=curltest&method=decoderawtransaction&params=" + encodeURIComponent(response_string);

// Request configuration
var options = {
  host: "127.0.0.1",
  port: "8332",
  path: "/path",
  method: "POST",
  headers: {
    // Required headers for form-data POST requests
    "Content-Type": "application/x-www-form-urlencoded",
    "Content-Length": Buffer.byteLength(post_params),
    // Add Basic Auth if your target service requires it (common for Bitcoin RPC)
    "Authorization": "Basic " + Buffer.from(email + ":" + password).toString("base64")
  }
};

// Send the request
var req = http.request(options, (res) => {
  let responseData = '';

  // Collect response chunks as they arrive
  res.on('data', (chunk) => {
    responseData += chunk;
  });

  // Process the full response once it's received
  res.on('end', () => {
    console.log('Raw Response:', responseData);
    // Parse JSON if the response is in JSON format (standard for JSON-RPC)
    try {
      const parsedResult = JSON.parse(responseData);
      console.log('Parsed JSON Result:', parsedResult);
    } catch (err) {
      console.error('Failed to parse JSON:', err);
    }
  });
});

// Handle request errors
req.on('error', (e) => {
  console.error('Request Error:', e.message);
});

// Write the POST data and finalize the request
req.write(post_params);
req.end();

Key Notes: #

• We added critical request headers: Content-Type tells the server what format we're sending, and Content-Length lets it know how much data to expect.
• encodeURIComponent() ensures special characters in response_string don't break parameter parsing.
• Basic Auth is included here since services like Bitcoin Core RPC require it—adjust the credentials as needed.
• We collect response chunks incrementally (since data can arrive in pieces) and parse the final result as JSON if applicable.

JSON-Format JSON-RPC Request (More Standard) #

If your target service accepts JSON bodies (most JSON-RPC implementations do), use this instead:

// Build a JSON request body
var postData = JSON.stringify({
  jsonrpc: "1.0",
  id: "curltest",
  method: "decoderawtransaction",
  params: [response_string] // JSON-RPC params are typically an array
});

var options = {
  // ... keep other options the same
  headers: {
    "Content-Type": "application/json",
    "Content-Length": Buffer.byteLength(postData),
    "Authorization": "Basic " + Buffer.from(email + ":" + password).toString("base64")
  }
};

// Send the JSON data
req.write(postData);

If you're building a Node.js server to receive POST requests like the one above, here's how to parse incoming parameters:

var http = require("http");
var querystring = require("querystring"); // For parsing form-data

const server = http.createServer((req, res) => {
  // Only handle POST requests to your target path
  if (req.method === 'POST' && req.url === '/path') {
    let requestBody = '';

    // Collect the incoming request body chunks
    req.on('data', (chunk) => {
      requestBody += chunk;
    });

    // Process the full request body once it's received
    req.on('end', () => {
      // Parse form-urlencoded parameters
      const postParams = querystring.parse(requestBody);
      console.log('Parsed POST Parameters:', postParams);
      // Access individual parameters
      console.log('Requested Method:', postParams.method);
      console.log('Params Value:', postParams.params);

      // Send a response back to the client
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ status: 'success', received: postParams }));
    });
  } else {
    // Handle non-POST or invalid path requests
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('Not Found');
  }
});

// Start the server
server.listen(8332, '127.0.0.1', () => {
  console.log('Server running on http://127.0.0.1:8332');
});

Key Notes: #

• Use querystring.parse() to parse x-www-form-urlencoded request bodies.
• If receiving JSON bodies, parse the request body with JSON.parse(requestBody) instead.
• Always wait for the end event to process the request body—data can arrive in multiple chunks, so you need to assemble it first.

That covers both sending POST requests as a client and parsing them as a server!

内容的提问来源于stack exchange，提问作者coin-o-pedia c