Node.js में HTTP POST अनुरोध कैसे करें?




httprequest (12)

Axios.post अनुरोध का एक और अक्षीय उदाहरण पोस्ट करना जो अतिरिक्त कॉन्फ़िगरेशन विकल्प और कस्टम शीर्षलेख का उपयोग करता है।

var postData = {
  email: "[email protected]",
  password: "password"
};

let axiosConfig = {
  headers: {
      'Content-Type': 'application/json;charset=UTF-8',
      "Access-Control-Allow-Origin": "*",
  }
};

axios.post('http://<host>:<port>/<path>', postData, axiosConfig)
.then((res) => {
  console.log("RESPONSE RECEIVED: ", res);
})
.catch((err) => {
  console.log("AXIOS ERROR: ", err);
})

मैं node.js में डेटा के साथ आउटबाउंड HTTP पोस्ट अनुरोध कैसे कर सकता हूं?


Google Compiler API पर POST अनुरोध करने के लिए node.js का उपयोग करने का एक उदाहरण यहां दिया गया है:

// We need this to build our post string
var querystring = require('querystring');
var http = require('http');
var fs = require('fs');

function PostCode(codestring) {
  // Build the post string from an object
  var post_data = querystring.stringify({
      'compilation_level' : 'ADVANCED_OPTIMIZATIONS',
      'output_format': 'json',
      'output_info': 'compiled_code',
        'warning_level' : 'QUIET',
        'js_code' : codestring
  });

  // An object of options to indicate where to post to
  var post_options = {
      host: 'closure-compiler.appspot.com',
      port: '80',
      path: '/compile',
      method: 'POST',
      headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
          'Content-Length': Buffer.byteLength(post_data)
      }
  };

  // Set up the request
  var post_req = http.request(post_options, function(res) {
      res.setEncoding('utf8');
      res.on('data', function (chunk) {
          console.log('Response: ' + chunk);
      });
  });

  // post the data
  post_req.write(post_data);
  post_req.end();

}

// This is an async file read
fs.readFile('LinkedList.js', 'utf-8', function (err, data) {
  if (err) {
    // If this were just a small part of the application, you would
    // want to handle this differently, maybe throwing an exception
    // for the caller to handle. Since the file is absolutely essential
    // to the program's functionality, we're going to exit with a fatal
    // error instead.
    console.log("FATAL An error occurred trying to read in the file: " + err);
    process.exit(-2);
  }
  // Make sure there's data before we post it
  if(data) {
    PostCode(data);
  }
  else {
    console.log("No data to post");
    process.exit(-1);
  }
});

मैंने हार्डकोडेड स्ट्रिंग के बजाय फ़ाइल से डेटा पोस्ट करने का तरीका दिखाने के लिए कोड अपडेट किया है। यह सफल पढ़ने के बाद वास्तविक कोड पोस्ट करने, इसे प्राप्त करने के लिए async fs.readFile कमांड का उपयोग करता है। यदि कोई त्रुटि है, तो इसे फेंक दिया जाता है, और यदि कोई डेटा नहीं है तो प्रक्रिया विफलता को इंगित करने के लिए नकारात्मक मान से निकलती है।


आप " Requestify " का उपयोग कर procice को सरल बना सकते हैं:

यहां यह कैसे प्राप्त करें:

var requestify = require('requestify'); 

अनुरोध प्राप्त करना:

requestify.get('http://example.com').then(function(response) {
    // Get the response body
    response.getBody();
});

और जेसन में अनुरोध पोस्ट कर रहा है:

requestify.post('http://example.com', {
        hello: 'world'
    })
    .then(function(response) {
        // Get the response body (JSON parsed or jQuery object for XMLs)
        response.getBody();

        // Get the raw response body
        response.body;
    });

आप Requestify का भी उपयोग कर सकते हैं, वास्तव में एक अच्छा और सरल HTTP क्लाइंट जिसे मैंने नोडजेएस + के लिए लिखा था, यह कैशिंग का समर्थन करता है।

