मैं डेटा के साथ, नोड.जेएस में एक आउटबाउंड HTTP पोस्ट अनुरोध कैसे बना सकता हूं?
node-fetch
जो fetch
HTTP अनुरोध करने के लिए देशी जावास्क्रिप्ट पद्धति का कार्यान्वयन है ।
मैं डेटा के साथ, नोड.जेएस में एक आउटबाउंड HTTP पोस्ट अनुरोध कैसे बना सकता हूं?
node-fetch
जो fetch
HTTP अनुरोध करने के लिए देशी जावास्क्रिप्ट पद्धति का कार्यान्वयन है ।
जवाबों:
Google कंपाइलर 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);
}
});
मैंने कोड को अपडेट किया है कि हार्डकोड स्ट्रिंग के बजाय किसी फ़ाइल से डेटा कैसे पोस्ट किया जाए, यह दिखाने के लिए। इसे fs.readFile
प्राप्त करने के लिए यह async कमांड का उपयोग करता है , एक सफल पढ़ने के बाद वास्तविक कोड को पोस्ट करना। यदि कोई त्रुटि है, तो इसे फेंक दिया जाता है, और यदि कोई डेटा नहीं है तो प्रक्रिया विफलता को इंगित करने के लिए एक नकारात्मक मान के साथ बाहर निकलती है।
querystring.stringify()
नेस्टेड ऑब्जेक्ट का समर्थन नहीं करता है , इसलिए आप qs.stringify()
इसके बजाय उपयोग करना चाह सकते हैं ।
Content-Length
बाइट्स और जरूरी नहीं कि स्ट्रिंग लेंथ (UTF-16 आदि) हो। उपयोग Buffer.byteLength(data)
करना हमेशा सही होगा।
querystring.stringify
आपके स्वयं के डेटा ऑब्जेक्ट होना चाहिए, न कि इस उत्तर में प्रदर्शित रद्दी (जो फ़ाइल आधारित ऑब्जेक्ट के लिए उपयोगी हो सकता है?)। मैं उम्र के लिए उस पर अटक गया था ... stackoverflow.com/questions/9768192/… ने मेरा पूरा समाधान उपलब्ध कराया
यदि आप अनुरोध लायब्रेरी का उपयोग करते हैं तो यह बहुत आसान हो जाता है ।
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);
}
}
);
एक अच्छा सिंटैक्स प्रदान करने के अलावा, यह json अनुरोधों को आसान बनाता है, oauth हस्ताक्षर (ट्विटर, आदि के लिए) को संभालता है, बहु-भाग प्रपत्र (जैसे फाइलें अपलोड करने के लिए) और स्ट्रीमिंग कर सकता है।
अनुरोध उपयोग आदेश को स्थापित करने के लिए 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);
});
मैं उत्पादन उद्देश्यों के लिए रेस्लर और सुई का उपयोग करता हूं । वे देशी निंदकों की तुलना में बहुत अधिक शक्तिशाली हैं। मूल प्रमाणीकरण, विशेष हेडर प्रविष्टि या यहां तक कि अपलोड / डाउनलोड फ़ाइलों के साथ अनुरोध करना संभव है।
पोस्ट / ऑपरेशन के लिए के रूप में, वे भी स्पष्ट ajax कॉल की तुलना में उपयोग करने के लिए अधिक सरल हैं।
needle.post('https://my.app.com/endpoint', {foo:'bar'},
function(err, resp, body){
console.log(body);
});
सरल और निर्भरता से मुक्त। एक वादा का उपयोग करता है ताकि आप परिणाम का इंतजार कर सकें। यह प्रतिक्रिया निकाय देता है और प्रतिक्रिया स्थिति कोड की जाँच नहीं करता है।
const https = require('https');
function httpsPost({body, ...options}) {
return new Promise((resolve,reject) => {
const req = https.request({
method: 'POST',
...options,
}, res => {
const chunks = [];
res.on('data', data => chunks.push(data))
res.on('end', () => {
let body = Buffer.concat(chunks);
switch(res.headers['content-type']) {
case 'application/json':
body = JSON.parse(body);
break;
}
resolve(body)
})
})
req.on('error',reject);
if(body) {
req.write(body);
}
req.end();
})
}
उपयोग:
const res = await httpsPost({
hostname: 'sentry.io',
path: `/api/0/organizations/org/releases/${changesetId}/deploys/`,
headers: {
'Authorization': `Bearer ${process.env.SENTRY_AUTH_TOKEN}`,
'Content-Type': 'application/json',
},
body: JSON.stringify({
environment: isLive ? 'production' : 'demo',
})
})
write
पद्धति पर req,write()
प्रयोग किया जाता है?
तुम भी उपयोग कर सकते हैं Requestify , एक बहुत शांत और सरल HTTP ग्राहक मैं NodeJS के लिए लिखा था + यह कैशिंग का समर्थन करता है।
बस निम्नलिखित करें:
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();
});
अद्यतन 2020:
मैं वास्तव में फ़िन का आनंद ले रहा हूं - अल्ट्रा-लाइटवेट Node.js HTTP क्लाइंट
इसे दो अलग-अलग तरीकों से इस्तेमाल किया जा सकता है। एक वादे के साथ (Async / Await) और दूसरा पारंपरिक कॉलबैक शैलियों के साथ।
इसके माध्यम से स्थापित करें: npm i phin
इसके साथ सीधे इसे पढ़ें await
:
const p = require('phin')
await p({
url: 'https://ethanent.me',
method: 'POST',
data: {
hey: 'hi'
}
})
अप्रकाशित (कॉलबैक) शैली:
const p = require('phin').unpromisified
p('https://ethanent.me', (err, res) => {
if (!err) console.log(res.body)
})
के रूप में 2015 वहाँ अब विभिन्न पुस्तकालयों कि कम से कम कोडिंग के साथ ऐसा कर सकते हैं की एक विस्तृत विविधता है। जब तक आपको बिल्कुल निम्न स्तर के 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');
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);
});
दर्जनों ओपन-सोर्स लाइब्रेरी उपलब्ध हैं जिनका उपयोग आप नोड में HTTP POST अनुरोध करने के लिए कर सकते हैं।
const axios = require('axios');
const data = {
name: 'John Doe',
job: 'Content Writer'
};
axios.post('https://reqres.in/api/users', data)
.then((res) => {
console.log(`Status: ${res.status}`);
console.log('Body: ', res.data);
}).catch((err) => {
console.error(err);
});
const needle = require('needle');
const data = {
name: 'John Doe',
job: 'Content Writer'
};
needle('post', 'https://reqres.in/api/users', data, {json: true})
.then((res) => {
console.log(`Status: ${res.statusCode}`);
console.log('Body: ', res.body);
}).catch((err) => {
console.error(err);
});
const request = require('request');
const options = {
url: 'https://reqres.in/api/users',
json: true,
body: {
name: 'John Doe',
job: 'Content Writer'
}
};
request.post(options, (err, res, body) => {
if (err) {
return console.log(err);
}
console.log(`Status: ${res.statusCode}`);
console.log(body);
});
const https = require('https');
const data = JSON.stringify({
name: 'John Doe',
job: 'Content Writer'
});
const options = {
hostname: 'reqres.in',
path: '/api/users',
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Content-Length': data.length
}
};
const req = https.request(options, (res) => {
let data = '';
console.log('Status Code:', res.statusCode);
res.on('data', (chunk) => {
data += chunk;
});
res.on('end', () => {
console.log('Body: ', JSON.parse(data));
});
}).on("error", (err) => {
console.log("Error: ", err.message);
});
req.write(data);
req.end();
विवरण के लिए, इस लेख को देखें ।
यह सबसे सरल तरीका है जिसका मैं अनुरोध करने के लिए उपयोग करता हूं: 'अनुरोध' मॉड्यूल का उपयोग करना।
'अनुरोध' मॉड्यूल स्थापित करने की कमान:
$ 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 ) की सादगी पसंद है । नोड और ब्राउज़र दोनों पर समान एपीआई।
;(async function() {
var response = await superagent.post('http://127.0.0.1:8125/', {age: 2})
console.log(response)
})
नोड-भ्रूण ( https://www.npmjs.com/package/node-fetch ) भी है, जिसमें एक एपीआई है जो fetch
ब्राउज़र से मेल खाता है - हालांकि इसके लिए मैन्युअल क्वेरी स्ट्रिंग एन्कोडिंग की आवश्यकता होती है, स्वचालित रूप से सामग्री प्रकारों को संभाल नहीं करता है, या तो किसी भी अन्य काम की अतिशयोक्ति करता है।
यदि आप HTTP आधारित वादे की तलाश कर रहे हैं, तो axios अच्छी तरह से अपना काम करता है।
const axios = require('axios');
axios.post('/user', {firstName: 'Fred',lastName: 'Flintstone'})
.then((response) => console.log(response))
.catch((error) => console.log(error));
या
await axios.post('/user', {firstName: 'Fred',lastName: 'Flintstone'})
आराम / JSON अनुरोध पोस्ट करने के लिए
हम केवल अनुरोध पैकेज का उपयोग कर सकते हैं और उन मूल्यों को बचा सकते हैं जिन्हें हमें Json वेरिएबल में भेजना है।
पहले अपने कंसोल में आवश्यक पैकेज npm स्थापित अनुरोध द्वारा स्थापित करें - सेव करें
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
यह डिफॉल्ट "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);
के लिए यह मेरा समाधान POST
और GET
।
Post
विधि के बारे में :
यदि शरीर एक JSON ऑब्जेक्ट है, तो यह महत्वपूर्ण है कि इसे इसके साथ जोड़ा जाए JSON.stringify
और संभवतः 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
// (i.e. 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
... the
JSON.parse पकड़ें क्योंकि आप यह सुनिश्चित नहीं कर सकते हैं कि यह वास्तव में एक अच्छी तरह से स्वरूपित जसन है और जब आप अनुरोध करते हैं, तो इसके बारे में सुनिश्चित होने का कोई तरीका नहीं है।
मापांक: 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, i.e.
// - 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
// (i.e. 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, i.e.
// - 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
// (i.e. 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') );
});
पद को संभालने और अपनी परियोजना के लिए अनुरोध प्राप्त करने के लिए एक निम्न स्तर की उपयोगिता बनाते हुए बहुत संघर्ष करने के बाद, मैंने अपना प्रयास यहाँ पोस्ट करने का निर्णय लिया। स्वीकृत उत्तर की तर्ज पर, यहाँ 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
});
}
let request = require('request');
let jsonObj = {};
request({
url: "https://myapii.com/sendJsonData",
method: "POST",
json: true,
body: jsonObj
}, function (error, resp, body){
console.log(resp);
});
या आप इस पुस्तकालय का उपयोग कर सकते हैं:
let axios = require("axios");
let jsonObj = {};
const myJsonAPI = axios.create({
baseURL: 'https://myapii.com',
timeout: 120*1000
});
let response = await myJsonAPI.post("sendJsonData",jsonobj).catch(e=>{
res.json(e);
});
console.log(response);
request
पुस्तकालय को हटा दिया गया है।
Axios ब्राउज़र और Node.js. के लिए एक HTTP आधारित वादा है। एक्सियोस ने आरईएस एंडपॉइंट्स के अतुल्यकालिक HTTP अनुरोध भेजना और सीआरयूडी संचालन करना आसान बना दिया है। इसका उपयोग सादे जावास्क्रिप्ट में या Vue या React जैसे पुस्तकालय के साथ किया जा सकता है।
const axios = require('axios');
var dataToPost = {
email: "your email",
password: "your password"
};
let axiosConfiguration = {
headers: {
'Content-Type': 'application/json;charset=UTF-8',
"Access-Control-Allow-Origin": "*",
}
};
axios.post('endpoint or url', dataToPost, axiosConfiguration)
.then((res) => {
console.log("Response: ", res);
})
.catch((err) => {
console.log("error: ", err);
})
एक axios.post अनुरोध का एक और अक्षीय उदाहरण पोस्ट करना जो अतिरिक्त कॉन्फ़िगरेशन विकल्प और कस्टम हेडर का उपयोग करता है।
var postData = {
email: "test@test.com",
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);
})
अनुरोध निर्भरता का उपयोग करके ।
सरल समाधान:
import request from 'request'
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)
}
});
request
से आता है
Request-Promise
वादा आधारित प्रतिक्रिया प्रदान करता है। 2xx के अलावा http प्रतिक्रिया कोड अस्वीकार किए जाने के वादे का कारण बनेगा। यह विकल्प सेट करके ओवरराइट किया जा सकता है। सरल = गलत
var options = {
method: 'POST',
uri: 'http://api.posttestserver.com/post',
body: {
some: 'payload'
},
json: true // Automatically stringifies the body to JSON
};
rp(options)
.then(function (parsedBody) {
// POST succeeded...
})
.catch(function (err) {
// POST failed...
});