Kaip padaryti HTTP POST užklausą node.js?

Kaip galiu pateikti išeinančią HTTP POST užklausą su duomenimis node.js?

796
28 мая '11 в 3:44 2011-05-28 03:44 Ženklas yra nustatytas gegužės 28 d., 11 val., 03:44, 2011-05-28 03:44
ответ 21 atsakymas

Čia pateikiamas pavyzdys, kaip naudoti „Google“ kompiliatoriui „POST API“ užklausą „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 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 data before we post it if(data) { PostCode(data); } else { console.log("No data to post"); process.exit(-1); } }); 

Atnaujinau kodą, kad galėčiau parodyti, kaip siųsti duomenis iš failo, o ne standžiai koduotą eilutę. Norėdami pasiekti šį tikslą, naudokite fs.readFile async fs.readFile , po sėkmingo skaitymo fs.readFile faktinį kodą. Jei yra klaida, jis išmestas, o jei duomenų nėra, procesas baigiamas neigiama verte, rodančia gedimą.

750
28 мая '11 в 3:50 2011-05-28 03:50 atsakymas pateikiamas gegužės 28 d., 11 d., 3:50, 2011-05-28 03:50

Tai tampa daug lengviau, jei naudojate užklausos biblioteką.

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

Be gero sintaksės, jis supaprastina „Json“ užklausas, tvarko „oauth“ parašą („Twitter“ ir kt.), Gali atlikti daugiapartines formas (pavyzdžiui, atsisiųsti failus) ir transliuoti.

Jei norite įdiegti užklausą, naudokite komandą npm install request .

986
21 окт. Jed Watson atsakymas, spalio 21 d 2012-10-21 18:57 '12, 18:57, 2012-10-21 18:57

Galite naudoti užklausos biblioteką. https://www.npmjs.com/package/request

 var request = require('request'); 

Skelbti JSON duomenis:

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

Skelbti XML duomenis:

 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); }); 
120
03 февр. Atsakymą pateikė Josiah Choi, vasario 03 d. 2015-02-03 13:57 '15, 13:57 2015-02-03 13:57

Naudoju Restler ir Needle gamybai. Jie yra daug galingesni nei vietinis httprequest. Galite paprašyti pagrindinio autentifikavimo, specialaus antraštės įrašo arba netgi įkelti / atsisiųsti failus.

Kalbant apie operaciją „post / get“, jie taip pat yra daug lengviau naudoti nei „raw“ laiko skambučiai, naudojant httprequest.

 needle.post('https://my.app.com/endpoint', {foo:'bar'}, function(err, resp, body){ console.log(body); }); 
39
08 марта '13 в 22:07 2013-03-08 22:07 atsakymą pateikė Grant Li kovo 8 d. 13 d. 22:07 2013-03-08 22:07

Taip pat galite naudoti „ Requestify“ , tikrai vėsią ir paprastą HTTP klientą, kurį parašiau „nodeJS +“, jis palaiko talpyklą.

Tiesiog atlikite šiuos veiksmus:

  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(); }); 
18
18 июля '13 в 21:15 2013-07-18 21:15 atsakymas duotas ranm8, liepos 18 d. 13, 21:15 2013-07-18 21:15

Tiems, kurie ateina čia ateinančiais metais. Šiuo metu yra daug skirtingų bibliotekų, kurios gali tai padaryti su minimaliu kodavimu. Norėčiau, kad HTTP užklausoms būtų teikiamos elegantiškos lengvos bibliotekos, nebent reikia kontroliuoti žemo lygio HTTP failus.

Viena iš tokių bibliotekų yra Unirest

Norėdami ją įdiegti, naudokite npm .
$ npm install unirest

Ir Hello, World! pavyzdys Hello, World! į kuriuos visi yra įpratę.

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


Neprivaloma:
Daugelis žmonių taip pat siūlo naudoti užklausą [2]

