दिलचस्प पोस्ट
इकाई फ़्रेमवर्क कोड प्रथम – डीबीसीटीन्टेक्स्ट पर कोई अलग () विधि नहीं पारदर्शी छवि के लिए सबसे छोटा डेटा यूआरआई छवि क्वेरी सेलेक्टोर और क्वेरीसिक्षक सभी बनाम एलेमेंट्स ByClassName और getElementById जावास्क्रिप्ट में जावास्क्रिप्ट: टैब के बीच डेटा साझा करना Zend डीबी का उपयोग कर एक उपकुंजी लेखन एक असली अपवाद में कैसे तर्क मूल्यों के साथ एक stacktrace प्राप्त करने के लिए JSON में, प्रत्येक नाम का उद्धरण क्यों है? सी में एक स्ट्रिंग पर स्विच करने का सबसे अच्छा तरीका अपाचे द्वारा प्रदत्त पाठ फ़ाइलों के लिए gzip के बजाय deflate का उपयोग क्यों करें? एक द्वितीयक मॉनीटर पर एक विंडोज़ फार्म दिखा रहा है? सरल विकास और तैनाती के लिए आप कैसे कॉन्फ़िगर करते हैं? window.localStorage बनाम chrome.storage.local अस्थायी बिंदु अंकगणित सटीक नतीजे का उत्पादन नहीं करते अजगर पैकेज ऑफ़लाइन स्थापना XmlSerializer का उपयोग करते हुए सीडीएटीए के रूप में आप एक स्ट्रिंग को कैसे सीरियल कर सकते हैं?

कैसे एक HTTP पोस्ट अनुरोध node.js में बनाने के लिए?

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

Solutions Collecting From Web of "कैसे एक HTTP पोस्ट अनुरोध node.js में बनाने के लिए?"

Google Compiler API को POST अनुरोध करने के लिए यहां नोड। जेएस का उपयोग करने का एक उदाहरण है:

 // 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 कमांड का उपयोग करता है, एक सफल पठन के बाद वास्तविक कोड पोस्ट कर रहा है। यदि कोई त्रुटि है, तो इसे फेंक दिया जाता है, और अगर कोई डेटा नहीं है तो विफलता का संकेत देने के लिए प्रक्रिया नकारात्मक मान से निकलती है

यदि आप अनुरोध लाइब्रेरी का उपयोग करते हैं तो यह बहुत आसान हो जाता है।

 var request = require('request'); request.post( 'http://www.yoursite.com/formpage', { json: { key: 'value' } }, function (error, response, body) { if (!error && response.statusCode == 200) { console.log(body) } } ); 

एक अच्छी सिंटैक्स प्रदान करने के अलावा यह जेसन के अनुरोधों को आसान बना देता है, चहचहाना के लिए हस्ताक्षर करता है (टि्वटर आदि के लिए), बहु-भाग के रूपों (जैसे फाइल अपलोड करने के लिए) और स्ट्रीमिंग कर सकता है।

अनुरोध उपयोग कमांड npm install request

आप अनुरोध लाइब्रेरी का उपयोग कर सकते हैं। https://www.npmjs.com/package/request

 var request = require('request'); 

JSON डेटा पोस्ट करने के लिए:

 var myJSONObject = { ... }; request({ url: "http://josiahchoi.com/myjson", method: "POST", json: true, // <--Very important!!! body: myJSONObject }, function (error, response, body){ console.log(response); }); 

XML डेटा पोस्ट करने के लिए:

 var myXMLText = '<xml>...........</xml>' request({ url: "http://josiahchoi.com/myjson", method: "POST", headers: { "content-type": "application/xml", // <--Very important!!! }, body: myXMLText }, function (error, response, body){ console.log(response); }); 

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

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

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

आप कॉन्सेप्ट का समर्थन भी कर सकते हैं, वास्तव में अच्छा और सरल 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(); }); 

आने वाले वर्षों में यहां आने वाले लोगों के लिए अब विभिन्न पुस्तकालयों की एक विस्तृत विविधता है जो इसे न्यूनतम कोडिंग के साथ पूरा कर सकती है। मुझे 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); }); 

अतिरिक्त:
बहुत से लोग भी अनुरोध के उपयोग का सुझाव दे रहे हैं [2]

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

Unirest अनुरोध वस्तु सीधे तक पहुँचने के लिए तरीकों प्रदान करता है

उदाहरण:

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

यह अनुरोध करने के लिए मैं सबसे आसान तरीका है: 'अनुरोध' मॉड्यूल का उपयोग करना।

'अनुरोध' मॉड्यूल स्थापित करने के लिए आदेश:

 $ npm install request 