बस निम्नलिखित करें:

    var requestify = require('requestify');

    requestify.post('http://example.com', {
        hello: 'world'
    })
    .then(function(response) {
        // Get the response body (JSON parsed or jQuery object for XMLs)
        response.getBody();
    });

पद को संभालने और मेरे प्रोजेक्ट के लिए अनुरोध प्राप्त करने के लिए निम्न स्तर की उपयोगिता बनाने के दौरान बहुत संघर्ष करने के बाद, मैंने यहां अपना प्रयास पोस्ट करने का फैसला किया। स्वीकृत उत्तर की पंक्तियों पर बहुत अधिक, यहां JSON डेटा भेजने के लिए http और https POST अनुरोध करने के लिए एक स्निपेट है।

const http = require("http")
const https = require("https")

// Request handler function
let postJSON = (options, postData, callback) => {

    // Serializing JSON
    post_data = JSON.stringify(postData)

    let port = options.port == 443 ? https : http

    // Callback function for the request
    let req = port.request(options, (res) => {
        let output = ''
        res.setEncoding('utf8')

        // Listener to receive data
        res.on('data', (chunk) => {
            output += chunk
        });

        // Listener for intializing callback after receiving complete response
        res.on('end', () => {
            let obj = JSON.parse(output)
            callback(res.statusCode, obj)
        });
    });

   // Handle any errors occurred while making request
    req.on('error', (err) => {
        //res.send('error: ' + err.message)
    });

    // Request is made here, with data as string or buffer
    req.write(post_data)
    // Ending the request
    req.end()
};

let callPost = () => {

    let data = {
        'name': 'Jon',
        'message': 'hello, world'
    }

    let options = {
        host: 'domain.name',       // Your domain name
        port: 443,                 // 443 for https and 80 for http
        path: '/path/to/resource', // Path for the request
        method: 'POST',            
        headers: {
            'Content-Type': 'application/json',
            'Content-Length': Buffer.byteLength(data)
        }
    }

    postJSON(options, data, (statusCode, result) => {
        // Handle response
        // Process the received data
    });

}

बाद के वर्षों में आने वाले लोगों के लिए। अब विभिन्न पुस्तकालयों की एक विस्तृत विविधता है जो इसे न्यूनतम कोडिंग के साथ पूरा कर सकती हैं। मैं HTTP अनुरोधों के लिए सुरुचिपूर्ण हल्के वजन पुस्तकालयों को पसंद करता हूं जब तक आपको बिल्कुल निम्न स्तर की HTTP सामग्री पर नियंत्रण की आवश्यकता न हो।

ऐसी एक पुस्तकालय Unirest

इसे स्थापित करने के लिए, npm उपयोग करें।
$ npm install unirest

और Hello, World! उदाहरण है कि हर कोई आदी है।

var unirest = require('unirest');

unirest.post('http://example.com/helloworld')
.header('Accept', 'application/json')
.send({ "Hello": "World!" })
.end(function (response) {
  console.log(response.body);
});


अतिरिक्त:
बहुत से लोग request के उपयोग का भी सुझाव दे रहे हैं https://www.npmjs.com/package/request

यह ध्यान देने योग्य होना चाहिए कि दृश्यों के पीछे Unirest request पुस्तकालय का उपयोग करता है।

Unirest अनुरोध ऑब्जेक्ट को सीधे एक्सेस करने के तरीकों को प्रदान करता है।

उदाहरण:

var Request = unirest.get('http://mockbin.com/request');

मुझे एक वीडियो मिला जो इस बारे में बताता है कि इसे कैसे प्राप्त किया जाए: https://www.youtube.com/watch?v=nuw48-u3Yrg

यह "querystring" और "stringbuilder" मॉड्यूल के साथ डिफ़ॉल्ट "http" मॉड्यूल का उपयोग करता है। एप्लिकेशन को वेब पेज से दो नंबर (दो टेक्स्टबॉक्स का उपयोग करके) लेते हैं और सबमिट पर, उन दोनों का योग देता है (टेक्स्टबॉक्स में मानों को बनाए रखने के साथ)। यह सबसे अच्छा उदाहरण है जिसे मैं कहीं और पा सकता हूं।