Verta pažymėti, kad request biblioteka naudojama už Unirest scenų.

„Unirest“ pateikia metodus, kaip tiesiogiai pasiekti užklausos objektą.

Pavyzdys:

 var Request = unirest.get('http://mockbin.com/request'); 
16
12 мая '15 в 23:05 2015-05-12 23:05 atsakymą pateikė Levi Roberts gegužės 12 d., 15 val., 15:05 val. 2015-05-12 23:05

Tai paprasčiausias būdas naudoti užklausai: naudojant „užklausos“ modulį.

Komanda įdiegti modulio „užklausą“:

 $ npm install request 

Kodo pavyzdys:

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

Be to, galite naudoti „Node.js“ integruotą „http“ modulį.

13
11 янв. Atsakymą pateikė Piyush Sagar sausio 11 d. 2016-01-11 14:48 '16 at 14:48 pm 2016-01-11 14:48

Paprasta ir ne priklausomybė. Naudoja pažadą, kad galėtumėte laukti rezultatų. Ji grąžina atsakymo įstaigą ir nekontroliuoja atsakymo būsenos kodo.

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

Naudoti:

 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', }) }) 
12
16 июня '18 в 23:04 2018-06-16 23:04 Atsakymą pateikė „ mpen “ birželio 16 d. 18 val. 11.44 2018-06-16 23:04
 var https = require('https');  // 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); }); 
12
11 марта '17 в 20:35 2017-03-11 20:35 Giulio Roggero atsakymas kovo 17 d. 17 d. 20:35 2017-03-11 20:35

Man patinka super agento paprastumas ( https://github.com/visionmedia/superagent ). Tas pats api abiejuose mazguose ir naršyklėje.

2018: neseniai persijungiau į mazgų atsiuntimą ( https://www.npmjs.com/package/node-fetch ).

11
31 янв. Atsakymą pateikė Pascal Belloncle, sausio 31 d 2013-01-31 03:44 '13, 03:44 2013-01-31 03:44

Siųsti atsakymą į JSON įrašą / užklausą
Mes galime naudoti užklausų paketą ir išsaugoti vertes, kurias turime siųsti „Json“ kintamajame.

Pirmiausia įdiegti reikalingą paketą konsolėje diegimo užklausai npm - 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+ " " method:"POST", json:true},function(error,response,body){ console.log(body) } ); 
6
19 февр. Atsakymas pateikiamas Prakhar Sharma 19 vasario mėn 2015-02-19 11:45 '15 at 11:45 2015-02-19 11:45

Radau vaizdo įrašą, paaiškinantį, kaip tai padaryti: https://www.youtube.com/watch?v=nuw48-u3Yrg

Jis naudoja numatytąjį „http“ modulį su „querystring“ ir „stringbuilder“ moduliais. Programa priima du numerius (naudodama du teksto laukus) iš tinklalapio ir po siuntimo grąžina šių dviejų sumų kiekį (kartu įrašant reikšmes teksto laukeliuose). Tai geriausias pavyzdys, kurį galėčiau rasti bet kur kitur.

 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"); 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"); 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); 
5
07 авг. atsakymas pateikiamas user203687 07 rug . 2015-08-07 05:59 '15 , 5:59 val. 2015-08-07 05:59

Jei ieškote HTTP prašymų, pagrįstų pažadais, axios atlieka savo darbą gražiai.

  const axios = require('axios'); axios.post('/user', { firstName: 'Fred', lastName: 'Flintstone' }) .then(function (response) { console.log(response); }) .catch(function (error) { console.log(error); }); 
5
18 окт. atsakymas suteiktas Pujan Srivastava 18 okt. 2017-10-18 02:45 '17, 02:45, 2017-10-18 02:45

Tai mano sprendimas POST ir GET .

Apie POST metodą:

Jei kūnas yra JSON objektas, svarbu, kad jis būtų panaikintas naudojant JSON.stringify ir galbūt atitinkamai nustatykite Content-Lenght JSON.stringify antraštę:

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

prieš rašydamas į užklausą:

 request.write( bodyString ); 

Apie GET ir POST metodus:

timeout gali būti atliekamas kaip socket atjungimas, todėl turite užregistruoti savo tvarkyklę, pavyzdžiui:

 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 tvarkytojas

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

Labai rekomenduoju registruoti abu tvarkytojus.

Atsakymo įstaiga yra sugadinta, todėl turite atlikti gabalus data tvarkyklėje:

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

Galutinėje body bus visas atsakymo tekstas:

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

Tai saugu suvynioti try ... sugauti JSON.parse`, nes jūs negalite būti tikri, kad tai yra gerai suformatuotas „Json“, ir nėra jokio būdo įsitikinti, kad tai yra laikas, kai pateikiate užklausą.

Modulis: SimpleAPI

  (function() { var SimpleAPI; SimpleAPI = (function() { var qs = require('querystring');  function SimpleAPI(host,port,timeout,ssl,debug,json) { this.host=host; this.port=port; this.timeout=timeout;  this.ssl=ssl || true;  this.debug=debug;  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'); } }  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  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); 

Taikymas:

 // 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') ); }); 
3
05 мая '16 в 19:15 2016-05-05 19:15 atsakymą pateikė loretoparisi gegužės 05 d. 16, 19:15 2016-05-05 19:15

Po daugelio problemų, sukuriančių žemo lygio įrankį, skirtą apdoroti pranešimą ir gauti prašymus dėl mano projekto, nusprendžiau skelbti savo pastangas. Daugelis, remiantis gautu atsakymu, čia yra HTTP užklausų ir https POST kūrimo fragmentas JSON duomenų siuntimui.

 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 }); } 
3
21 сент. atsakymas pateikiamas daugeliui 21 sep . 2017-09-21 11:30 '17 11:30 val. 2017-09-21 11:30

Skelbti kitą ašinio pavyzdžio užklausą - „axios.post“, kuriame naudojami išplėstiniai konfigūracijos parametrai ir pasirinktinės antraštės.

2
27 янв. Matthew Rideout atsakymas 27 Jan 2018-01-27 22:44 '18, 10:44 val. 2018-01-27 22:44
 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); }); 

Arba galite naudoti šią biblioteką:

 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); 
1
20 нояб. Atsakymą pateikė Jitendra virani lapkričio 20 d 2018-11-20 10:08 '18, 10:08, 2018-11-20 10:08

Procesą galite supaprastinti naudodami užklausą „“:

Štai kaip tai gauti:

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

Ir siųsdami užklausą Jsonui:

1
30 марта '16 в 18:35 2016-03-30 18:35 atsakymas duotas „ Yoni“ kovo 30 d., 16 val. 18:35 2016-03-30 18:35

Bandžiau skambinti naudodamas pašto operatorių, ir jis pavertė visus jam pateiktus duomenis, kad būtų pateiktas kodas node.js [užklausa, gimtoji, unirest]

0
30 нояб. atsakymas duotas priyanka 30 nov. 2018-11-30 20:13 '18, 8:13 pm 2018-11-30 20:13

Užklausos priklausomybės naudojimas.

Paprastas sprendimas:

  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) } }); 
0
20 февр. atsakymas pateikiamas ngCourse 20 vas . 2018-02-20 14:54 '18, 14:54 val. 2018-02-20 14:54

Request-Promise suteikia atsakymą, pagrįstą pažadu. Http atsakymo kodai, išskyrus 2xx, lems pažadą. Tai galima perrašyti nustatant options.simple = false

 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... }); 
0
24 янв. atsakymą pateikė veeresh yh 24 Jan 2019-01-24 08:47 '19, 08:47 2019-01-24 08:47

Kiti klausimai apie žymes arba Užduoti klausimą