उदाहरण कोड:

 var request = require('request') var options = { method: 'post', body: postData, // Javascript object json: true, // Use,If you are sending JSON data url: url, headers: { // Specify headers, If any } } request(options, function (err, res, body) { if (err) { console.log('Error :', err) return } console.log(' Body :', body) }); 

अनुरोध करने के लिए आप Node.js के अंतर्निहित 'http' मॉड्यूल का भी उपयोग कर सकते हैं।

मुझे सुपरगीन्ट की सादगी पसंद है ( https://github.com/visionmedia/superagent ) दोनों नोड और ब्राउज़र पर समान एपीआई

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

एनएमएम स्थापित करने के अनुरोध से पहले अपने कंसोल में संकुल की आवश्यकता स्थापित करें –save

 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) } ); 

मुझे एक वीडियो मिला, जो यह कैसे प्राप्त करें: 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); 
 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://img.hiwab.com/http/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); }); 

यह POST और GET लिए मेरा समाधान है

Post विधि के बारे में:

यदि शरीर एक JSON ऑब्जेक्ट है, तो इसे JSON.stringify साथ deserialize करना महत्वपूर्ण है और संभवतः इसके अनुसार Content-Lenght हेडर सेट करें:

  var bodyString=JSON.stringify(body) var _headers = { 'Content-Length': Buffer.byteLength(bodyString) }; 

अनुरोध करने के लिए इसे लिखने से पहले:

 request.write( bodyString ); 

Get और Post दोनों तरीकों के बारे में:

timeout एक socket डिस्कनेक्ट के रूप में हो सकता है, इसलिए आपको इसके हैंडलर की तरह पंजीकरण करना होगा:

 request.on('socket', function (socket) { socket.setTimeout( self.timeout ); socket.on('timeout', function() { request.abort(); if(timeout) return timeout( new Error('request timed out') ); }); }); 

