Como posso fazer uma solicitação HTTP POST de saída, com dados, no node.js?
node-fetch
uma implementação do fetch
método JavaScript nativo para fazer solicitações HTTP.
Como posso fazer uma solicitação HTTP POST de saída, com dados, no node.js?
node-fetch
uma implementação do fetch
método JavaScript nativo para fazer solicitações HTTP.
Respostas:
Aqui está um exemplo do uso do node.js para fazer uma solicitação POST à API do Google Compiler:
// 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);
}
});
Atualizei o código para mostrar como postar dados de um arquivo, em vez da string codificada. Ele usa o fs.readFile
comando async para conseguir isso, publicando o código real após uma leitura bem-sucedida. Se houver um erro, ele será lançado e, se não houver dados, o processo será encerrado com um valor negativo para indicar falha.
querystring.stringify()
não suporta objetos aninhados , portanto, você pode usar qs.stringify()
.
Content-Length
são bytes e não necessariamente o comprimento da string (UTF-16 etc). O uso Buffer.byteLength(data)
sempre estará correto.
querystring.stringify
deve ser seu próprio objeto de dados, não o lixo eletrônico exibido nesta resposta (que pode ser útil para objetos baseados em arquivo?). Eu estava preso em que para as idades ... stackoverflow.com/questions/9768192/... desde a minha solução completa
Isso fica muito mais fácil se você usar a biblioteca de solicitações .
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);
}
}
);
Além de fornecer uma sintaxe agradável, facilita as solicitações de json, lida com a assinatura do oauth (para twitter, etc.), pode fazer formulários com várias partes (por exemplo, para upload de arquivos) e streaming.
Para instalar o pedido, use o comando npm install request
Você pode usar a biblioteca de solicitações. https://www.npmjs.com/package/request
var request = require('request');
Para postar dados JSON:
var myJSONObject = { ... };
request({
url: "http://josiahchoi.com/myjson",
method: "POST",
json: true, // <--Very important!!!
body: myJSONObject
}, function (error, response, body){
console.log(response);
});
Para postar dados 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);
});
Uso Restler e Needle para fins de produção. Ambos são muito mais poderosos que a solicitação de ativação nativa. É possível solicitar com autenticação básica, entrada de cabeçalho especial ou até mesmo upload / download de arquivos.
Quanto à operação post / get, eles também são muito mais simples de usar do que chamadas ajax brutas usando o enableprequest.
needle.post('https://my.app.com/endpoint', {foo:'bar'},
function(err, resp, body){
console.log(body);
});
Simples e sem dependência. Usa uma promessa para que você possa aguardar o resultado. Ele retorna o corpo da resposta e não verifica o código de status da resposta.
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();
})
}
Uso:
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
método req,write()
?
Você também pode usar o Requestify , um cliente HTTP muito legal e simples que escrevi para o nodeJS +, que suporta cache.
Faça o seguinte:
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();
});
Atualização 2020:
Estou gostando muito do phin - o cliente HTTP ultra-leve do Node.js.
Pode ser usado de duas maneiras diferentes. Um com promessas (Async / Await) e outro com estilos tradicionais de retorno de chamada.
Instalar via: npm i phin
Diretamente do README com await
:
const p = require('phin')
await p({
url: 'https://ethanent.me',
method: 'POST',
data: {
hey: 'hi'
}
})
Estilo não autorizado (retorno de chamada):
const p = require('phin').unpromisified
p('https://ethanent.me', (err, res) => {
if (!err) console.log(res.body)
})
A partir de 2015 , agora existe uma grande variedade de bibliotecas diferentes que podem fazer isso com o mínimo de codificação. Eu prefiro bibliotecas leves e elegantes para solicitações HTTP, a menos que você precise absolutamente do controle do material HTTP de baixo nível.
Uma dessas bibliotecas é a Unirest
Para instalá-lo, use npm
.
$ npm install unirest
E no Hello, World!
exemplo que todos estão acostumados.
var unirest = require('unirest');
unirest.post('http://example.com/helloworld')
.header('Accept', 'application/json')
.send({ "Hello": "World!" })
.end(function (response) {
console.log(response.body);
});
Extra:
muitas pessoas também estão sugerindo o uso de solicitação [2]
Vale a pena notar que nos bastidores Unirest
usa a request
biblioteca.
O Unirest fornece métodos para acessar o objeto de solicitação diretamente.
Exemplo:
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);
});
Existem dezenas de bibliotecas de código aberto disponíveis que você pode usar para fazer uma solicitação HTTP POST no Nó.
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();
Para detalhes, consulte este artigo .
Esta é a maneira mais simples que eu uso para fazer request: usando o módulo 'request'.
Comando para instalar o módulo 'request':
$ npm install request
Código de exemplo:
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)
});
Você também pode usar o módulo 'http' interno do Node.js. para fazer uma solicitação.
Eu gosto da simplicidade do superagent ( https://github.com/visionmedia/superagent ). A mesma API no nó e no navegador.
;(async function() {
var response = await superagent.post('http://127.0.0.1:8125/', {age: 2})
console.log(response)
})
Também há busca de nó ( https://www.npmjs.com/package/node-fetch ), que possui uma API que corresponde fetch
aos navegadores - no entanto, isso requer codificação manual de cadeias de consulta, não manipula automaticamente tipos de conteúdo ou assim, qualquer outro superagente de trabalho faz.
Se você está procurando solicitações HTTP baseadas em promessas, o axios faz seu trabalho bem.
const axios = require('axios');
axios.post('/user', {firstName: 'Fred',lastName: 'Flintstone'})
.then((response) => console.log(response))
.catch((error) => console.log(error));
OU
await axios.post('/user', {firstName: 'Fred',lastName: 'Flintstone'})
Para postar solicitação de descanso / JSON
Podemos simplesmente usar o pacote de solicitação e salvar os valores que temos para enviar na variável Json.
Primeiro instale o pacote require no seu console por npm install request --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)
}
);
Encontrei um vídeo que explica como conseguir isso: https://www.youtube.com/watch?v=nuw48-u3Yrg
Ele usa o módulo "http" padrão juntamente com os módulos "querystring" e "stringbuilder". O aplicativo pega dois números (usando duas caixas de texto) de uma página da web e, após o envio, retorna a soma desses dois (juntamente com a persistência dos valores nas caixas de texto). Este é o melhor exemplo que eu poderia encontrar em qualquer outro lugar.
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);
Esta é a minha solução para POST
e GET
.
Sobre o Post
método:
Se o corpo for um objeto JSON, é importante desserializá-lo JSON.stringify
e, possivelmente, definir o Content-Lenght
cabeçalho de acordo:
var bodyString=JSON.stringify(body)
var _headers = {
'Content-Length': Buffer.byteLength(bodyString)
};
antes de escrevê-lo na solicitação:
request.write( bodyString );
Sobre ambos Get
e Post
métodos:
O timeout
pode ocorrer como uma socket
desconexão, por isso você deve registrar seu manipulador como:
request.on('socket', function (socket) {
socket.setTimeout( self.timeout );
socket.on('timeout', function() {
request.abort();
if(timeout) return timeout( new Error('request timed out') );
});
});
enquanto o request
manipulador estiver
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') );
});
Eu sugiro fortemente registrar os dois manipuladores.
O corpo da resposta está em partes, portanto, você deve concatear partes no data
manipulador:
var body = '';
response.on('data', function(d) {
body += d;
});
No end
o body
conterá todo o corpo da resposta:
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());
}
});
É seguro quebrar com um try
... catch the
JSON.parse`, pois você não pode ter certeza de que é um json bem formatado, na verdade, e não há como ter certeza disso no momento em que você faz a solicitação.
Módulo: 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);
Uso:
// 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') );
});
Depois de lutar muito enquanto criava um utilitário de baixo nível para lidar com a postagem e obter solicitações para o meu projeto, decidi postar meu esforço aqui. Muito nas linhas de resposta aceita, aqui está um trecho para fazer solicitações http e https POST para enviar dados JSON.
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);
});
Ou você pode usar esta biblioteca:
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
biblioteca foi preterida.
O Axios é um cliente HTTP baseado em promessa para o navegador e o Node.js. O Axios facilita o envio de solicitações HTTP assíncronas para terminais REST e a execução de operações CRUD. Pode ser usado em JavaScript simples ou com uma biblioteca como Vue ou 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);
})
Postando outro exemplo de axios de uma solicitação axios.post que usa opções de configuração adicionais e cabeçalhos personalizados.
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);
})
Usando dependência de solicitação .
Solução simples:
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
vem?
Request-Promise
Fornece resposta baseada em promessas. códigos de resposta http diferentes de 2xx farão com que a promessa seja rejeitada. Isso pode ser substituído, definindo 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...
});