var http = require("http");
var qs = require("querystring");
var StringBuilder = require("stringbuilder");

var port = 9000;

function getCalcHtml(req, resp, data) {
    var sb = new StringBuilder({ newline: "\r\n" });
    sb.appendLine("<html>");
    sb.appendLine(" <body>");
    sb.appendLine("     <form method='post'>");
    sb.appendLine("         <table>");
    sb.appendLine("             <tr>");
    sb.appendLine("                 <td>Enter First No: </td>");

    if (data && data.txtFirstNo) {
        sb.appendLine("                 <td><input type='text' id='txtFirstNo' name='txtFirstNo' value='{0}'/></td>", data.txtFirstNo);
    }
    else {
        sb.appendLine("                 <td><input type='text' id='txtFirstNo' name='txtFirstNo' /></td>");
    }

    sb.appendLine("             </tr>");
    sb.appendLine("             <tr>");
    sb.appendLine("                 <td>Enter Second No: </td>");

    if (data && data.txtSecondNo) {
        sb.appendLine("                 <td><input type='text' id='txtSecondNo' name='txtSecondNo' value='{0}'/></td>", data.txtSecondNo);
    }
    else {
        sb.appendLine("                 <td><input type='text' id='txtSecondNo' name='txtSecondNo' /></td>");
    }

    sb.appendLine("             </tr>");
    sb.appendLine("             <tr>");
    sb.appendLine("                 <td><input type='submit' value='Calculate' /></td>");
    sb.appendLine("             </tr>");

    if (data && data.txtFirstNo && data.txtSecondNo) {
        var sum = parseInt(data.txtFirstNo) + parseInt(data.txtSecondNo);
        sb.appendLine("             <tr>");
        sb.appendLine("                 <td>Sum: {0}</td>", sum);
        sb.appendLine("             </tr>");
    }

    sb.appendLine("         </table>");
    sb.appendLine("     </form>")
    sb.appendLine(" </body>");
    sb.appendLine("</html>");
    sb.build(function (err, result) {
        resp.write(result);
        resp.end();
    });
}

function getCalcForm(req, resp, data) {
    resp.writeHead(200, { "Content-Type": "text/html" });
    getCalcHtml(req, resp, data);
}

function getHome(req, resp) {
    resp.writeHead(200, { "Content-Type": "text/html" });
    resp.write("<html><html><head><title>Home</title></head><body>Want to some calculation? Click <a href='/calc'>here</a></body></html>");
    resp.end();
}

function get404(req, resp) {
    resp.writeHead(404, "Resource Not Found", { "Content-Type": "text/html" });
    resp.write("<html><html><head><title>404</title></head><body>404: Resource not found. Go to <a href='/'>Home</a></body></html>");
    resp.end();
}

function get405(req, resp) {
    resp.writeHead(405, "Method not supported", { "Content-Type": "text/html" });
    resp.write("<html><html><head><title>405</title></head><body>405: Method not supported</body></html>");
    resp.end();
}

http.createServer(function (req, resp) {
    switch (req.method) {
        case "GET":
            if (req.url === "/") {
                getHome(req, resp);
            }
            else if (req.url === "/calc") {
                getCalcForm(req, resp);
            }
            else {
                get404(req, resp);
            }
            break;
        case "POST":
            if (req.url === "/calc") {
                var reqBody = '';
                req.on('data', function (data) {
                    reqBody += data;
                    if (reqBody.length > 1e7) { //10MB
                        resp.writeHead(413, 'Request Entity Too Large', { 'Content-Type': 'text/html' });
                        resp.end('<!doctype html><html><head><title>413</title></head><body>413: Request Entity Too Large</body></html>');
                    }
                });
                req.on('end', function () {
                    var formData = qs.parse(reqBody);
                    getCalcForm(req, resp, formData);
                });
            }
            else {
                get404(req, resp);
            }
            break;
        default:
            get405(req, resp);
            break;
    }
}).listen(port);