जबकि request हैंडलर है

  request.on('timeout', function () { // Timeout happend. Server received request, but not handled it // (ie doesn't send any response or it took to long). // You don't know what happend. // It will emit 'error' message as well (with ECONNRESET code). req.abort(); if(timeout) return timeout( new Error('request timed out') ); }); 

मैं दृढ़ता से सुझाव देता हूं कि दोनों हैंडलर पंजीकरण करें।

प्रतिक्रिया शरीर का टुकड़ा है, इसलिए आपको data हैंडलर पर विखंडन करना चाहिए:

  var body = ''; response.on('data', function(d) { body += d; }); 

end में body में पूरे प्रतिक्रिया शरीर शामिल होगा:

  response.on('end', function() { try { var jsonResponse=JSON.parse(body); if(success) return success( jsonResponse ); } catch(ex) { // bad json if(error) return error(ex.toString()); } }); 

यह try करने के साथ लपेट करने के लिए सुरक्षित है … JSON.parse the पकड़ो क्योंकि आप यह सुनिश्चित नहीं कर सकते हैं कि यह वास्तव में एक अच्छी तरह से स्वरूपित जेसन है और जिस समय आप अनुरोध करते हैं, उसके बारे में सुनिश्चित करने का कोई तरीका नहीं है।

मॉड्यूल: SimpleAPI

 /** * Simple POST and GET * @author Loreto Parisi (loretoparisi at gmail dot com) */ (function() { var SimpleAPI; SimpleAPI = (function() { var qs = require('querystring'); /** * API Object model * @author Loreto Parisi (loretoparisi at gmail dot com) */ function SimpleAPI(host,port,timeout,ssl,debug,json) { this.host=host; this.port=port; this.timeout=timeout; /** true to use ssl - defaults to true */ this.ssl=ssl || true; /** true to console log */ this.debug=debug; /** true to parse response as json - defaults to true */ this.json= (typeof(json)!='undefined')?json:true; this.requestUrl=''; if(ssl) { // use ssl this.http = require('https'); } else { // go unsafe, debug only please this.http = require('http'); } } /** * HTTP GET * @author Loreto Parisi (loretoparisi at gmail dot com) */ SimpleAPI.prototype.Get = function(path, headers, params, success, error, timeout) { var self=this; if(params) { var queryString=qs.stringify(params); if( queryString ) { path+="?"+queryString; } } var options = { headers : headers, hostname: this.host, path: path, method: 'GET' }; if(this.port && this.port!='80') { // port only if ! 80 options['port']=this.port; } if(self.debug) { console.log( "SimpleAPI.Get", headers, params, options ); } var request=this.http.get(options, function(response) { if(self.debug) { // debug console.log( JSON.stringify(response.headers) ); } // Continuously update stream with data var body = ''; response.on('data', function(d) { body += d; }); response.on('end', function() { try { if(self.json) { var jsonResponse=JSON.parse(body); if(success) return success( jsonResponse ); } else { if(success) return success( body ); } } catch(ex) { // bad json if(error) return error( ex.toString() ); } }); }); request.on('socket', function (socket) { socket.setTimeout( self.timeout ); socket.on('timeout', function() { request.abort(); if(timeout) return timeout( new Error('request timed out') ); }); }); request.on('error', function (e) { // General error, ie // - ECONNRESET - server closed the socket unexpectedly // - ECONNREFUSED - server did not listen // - HPE_INVALID_VERSION // - HPE_INVALID_STATUS // - ... (other HPE_* codes) - server returned garbage console.log(e); if(error) return error(e); }); request.on('timeout', function () { // Timeout happend. Server received request, but not handled it // (ie doesn't send any response or it took to long). // You don't know what happend. // It will emit 'error' message as well (with ECONNRESET code). req.abort(); if(timeout) return timeout( new Error('request timed out') ); }); self.requestUrl = (this.ssl?'https':'http') + '://' + request._headers['host'] + request.path; if(self.debug) { console.log("SimpleAPI.Post",self.requestUrl); } request.end(); } //RequestGet /** * HTTP POST * @author Loreto Parisi (loretoparisi at gmail dot com) */ SimpleAPI.prototype.Post = function(path, headers, params, body, success, error, timeout) { var self=this; if(params) { var queryString=qs.stringify(params); if( queryString ) { path+="?"+queryString; } } var bodyString=JSON.stringify(body) var _headers = { 'Content-Length': Buffer.byteLength(bodyString) }; for (var attrname in headers) { _headers[attrname] = headers[attrname]; } var options = { headers : _headers, hostname: this.host, path: path, method: 'POST', qs : qs.stringify(params) }; if(this.port && this.port!='80') { // port only if ! 80 options['port']=this.port; } if(self.debug) { console.log( "SimpleAPI.Post\n%s\n%s", JSON.stringify(_headers,null,2), JSON.stringify(options,null,2) ); } if(self.debug) { console.log("SimpleAPI.Post body\n%s", JSON.stringify(body,null,2) ); } var request=this.http.request(options, function(response) { if(self.debug) { // debug console.log( JSON.stringify(response.headers) ); } // Continuously update stream with data var body = ''; response.on('data', function(d) { body += d; }); response.on('end', function() { try { console.log("END", body); var jsonResponse=JSON.parse(body); if(success) return success( jsonResponse ); } catch(ex) { // bad json if(error) return error(ex.toString()); } }); }); request.on('socket', function (socket) { socket.setTimeout( self.timeout ); socket.on('timeout', function() { request.abort(); if(timeout) return timeout( new Error('request timed out') ); }); }); request.on('error', function (e) { // General error, ie // - ECONNRESET - server closed the socket unexpectedly // - ECONNREFUSED - server did not listen // - HPE_INVALID_VERSION // - HPE_INVALID_STATUS // - ... (other HPE_* codes) - server returned garbage console.log(e); if(error) return error(e); }); request.on('timeout', function () { // Timeout happend. Server received request, but not handled it // (ie doesn't send any response or it took to long). // You don't know what happend. // It will emit 'error' message as well (with ECONNRESET code). req.abort(); if(timeout) return timeout( new Error('request timed out') ); }); self.requestUrl = (this.ssl?'https':'http') + '://' + request._headers['host'] + request.path; if(self.debug) { console.log("SimpleAPI.Post",self.requestUrl); } request.write( bodyString ); request.end(); } //RequestPost return SimpleAPI; })(); module.exports = SimpleAPI }).call(this); 

उपयोग:

 // Parameters // domain: example.com // ssl:true, port:80 // timeout: 30 secs // debug: true // json response:true var api = new SimpleAPI('posttestserver.com', 80, 1000 * 10, true, true, true); var headers = { 'Content-Type' : 'application/json', 'Accept' : 'application/json' }; var params = { "dir" : "post-test" }; var method = 'post.php'; api.Post(method, headers, params, body , function(response) { // success console.log( response ); } , function(error) { // error console.log( error.toString() ); } , function(error) { // timeout console.log( new Error('timeout error') ); }); 

यदि आप वादा आधारित HTTP क्लाइंट की तलाश में हैं

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

यूआरएल: https://www.npmjs.com/package/axios

पोस्ट को संभालने और मेरे प्रोजेक्ट के लिए अनुरोध प्राप्त करने के लिए निम्न स्तर की उपयोगिता बनाने के बाद बहुत कुछ संघर्ष करने के बाद, मैंने यहां अपना प्रयास पोस्ट करने का निर्णय लिया। स्वीकार किए जाते हैं उत्तर की तर्ज पर, यहां एक 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 }); } 

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

इसे प्राप्त करने का तरीका यहां दिया गया है:

 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; });