Como é feita uma solicitação HTTP POST no node.js?

946

Como posso fazer uma solicitação HTTP POST de saída, com dados, no node.js?

Marca
fonte
16
Conforme sugerido na resposta de Jed Watson , recomendo fortemente o uso de request, a menos que você esteja escrevendo uma API de baixo nível.
Namuol 31/05
4
Você pode usar apenas node-fetchuma implementação do fetchmétodo JavaScript nativo para fazer solicitações HTTP.
Fez Vrasta 13/08/16
Esta postagem aborda os cenários de uso básico para o uso de solicitação. blog.modulus.io/node.js-tutorial-how-to-use-request-module
Shaswat Rungta

Respostas:

855

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.readFilecomando 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.

onteria_
fonte
4
O cabeçalho do comprimento do conteúdo é calculado corretamente? Deveria ser bytes, certo?
Eric
7
Observe que querystring.stringify() não suporta objetos aninhados , portanto, você pode usar qs.stringify().
Johndodo
51
Content-Lengthsão bytes e não necessariamente o comprimento da string (UTF-16 etc). O uso Buffer.byteLength(data)sempre estará correto.
greenimpala
4
para enviar dados posteriores padrão, o objeto em querystring.stringifydeve 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
ROZZA
7
Gotcha: Se você estiver usando um site criptografado por SSL, precisará da biblioteca "https". Você não pode simplesmente alterar a porta para 443.
Dave Collins
1137

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

Jed Watson
fonte
153
{form: {key: 'value'}} deve ser substituído por {json: {key: 'value'}} (porque a pergunta não é específica para formulários). Também é preciso entender 'form' e 'json' são palavras-chave da biblioteca de solicitações e não fazem parte dos dados personalizados (por mais trivial que esse último comentário possa parecer, levei um tempo para descobrir ...)
blacelle
7
Continuo voltando a esta pergunta e resposta. Realmente deveria ser "a" resposta para a pergunta.
Spencer Kormos
6
Você merece um distintivo de ouro apenas para esta resposta. É muito mais útil que o aceito ... e já existia em 2012? Wow
Zoltán Schmidt
3
pode ser necessário adicionar dependência executando este comando 'npm install --save request'
Shady Sherif
18
Esta biblioteca foi preterida.
Evorlor 15/02
138

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);
});
Josiah Choi
fonte
Após a revisão em sua documentação. ele afirma o seguinte: json - define o corpo, mas a representação JSON do valor e adiciona o cabeçalho Content-type: application / json. Além disso, analisa o corpo da resposta como JSON. Isso significa que quando json = true, ele definirá o cabeçalho, json e body. Caso contrário, nenhum cabeçalho será definido e analise como texto. (Como o exemplo XML acima). Isso torna a API de solicitação prática e simplista, mas bastante difícil de entender na primeira vez.
Josias Choi
Está tecnicamente em seus documentos, mas nenhum dos exemplos mostra isso - apenas dados de formulário. É uma agulha no palheiro e, como tal, é uma omissão enorme, já que esta é a segunda maneira mais frequente de usar o ajax em JS, e certamente uma das mais comuns na web.
Kyle Baker
Usar request.post é um pouco melhor para o IMO do que especificar o POST como o método. Aqui estão alguns exemplos do GitHub para usar request.post
drorw 18/04/19
12
Esta biblioteca foi preterida.
Evorlor 15/02
44

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);
});
Grant Li
fonte
Eu tentei solicitar, nó-formulário-dados e superagente antes da agulha. A agulha foi a única que funcionou corretamente para mim ao tentar fazer o upload de um arquivo de formulário com várias partes.
Paul Young
35

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',
    })
})
mpen
fonte
Para que é utilizado o writemétodo req,write()?
Ari #
@Ari Que escreve o corpo da solicitação ... nodejs.org/api/…
mpen
21

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();
    });
ranm8
fonte
1
Ele não funciona para mim, ver o problema aqui: github.com/ranm8/requestify/issues/2
Erel Segal-Halevi
20

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 Unirestusa a requestbiblioteca.

O Unirest fornece métodos para acessar o objeto de solicitação diretamente.

Exemplo:

var Request = unirest.get('http://mockbin.com/request');
Levi Roberts
fonte
1
Outro descobri que parece muito bom é github.com/request/request que parece um pouco mais popular do que unirest pelo menos como esta escrito
Lochlan
Eu posso atestar para solicitar. É uma biblioteca muito boa. Acho que a solicitação fornece mais funcionalidade de baixo nível, portanto, é apropriado usá-la para aplicativos específicos. Quando não me preocupo necessariamente com as coisas de baixo nível, acho o Unirest adequado.
Levi Roberts
Por que a unirest seria considerada leve quando depende de solicitação? Solicitar em si tem 22 dependências, não vejo como isso é leve
raphadko
@raphadko Tenho certeza de que ao longo dos anos o inchaço dos recursos ocorreu. Certifique-se de verificar o timestamp de quando eu postei a minha resposta;)
Levi Roberts
17
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);
});
Giulio Roggero
fonte
existe uma maneira de exibir o corpo da postagem da solicitação na solicitação ou na resposta?
jacoballenwood
17

Existem dezenas de bibliotecas de código aberto disponíveis que você pode usar para fazer uma solicitação HTTP POST no Nó.

1. Axios (recomendado)

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

2. Agulha

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

3. Pedido

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

4. Módulo HTTPS nativo

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 .

attacomsian
fonte
14

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.

Piyush Sagar
fonte
1
Esta biblioteca foi preterida.
Yuri Tkachenko
12

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 fetchaos 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.

Pascal Belloncle
fonte
1
E em contraste com agulha, unirest e co, ele deliveres em ser leve (superagent: 16k, unirest: 1M, agulha: 530K)
Lars
9

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'})
Pujan Srivastava
fonte
6

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)
               }
    );
Prakhar Sharma
fonte
2
Nunca crie sua própria string de consulta. Você está deixando de codificar corretamente seus valores. Node.js tem uma biblioteca para este fim: nodejs.org/api/querystring.html
Brad
Esta biblioteca foi preterida.
Yuri Tkachenko
4

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);
user203687
fonte
4

Esta é a minha solução para POSTe GET.

Sobre o Postmétodo:

Se o corpo for um objeto JSON, é importante desserializá-lo JSON.stringifye, possivelmente, definir o Content-Lenghtcabeç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 Gete Postmétodos:

O timeoutpode ocorrer como uma socketdesconexã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 requestmanipulador 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 datamanipulador:

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

No endo bodyconterá 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 theJSON.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') );
    });
Loretoparisi
fonte
4

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

}
manyu
fonte
2
Você nunca usa o post_data serializado? escrever como objeto js é convertido em buffer por padrão?
ThatBrianDude
3
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);
Jitendra virani
fonte
requestbiblioteca foi preterida.
Yuri Tkachenko
3

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);
        })
abhinavxeon
fonte
2

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: "[email protected]",
  password: "password"
};

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

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

Matthew Rideout
fonte
0

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)
            }
        });
Shashwat Gupta
fonte
3
de onde requestvem?
CodyBugstein
Esta biblioteca foi preterida.
Yuri Tkachenko
0

Request-PromiseFornece 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...
});
veeresh yh
fonte