मैं उत्पादन प्रयोजनों के लिए Restler और Needle उपयोग करता Restler । वे मूल httprequest की तुलना में अधिक शक्तिशाली हैं। बुनियादी प्रमाणीकरण, विशेष शीर्षलेख प्रविष्टि या यहां तक ​​कि अपलोड / डाउनलोड फ़ाइलों के साथ अनुरोध करना संभव है।

पोस्ट / ऑपरेशन के लिए, वे httprequest का उपयोग करके कच्चे AJAX कॉल की तुलना में उपयोग करने के लिए बहुत आसान हैं।

needle.post('https://my.app.com/endpoint', {foo:'bar'}, 
    function(err, resp, body){
        console.log(body);
});

यदि आप वादे आधारित HTTP अनुरोधों की तलाश में हैं, तो axios काम अच्छी तरह से करता है।

  const axios = require('axios');

  axios.post('/user', {
    firstName: 'Fred',
    lastName: 'Flintstone'
  })
  .then(function (response) {
    console.log(response);
  })
  .catch(function (error) {
    console.log(error);
  });

सरल समाधान:

 var data = {
        "host":"127.1.1.1",
        "port":9008
    }

request.post( baseUrl + '/peers/connect',
        {
            json: data,  // your payload data placed here
            headers: {
                'X-Api-Key': 'dajzmj6gfuzmbfnhamsbuxivc', // if authentication needed
                'Content-Type': 'application/json' 
            }
        }, function (error, response, body) {
            if (error) {
                callback(error, null)
            } else {
                callback(error, response.body)
            }
        });

बाकी / JSON अनुरोध पोस्ट करने के लिए
हम केवल अनुरोध पैकेज का उपयोग कर सकते हैं और जेसन वैरिएबल में हमें भेजे जाने वाले मानों को सहेज सकते हैं।

सबसे पहले अपने कंसोल में आवश्यक पैरामीटर को एनपीएम इंस्टॉल अनुरोध - सेव द्वारा स्थापित करें

var request = require('request');

    var options={
                'key':'28',
                'key1':'value',
                'key2':'value'
                }

    request({
             url:"http://dev.api.ean.com/ean-services/rs/hotel/v3/ping?                      
                 minorRev="+options.key+
                 "&cid="+options.key1+
                 "&apiKey="+options.key2,
             method:"POST",
             json:true},function(error,response,body){
                     console.log(body)
               }
    );

var https = require('https');


/**
 * HOW TO Make an HTTP Call - POST
 */
// do a POST request
// create the JSON object
jsonObject = JSON.stringify({
    "message" : "The web of things is approaching, let do some tests to be ready!",
    "name" : "Test message posted with node.js",
    "caption" : "Some tests with node.js",
    "link" : "http://www.youscada.com",
    "description" : "this is a description",
    "picture" : "http://youscada.com/wp-content/uploads/2012/05/logo2.png",
    "actions" : [ {
        "name" : "youSCADA",
        "link" : "http://www.youscada.com"
    } ]
});

// prepare the header
var postheaders = {
    'Content-Type' : 'application/json',
    'Content-Length' : Buffer.byteLength(jsonObject, 'utf8')
};

// the post options
var optionspost = {
    host : 'graph.facebook.com',
    port : 443,
    path : '/youscada/feed?access_token=your_api_key',
    method : 'POST',
    headers : postheaders
};

console.info('Options prepared:');
console.info(optionspost);
console.info('Do the POST call');

// do the POST call
var reqPost = https.request(optionspost, function(res) {
    console.log("statusCode: ", res.statusCode);
    // uncomment it for header details
//  console.log("headers: ", res.headers);

    res.on('data', function(d) {
        console.info('POST result:\n');
        process.stdout.write(d);
        console.info('\n\nPOST completed');
    });
});

// write the json data
reqPost.write(jsonObject);
reqPost.end();
reqPost.on('error', function(e) {
    console.error(e);
});




httprequest